You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 52.91.0.0/16 has been blocked (disabled) by ‪JJMC89‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 05:26, 2 September 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪Jon Kolbert‬. The reason given is Open proxy/Webhost: See the help page if you are affected .
- Start of block: 04:57, 27 November 2021
- Expiry of block: 04:57, 27 November 2024
Your current IP address is 52.91.194.66. The blocked range is 52.91.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((short description|Conversion of raster graphics into vector graphics))
((Multiple issues|
((Update|date=May 2023))
((Lead too short|date=April 2023))
))
In [[computer graphics]], '''image tracing''', '''raster-to-vector conversion''' or '''raster vectorization''' is the conversion of [[raster graphics]] into [[vector graphics]].

==Background==
[[File:Bitmap VS SVG.svg|right|300px|thumb|This image illustrates the difference between bitmap and vector images. The bitmap image is composed of a fixed set of pixels, while the vector image is composed of a fixed set of shapes. In the picture, scaling the bitmap reveals the pixels while scaling the vector image preserves the shapes.]]

An image does not have any structure: it is just a collection of marks on paper, grains in film, or pixels in a [[bitmap]]. While such an image is useful, it has some limits. If the image is magnified enough, its artifacts appear. The halftone dots, film grains, and pixels become apparent. Images of sharp edges become fuzzy or jagged. See, for example, [[pixelation]]. Ideally, a vector image does not have the same problem. Edges and filled areas are represented as mathematical curves or gradients, and they can be magnified arbitrarily (though of course the final image must also be [[rasterization|rasterized]] in to be rendered, and its quality depends on the quality of the rasterization algorithm for the given inputs).

The task in vectorization is to convert a two-dimensional image into a two-dimensional vector representation of the image. It is not examining the image and attempting to recognize or extract a three-dimensional model that may be depicted; i.e. it is not a [[Computer vision|vision system]]. For most applications, vectorization also does not involve [[optical character recognition]]; characters are treated as lines, curves, or filled objects without attaching any significance to them. In vectorization, the shape of the character is preserved, so artistic embellishments remain.

Vectorization is the inverse operation corresponding to [[rasterization]], as [[Integral|integration]] is to [[Derivative|differentiation]].  And, just as with these other two operations, while rasterization is fairly straightforward and algorithmic, vectorization involves the reconstruction of lost information and therefore requires [[heuristic]] methods.

Synthetic images such as maps, cartoons, logos, clip art, and technical drawings are suitable for vectorization. Those images could have been originally made as vector images because they are based on geometric shapes or drawn with simple curves.

Continuous tone photographs (such as live portraits) are not good candidates for vectorization. 

The input to vectorization is an image, but an image may come in many forms such as a photograph, a drawing on paper, or one of several [[Image_file_formats#Raster_formats|raster file formats]]. Programs that do raster-to-vector conversion may accept bitmap formats such as [[Tagged Image File Format|TIFF]], [[BMP file format|BMP]] and [[Portable Network Graphics|PNG]].

The output is a [[Image_file_formats#Vector_formats|vector file format]]. Common vector formats are [[Scalable Vector Graphics|SVG]], [[AutoCAD DXF|DXF]], [[Encapsulated PostScript|EPS]], [[Enhanced Metafile Format|EMF]] and [[Adobe Illustrator|AI]].

Vectorization can be used to update images or recover work. Personal computers often come with a simple paint program that produces a bitmap output file. These programs allow users to make simple illustrations by adding text, drawing outlines, and filling outlines with a specific color. Only the results of these operations (the pixels) are saved in the resulting bitmap; the drawing and filling operations are discarded. Vectorization can be used to recapture some of the information that was lost.

Vectorization is also used to recover information that was originally in a vector format but has been lost or has become unavailable. A company may have commissioned a logo from a graphic arts firm. Although the graphics firm used a vector format, the client company may not have received a copy of that format. The company may then acquire a vector format by scanning and vectorizing a paper copy of the logo.

==Process==
[[File:Mad scientist caricature.png|thumb|Original PNG file (16 kB)]]
[[File:Mad scientist.svg|thumb|Hand converted to SVG (49 kB)]]

Vectorization starts with an image.

===Manual===

The image can be vectorized manually. A person could look at the image, make some measurements, and then write the output file by hand. That was the case for the vectorization of a technical illustration about neutrinos. The illustration has a few geometric shapes and a lot of text; it was relatively easy to convert the shapes, and the SVG vector format allows the text (even subscripts and superscripts) to be entered easily.

The original image did not have any curves (except for the text), so the conversion is straightforward. Curves make the conversion more complicated. Manual vectorization of complicated shapes can be facilitated by the tracing function built into some [[Vector_graphics_editor|vector graphics editing programs]].

If the image is not yet in machine readable form, then it has to be scanned into a usable file format.

Once there is a machine-readable bitmap, the image can be imported into a [[Comparison of vector graphics editors|graphics editing program]] (such as [[Adobe Illustrator]], [[CorelDRAW]], or [[Inkscape]]).  Then a person can manually trace the elements of the image using the program's editing features. Curves in the original image can be approximated with lines, arcs, and Bézier curves. An illustration program allows spline knots to be adjusted for a close fit. Manual vectorization is possible, but it can be tedious.

Although graphics drawing programs have been around for a long time, artists may find the freehand drawing facilities awkward even when a drawing tablet is used. Instead of using a program, Pepper recommends making an initial sketch on paper. Instead of scanning the sketch and tracing it freehand in the computer, Pepper states: "Those proficient with a graphic tablet and stylus could make the following changes directly in CorelDRAW by using a scan of the sketch as an underlay and drawing over it. I prefer to use pen and ink, and a light table"; most of the final image was traced by hand in ink. Later the line-drawing image was scanned at 600&nbsp;dpi, cleaned up in a paint program, and then automatically traced with a program.<ref>((harvnb|Pepper|2005|pp=68–71))</ref> Once the black and white image was in the graphics program, some other elements were added and the figure was colored.

Similarly, Ploch recreated a design from a digital photograph. The JPEG was imported and some "basic shapes" were traced by hand and colored in the graphics drawing program; more complex shapes were handled differently. Ploch used a bitmap editor to remove the background and crop the more complex image components. He then printed the image and traced it by hand onto tracing paper to get a clean black and white line drawing. That drawing was scanned and then vectorized with a program.<ref>((harvnb|Ploch|2005|p=17))</ref>

===Automatic===
Some programs automate the vectorization process.  Example programs are [[Adobe Streamline]] (discontinued), Corel's PowerTRACE, and [[Potrace]]. Some of these programs have a command line interface while others are interactive that allow the user to adjust the conversion settings and view the result. Adobe Streamline is not only an interactive program, but it also allows a user to manually edit the input bitmap and the output curves. Corel's PowerTRACE is accessed through CorelDRAW; CorelDRAW can be used to modify the input bitmap and edit the output curves. Adobe Illustrator has a facility to trace individual curves.<ref>((harvnb|Adobe|1998|pp=100–101))</ref>

Automated programs can have mixed results. A program (PowerTRACE) was used to convert a PNG map to SVG. The program did a good job on the map boundaries (the most tedious task in the tracing) and the settings dropped out all the text (small objects). The text was manually re-inserted.

[[File:StrekenProvincieUtrecht.png|thumb|320px|left|Map in PNG format (13 kB)]]
[[File:StrekenProvincieUtrecht1.svg|thumb|320px|left|Map after automated conversion and touch up to re-add the labels and adjust colors (18 kB)]]

Other conversions may not go as well. The results depend on having high-quality scans, reasonable settings, and good algorithms.

Scanned images often have a lot of noise. The bitmap image may need a lot of work to clean it up. Erase stray marks and fill in lines and areas.

Corel advice: Put the image on a light table, cover it with [[vellum]] ([[tracing paper]]), and then manually ink the desired outlines. Then scan the vellum and use an automated raster-to-vector conversion program on that scan.

==Options==
[[File:Lines on Vellum 600dpi.png|thumb|upright=2.0|Although these lines may look solid, they are far from perfect. The lines were drawn on [[vellum]] with a fountain pen, a 0.7&nbsp;mm gel pen, and a 0.5&nbsp;mm HB pencil. The images were scanned at 600 pixels per inch with 24-bit RGB. The line widths end up being 10 to 14 pixels wide. The ink colors are not uniform and have [[specular reflection]]s that put light pixels within the lines. The pencil lines also have interior defects due to the roughness (tooth) of the paper. The scan also has some [[unsharp masking]] artifacts.]]

There are many different image styles and possibilities, and no single vectorization method works well on all images. Consequently, vectorization programs have many options that influence the result.

One issue is what the predominant shapes are. If the image is of a fill-in form, then it will probably have just vertical and horizontal lines of a constant width. The program's vectorization should take that into account. On the other hand, a CAD drawing may have lines at any angle, there may be curved lines, and there may be several line weights (thick for objects and thin for dimension lines). Instead of (or in addition to) curves, the image may contain outlines filled with the same color. Adobe Streamline allows users to select a combination of line recognition (horizontal and vertical lines), centerline recognition, or outline recognition.<ref>((harvnb|Adobe|1992|p=39))</ref> Streamline also allows small outline shapes to be thrown out; the notion is such small shapes are noise.<ref>((harvnb|Adobe|1992|pp=40–41))</ref> The user may set the noise level between 0 and 1000; an outline that has fewer pixels than that setting is discarded.

Another issue is the number of colors in the image. Even images that were created as black on white drawings may end up with many shades of gray. Some line-drawing routines employ anti-aliasing; a pixel completely covered by the line will be black, but a pixel that is only partially covered will be gray. If the original image is on paper and is scanned, there is a similar result: edge pixels will be gray. Sometimes images are compressed (e.g., JPEG images), and the compression will introduce gray levels.

Many of the vectorization programs will group same-color pixels into lines, curves, or outlined shapes.  If each possible color is grouped into its object, there can be an enormous number of objects. Instead, the user is asked to select a finite number of colors (usually less than 256), the image is reduced to using that many colors (this step is [[color quantization]]), and then the vectorization is done on the reduced image.<ref>((harvnb|Adobe|1992|p=53))</ref> For continuous tone images such as photographs, the result of color quantization is [[posterization]]. Gradient fills will also be posterized.<ref>((harvtxt|Adobe|1998|pp=348–350)) discusses [[colour banding|color banding]] in gradient fills.</ref>

Reducing the number of colors in an image is often aided by a histogram. The most common colors may be selected as the representatives, and other colors are mapped to their closest representative. When the number of colors is set to two, the user may be asked to make threshold and contrast settings.<ref>((harvnb|Adobe|1992|pp=54–55))</ref> A contrast setting looks for significant changes in pixel color rather than a particular color; consequently, it may ignore the gradual color variations in a [[color gradient|gradient fill]]. Once the outline has been extracted, the user can manually reintroduce the gradient fill.

The vectorization program will want to group a region of the same color into a single object. It can do that by making the region boundary exactly follow the pixel boundaries, but the result will be a boundary of often short orthogonal lines. The resulting conversion will also have the same pixelation problems that a bitmap has when it is magnified. Instead, the vectorization program needs to approximate the region boundary with lines and curves that closely follow the pixel boundaries but are not exactly the pixel boundaries. A tolerance parameter tells the program how closely it should follow the pixel boundaries.<ref>((harvnb|Adobe|1992|pp=59–60))</ref>

The end result of many vectorization programs are curves consisting of cubic [[Bézier curve]]s. A region boundary is approximated with several curve segments. To keep a curve smooth, the joints of two curves are constrained so the tangents match. One problem is determining where a curve bends so sharply that it should not be smooth.<ref>((harvnb|Itoh|Ohno|1993))</ref> The smooth portions of a curve are then approximated with a Bézier curve fitting procedure. Successive division may be used. Such a fitting procedure tries to fit the curve with a single cubic curve; if the fit is acceptable, then the procedure stops. Otherwise, it selects some advantageous point along the curve and breaks the curve into two parts. It then fits the parts while keeping the joint tangent. If the fit is still unacceptable, then it breaks the curve into more parts.<ref>((harvnb|Schneider|1990))</ref>

Some vectorizers are standalone programs, but many have interactive interfaces that allow a user to adjust the program parameters and quickly see the result. PowerTRACE, for example, can display the original image and preview the converted image so the user may compare them; the program also reports information such as the number of curves.<ref>((harvnb|Corel|2005|p=217))</ref>

== Example ==
<gallery mode="packed" heights="400px" style="text-align:left">
File:Radula diagram3.png|Original artwork in PNG format; 115 kB.
File:Radula diagram3 traced.svg|Traced with PowerTRACE using detailed logo, smoothing 40, detail +2.5; result: 50 colors, 94 curves, 2452 nodes, 96 kB.
</gallery>

On the right is an illustration showing the operation of the [[radula]] in mollusks. The upper portion is mostly a one-pen-width filled outline diagram, but it has a mesh gradient fill along the bottom of the shell and along the bottom of the food. It also has some artistic brushes on the upper left of the shell. The bottom portion of the illustration has four line weights and some small characters; the color fill is simple except for a gradient at the jagged lines.

The 531×879 pixel image was traced; 50 colors were used. Most (if not all) lines were lost; they were turned into black regions, and their effective line widths varied. The black outline around the blue food in the upper part disappeared. The gradient fills and brushed spots were lost to color quantization/posterization; some brush spots disappeared. Some letters survived the vectorization with distortion, but most letters were discarded. Losing the letters is not a big issue; post conversion editing would want to delete the annotation and replace it with text rather than curves. Thin lines crossing at a shallow angle made filled regions, and intersecting outlines of filled regions became confused; see lower right corner. The tracing also has some odd features. Many black outlines touch, so they become large, complicated, objects rather than just outlines for specific regions. Instead of just a background, a rectangular white region separates the two outlined rectangles. The objects labeled ''op'', ''rp'', and ''rr'' are not simple layered shapes; the desired result would have ''rr'' overlaid by ''rp'' which is overlaid by ''op''.

== Usage domains ==
*In [[computer-aided design]] (CAD) drawings ([[blueprint]]s etc.) are scanned, vectorized, and written as CAD files in a process called ''paper-to-CAD conversion'' or ''drawing conversion''.
*In [[geographic information system]]s (GIS) satellite or aerial images are vectorized to create [[geographical map|maps]].
*In [[graphic design]] and [[photography]], graphics can be vectorized for easier usage and resizing.
*Vectorization is often the first step in [[Optical Character Recognition|OCR]] solutions for handwritten text or [[signature]]s.

Vectorization is effective on single colored, nongradient input data, like signatures.
<gallery mode="packed" style="text-align:left">
File:Firma-colon.JPG|Signature of [[Christopher Columbus]] as [[JPEG]] image (1,308 × 481 pixel), 63&nbsp;[[Kilobyte|kB]]
File:Columbus Signature.svg|Vectorized two-color (black & white) variant of the signature of [[Christopher Columbus]], 19&nbsp;kB
</gallery>

===Continuous tone images===
Vectorization is usually inappropriate for continuous tone images such as portraits. The result is often poor. For example, many different image tracing algorithms were applied to a 25&nbsp;kB JPEG image. The resulting vector images are at least a factor of ten larger and may have pronounced posterization effects when a small number of colors are used.

<gallery mode="packed" heights="200" style="text-align:left" styles="text-align:left">
File:Silversmith.jpg|A photograph in [[JPEG]] format, 25&nbsp;KB
File:SilversmithRaveGrid.svg|The photograph at left vectorized with ''RaveGrid'', 1.64&nbsp;MB
File:Silversmith.svg|Same photograph vectorized with [[Comparison of raster-to-vector conversion software#autotrace|AutoTrace]] in the Delineate GUI, 677&nbsp;KB
File:Silversmith-inkscape.svg|Same photograph vectorized with [[Inkscape]]'s "Trace Bitmap" function, based on [[potrace]], 1.05&nbsp;MB
File:Silversmith-scan2cad.svg|Same photograph vectorized with [[Scan2CAD]], 340&nbsp;KB
File:SilversmithVectormagic-high-12colors.svg|''Vectormagic'', 12 colors, 369&nbsp;KB
File:SilversmithVectormagic-high-unlimitedcolors.svg|''Vectormagic'', all colors, 744&nbsp;KB
File:Silversmith vectorized12.svg|''Super Vectorizer'', 12 colors, 225&nbsp;KB
</gallery>

==See also==
* [[Rasterisation|Rasterization]]
* [[CAD data exchange]]
* [[Comparison of raster-to-vector conversion software]]
* [[Digitizing]]
* [[Discretization error]]
* [[Downsampling]]
* [[Feature detection (computer vision)]]
* [[Edge detection]]
* [[Image scanner]]
* [[Optical character recognition]]
* [[Quantization error]]
* [[Subpaving]]

==References==
((reflist|30em))

((refbegin|30em))
* ((citation |last=Adobe |title=Adobe Streamline User Guide |edition=version 3 for Windows |date=1992 |publisher=Adobe Systems |location=Mountain View, CA))
* ((citation |last=Adobe |title=Adobe Illustrator User Guide |edition=version 8.0 |date=August 1998 |publisher=Adobe Systems |location=Mountain View, CA |id=90012366))
* ((citation |last=Corel |series=CorelDRAW X3 Graphics Suite |title=User Guide |date=2005 |publisher=Corel Corporation |location=Ottawa, ON |pages=213–220))
* ((citation |last=Pepper |first=K. N. |chapter=Cartooning with CorelDRAW |pages=64–77 |editor-last=Corel |series=CorelDRAW X3 Graphics Suite |title=CorelDRAW Handbook: Insights from the Experts |date=2005 |publisher=Corel Corporation))
* ((citation |last=Ploch |first=Michael |chapter=Re-creating vintage designs on t-shirts |pages=12–23 |editor-last=Corel |series=CorelDRAW X3 Graphics Suite |title=CorelDRAW Handbook: Insights from the Experts |date=2005 |publisher=Corel Corporation))
*((Citation |last=Schneider |first=Philip J. |pages=612–626 |editor-last=Glassner |chapter=An Algorithm for Automatically Fitting Digitized Curves |editor-first=Andrew S. |date=1990 |title=Graphics Gems |publisher=Academic Press |location=Boston, MA |isbn=0-12-059756-X))
((refend))

==Further reading==
* ((citation |last1=Avrahami |first1=Gideon |last2=Pratt |first2=Vaughan |author2-link=Vaughan Pratt |chapter=Sub-pixel Edge Detection in Character Digitization |pages=54–64 |editor1-last=Morris |editor1-first=R. |editor2-last=André |editor2-first=J. |title=Raster Imaging and Digital Typography II |date=29 November 1991 |publisher=Cambridge University Press |isbn=9780521417648 |ref=none|chapter-url=https://books.google.com/books?id=Q9KtGcpfNgUC&dq=%22Sub-pixel+Edge+Detection+in+Character+Digitization%22&pg=PA54))
* ((citation |last1=Itoh |first1=Koichi |last2=Ohno |first2=Yoshio |title=A curve fitting algorithm for character fonts |journal=Electronic Publishing |volume=6 |issue=3 |pages=195–205 |date=September 1993 |publisher=John Wiley|citeseerx=10.1.1.39.537 ))

==External links==
* [http://howto.corel.com/index.php/Corel:Taking_Corel_PowerTRACE_for_a_Test_Drive Taking Corel PowerTRACE for a Test Drive]

[[Category:Computer graphics]]

Pages transcluded onto the current version of this page (help):

Image tracing (edit)
Template:Ambox (view source) (template editor protected)
Template:Ambox globe (view source) (template editor protected)
Template:Ambox globe current red (view source) (template editor protected)
Template:Citation (view source) (protected)
Template:Harvard citation no brackets (view source) (template editor protected)
Template:Harvard citation text (view source) (template editor protected)
Template:Harvnb (view source) (template editor protected)
Template:Harvtxt (view source) (template editor protected)
Template:Lead too short (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:Multiple issues (view source) (template editor protected)
Template:Multiple issues/styles.css (view source) (template editor protected)
Template:Pagetype (view source) (protected)
Template:Refbegin (view source) (template editor protected)
Template:Refbegin/styles.css (view source) (template editor protected)
Template:Refend (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:SDcat (view source) (protected)
Template:SUBJECTSPACE formatted (view source) (template editor protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Template:Update (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Disambiguation/templates (view source) (protected)
Module:Footnotes (view source) (template editor protected)
Module:Footnotes/anchor id list (view source) (template editor protected)
Module:Footnotes/anchor id list/data (view source) (template editor protected)
Module:Footnotes/whitelist (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (protected)
Module:Pagetype/setindex (view source) (protected)
Module:Pagetype/softredirect (view source) (protected)
Module:SDcat (view source) (protected)
Module:String (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Wikitext Parsing (view source) (protected)
Module:Yesno (view source) (protected)

Return to Image tracing.

Retrieved from "https://en.wikipedia.org/wiki/Image_tracing"