ChatGPT解决这个技术问题 Extra ChatGPT

What is the difference between SVG and HTML5 Canvas?

What are the differences between SVG and HTML5 Canvas? They both seem to do the same to me. Basically, they both draw vector artwork using coordinate points.

What am I missing? What are the major differences between SVG and HTML5 Canvas? Why should I choose one over the other?

Wikipedia has a helpful article on this: Canvas versus Scalable Vector Graphics (SVG)
Canvas, as I understand it, doesn't provide for vector graphics. It's all about the bitmap.
possible duplicate of HTML5 Canvas vs SVG/VML?
Canvas are raster graphics and svgs are vector graphics which is scalable. Best explaination by sitePoint link : sitepoint.com/canvas-vs-svg-choosing-the-right-tool-for-the-job

J
JohnnySoftware

SVG is like a "draw" program. The drawing is specified as drawing instructions for each shape and any part of any shape can be changed. Drawings are shape-oriented.

Canvas is like a "paint" program. Once the pixels hit the screen, that is your drawing. You cannot change shapes except by overwriting them with other pixels. Paintings are pixel-oriented.

Being able to change drawings is very important for some programs; e.g. drafting apps, diagramming tools, etc. So SVG has an advantage here.

Being able to control individual pixels is important for some artistic programs.

Getting great animation performance for user-manipulation via mouse drags is easier with Canvas than SVG.

A single pixel on the computer screen will often consume 4 bytes of information and a computer screen these days takes several megabytes. So Canvas might be inconvenient if you want to let the user edit an image and then upload it again.

By contrast, drawing a handful of shapes that cover the entire screen using SVG takes up few bytes, downloads quickly, and can be uploaded again easily with the same advantages going in that direction as when it comes down on the other direction. So SVG can be faster than Canvas.

Google implemented Google Maps with SVG. That gives the web app its zippy performance and smooth scrolling.


Not going to vote you down - the new version of google maps actually uses canvas now, not svg. The svg version is now deprecated.
R
Rahul Sagore

See Wikipedia: http://en.wikipedia.org/wiki/Canvas_element

SVG is an earlier standard for drawing shapes in browsers. However, SVG is at a fundamentally higher level because each drawn shape is remembered as an object in a scene graph or DOM, which is subsequently rendered to a bit map. This means that if attributes of an SVG object are changed, the browser can automatically re-render the scene. In the example above, once the rectangle is drawn, the fact that it was drawn is forgotten by the system. If its position were to be changed, the entire scene would need to be redrawn, including any objects that might have been covered by the rectangle. But in the equivalent SVG case, one could simply change the position attributes of the rectangle and the browser would determine how to repaint it. It is also possible to paint a canvas in layers and then recreate specific layers. SVG images are represented in XML, and complex scenes can be created and maintained with XML editing tools. The SVG scene graph enables event handlers to be associated with objects, so a rectangle may respond to an onClick event. To get the same functionality with canvas, one must manually match the coordinates of the mouse click with the coordinates of the drawn rectangle to determine whether it was clicked. Conceptually, canvas is a lower level protocol upon which SVG might be built.[citation needed] However, this is not (normally) the case—they are independent standards. The situation is complicated because there are scene graph libraries for Canvas, and SVG has some bit map manipulation functionality.

UPDATE: I use SVG because of its markup language abilities - it can be processed by XSLT and can hold other markup in its nodes. Similarly I can hold SVG in my markup (chemistry). This allows me to manipulate SVG attributes (e.g. rendering) by combinations of markup. This may be possible in Canvas but I suspect that it's a lot harder.


The last sentence in the last paragraph needs a citation or two as well. SVG has no "bit map manipulation functionality", unless the author is trying to misrepresent svg filter effects as that, but it's far from clear what is meant.
@Erik I would agree with you. Looks like this WP entry needs editing
It sounds like for most applications, SVG is superior to Canvas. Is that true? Is there anything that Canvas can do that SVG can't?
I know it is years later but today there are many canvas libraries, like paper.js and fabric.js
svg is bad for performance because it uses the real dom to keep updating objects causing reflows, canvas is bad for usage because it doesnt track objects as individual entities, what if we had a canvas that uses virtual dom
F
Fizer Khan

High Level Summary of Canvas vs. SVG

Canvas

Pixel based (Dynamic .png) Single HTML element.(Inspect element in Developer tool. You can see only canvas tag) Modified through script only Event model/user interaction is granular (x,y) Performance is better with smaller surface, a larger number of objects (>10k), or both

SVG

Shape based Multiple graphical elements, which become part of the DOM Modified through script and CSS Event model/user interaction is abstracted (rect, path) Performance is better with smaller number of objects (<10k), a larger surface, or both

For detailed difference, read http://msdn.microsoft.com/en-us/library/ie/gg193983(v=vs.85).aspx


E
Erik Dahlström

There's a difference in what they are, and what they do for you.

SVG is a document format for scalable vector graphics.

Canvas is a javascript API for drawing vector graphics to a bitmap of a specific size.

To elaborate a bit, on format versus API:

With svg you can view, save and edit the file in many different tools. With canvas you just draw, and nothing is retained about what you just did apart from the resulting image on the screen. You can animate both, SVG handles the redrawing for you by just looking at the elements and attributes specified, while with canvas you have to redraw each frame yourself using the API. You can scale both, but SVG does it automatically, while with canvas again, you have to re-issue the drawing commands for the given size.


Perhaps the most fair and technically accurate of all the answers. SVG is document format, created either on server (mostly static) or on client itlsef. A canvas frame is nothing more than picture. So naturally it requires you to redraw which has its API.
S
Sam007

Two things that hit me the most for SVG and Canvas were,

Ability to use Canvas without the DOM, where as SVG depends heavily on DOM and as the complexity increases the performance slows down. Like in game design.

Advantage of using SVG would be that resolution remains the same across platforms which lacks in Canvas.

Lot more detail is provided in this site. http://dev.opera.com/articles/view/svg-or-canvas-choosing-between-the-two/


A
Aji

It is absolutely depends on your need/requirement.

If you want to just show an image/chart on a screen then recommended approach is canvas. (Example is PNG, GIF, BMP etc.)

If you want to extend the features of your graphics for example if you mouse over on the chart want to zoom certain area without spoil display quality then you select SVG. (Good example is AutoCAD, Visio, GIS files).

If you want build a dynamic flow diagram creator tool with shape connector it is better to select SVG rather than CANVAS.

When the size of the screen increases, canvas begins to degrade as more pixels need to be drawn.

When the number of objects increases on the screen, SVG begins to degrade as we are continually adding them to the DOM.

Also please refer : http://msdn.microsoft.com/en-us/library/gg193983(v=vs.85).aspx


P
Purushoth

SVG

Based on use case SVG is used for logos, charts because its vector graphics you draw and forgot about it. When view port change like re-sizing(or zoom) it will adjust itself and no need to redraw.

Canvas

Canvas is bitmap (or raster) it done by painting of pixels to the screen. It is used to develop games or graphics experience (https://www.chromeexperiments.com/webgl) in a given area it paints pixel and changes by redraw it another. Since its a raster type we need to redraw entirely as view port changes.

Reference

http://www.sitepoint.com/7-reasons-to-consider-svgs-instead-of-canvas

http://en.wikipedia.org/wiki/WebGL

http://vector-conversions.com/vectorizing/raster_vs_vector.html


c
ceving

SVG is a specification of a drawing like a file format. A SVG is a document. You can exchange SVG files like HTML files. And additionally because SVG elements and HTML elements share the same the DOM API, it is possible to use JavaScript to generate a SVG DOM in the same way as it is possible to create a HTML DOM. But you do not need JavaScript to generate SVG file. A simple text editor is enough to write a SVG. But you need at least a calculator to calculate the coordinates of the shapes in the drawing.

CANVAS is just a drawing area. It it necessary to use JavaScript to generate the contents of a canvas. You can not exchange a canvas. It is no document. And the elements of the canvas are not part of the DOM tree. You can not use the DOM API to manipulate the contents of a canvas. Instead you have to use a dedicated canvas API to draw shapes into the canvas.

The advantage of a SVG is, that you can exchange the drawing as a document. The advantage of the CANVAS is, that is has a less verbose JavaScript API to generate the contents.

Here is an example, which shows that you can achieve similar results, but the way how to do it in JavaScript is very different.

// Italic S in SVG (function () { const ns='http://www.w3.org/2000/svg'; let s = document.querySelector('svg'); let p = document.createElementNS (ns, 'path'); p.setAttribute ('id', 'arc'); p.setAttribute ('d', 'M 0.9 -0.9 a 0.8,0.4 -10 0,0 -0.9,0.9'); s.appendChild (p); let u = document.createElementNS (ns, 'use'); u.setAttribute ('href', '#arc'); u.setAttribute ('transform', 'rotate(180)'); s.appendChild (u); })(); // Italic S in CANVAS (function () { let c = document.querySelector('canvas'); let w = c.width = c.clientWidth; let h = c.height = c.clientHeight; let x = c.getContext('2d'); x.lineWidth = 0.05 * w; x.moveTo (w/2, h/2); x.bezierCurveTo (w*0.02, h*0.4, w*0.4, -h*0.02, w*0.95, h*0.05); x.moveTo (w/2, h/2); x.bezierCurveTo (w*(1-0.02), h*(1-0.4), w*(1-0.4), h*(1+0.02), w*(1-0.95), h*(1-0.05)); x.stroke(); })(); svg, canvas { width: 3em; height: 3em; } svg { vertical-align: text-top; stroke: black; stroke-width: 0.1; fill: none; } canvas { vertical-align: text-bottom; } div { float: left; }

VG
CANVA

As you can see the result is almost the same, but the JavaScript code is completely different.

SVG is created with the DOM API using createElement, setAttribute and appendChild. All graphics are in the attribute strings. SVG has more powerful primitives. The CANVAS for example has nothing equivalent to the SVG arc path. The CANVAS example tries to emulate the SVG arc with a Bezier curve. In SVG you can reuse elements in order to transform them. In the CANVAS you can not reuse elements. Instead you have to write a JavaScript function in order to call it twice. SVG has a viewBox which allows to use normalized coordinates, which simplifies rotations. In the CANVAS you have to calculate the coordinates yourself based of the clientWidth and clientHeight. And you can style all SVG elements with CSS. In the CANVAS you can not style anything with CSS. Because SVG is a DOM, you can assign event handlers to all SVG elements. The elements in the CANVAS have no DOM and no DOM event handlers.

But on the other hand the CANVAS code is much easier to read. You do not need to care about XML name spaces. And you can directly call the graphics functions, because you do not need to build a DOM.

The lesson is clear: if you quickly want to draw some graphics, use the CANVAS. If you need to share the graphics, like to style it with CSS or want to use DOM event handlers in your graphics, build an SVG.


N
Narayana Swamy

adding to the above points:

SVG is lightweight for transferring over web when compared to JPEG,GIF etc and also it scale extremely when resized without loosing the Quality.


V
Vasundhara

SVG It is Object Model-based. Is suitable for using large rendering areas. SVG provides any support for event handlers . Modification is allowed through script and CSS. SVG has Better scalability SVG is Vector based (composed of shapes). SVG is not suitable for Games graphics. SVG does not depend on resolution. SVG is capable for API animation. SVG is suitable for printing with high quality and any resolution.

Canvas elements

It is pixel based.

Is suitable for using small rendering

Canvas does not provide any recourse for event handlers.

Modification is allowed through script only.

Canvas has poor scalability.

Canvas is Raster based (composed of a pixel).

Canvas is suitable for games graphics.

Canvas is completely dependent on resolution.

Canvas has no any API for animation.

Canvas is not suitable for printing high quality and high resolution.