Cross Platform Scalable Vector Graphics with svgweb – A Record Aside

Pity Scalable Vector Graphics. It’s been an official commonplace since earlier than IE6 was launched but has by no means discovered a lot of an viewers on the net, actually not the one it deserves. Simply as SVG was beginning to set up some browser assist, alongside got here the canvas tag, stealing the thunder of dynamically generated client-side photos.

Article Continues Beneath

Regardless of all the eye being paid to canvas, there’s nonetheless a spot for good ole SVG, notably for builders seeking to change plug-ins like Flash for information visualization.

One of many causes that Flash has been a well-liked selection for information visualization is the wealthy graphics API that was launched a number of variations again. This graphics API, native to Flash’s programming language ActionScript, makes it potential to attract dynamic charts, graphs, and maps programmatically, based mostly on information or consumer enter—with out having to fiddle with any server-side middleware, and all within the browser. This was a revelation when it was launched and drove an excessive amount of innovation in interactive information graphics.

A couple of years in the past, Apple launched the canvas tag to permit builders constructing Dashboard widgets a mechanism to attract arbitrary shapes utilizing simply HTML. That proposal, as you little doubt are conscious, is now an official a part of the HTML5 spec. The drawing strategies canvas launched are literally fairly much like those that ActionScript builders have been utilizing for some time. The truth is, I’d wager that anybody who’s performed any dynamic drawing in Flash might transfer over to canvas fairly simply. I’d double-down on that wager and say that the similarity between drawing with ActionScript and canvas is at the very least partially accountable for canvas’ success.

There are additionally JavaScript-based drawing libraries like Raphaël—the truth is, you’ve most likely already seen Brian Suda’s glorious article on utilizing the Raphaël JavaScript library to render SVG dynamically within the browser. Raphaël is nice for abstracting plenty of the complexity of SVG and for working cross-browser, all the best way again to IE6; however one factor it doesn’t do is allow you to load exterior SVG information, much like how you’ll load a picture utilizing the img tag.

What does the flexibility to load an SVG file should do with something? Nicely, for one, it signifies that you need to use third celebration instruments like Illustrator or the superb (and free!) Inkscape for drawing your SVG photos, which might then be loaded and manipulated within the browser utilizing JavaScript. The distinction is all about the way you method the issue—ActionScript, canvas, and Raphaël allow you to draw photos programmatically with code, whereas SVG permits you to draw photos in a drawing instrument, load that picture right into a browser and add scripting.

To make all of this work, we’re going to be utilizing an open-source JavaScript library referred to as svgweb to load the SVG file, add occasions, and deal with cross-browser points. The best way svgweb handles older browsers, like IE, is actually fairly intelligent: Fairly than attempt to map SVG to IE’s proprietary drawing APIs—which is what Raphaël does—they constructed their very own SVG renderer in Flash. That Flash-based SVG renderer hundreds the exterior SVG information and in addition handles JavaScript occasions which can be handed from the browser, fully transparently.

The svgweb library detects if the browser has native SVG assist and, if not, it embeds the Flash shim that interprets SVG into Flash-native drawing instructions. (That is much like how some HTML5 audio and video gamers are utilizing Flash as a fallback for taking part in H.264 encoded video in browsers that don’t assist the video tag or H.264 encoded video.) DOM-style occasions are dealt with and handed backwards and forwards between the Flash shim and the browser so that you simply solely have to put in writing the occasion logic as soon as, in JavaScript, as a substitute of getting to put in writing ActionScript handlers as nicely. Which means svgweb brings SVG to one thing like 95% of browsers, together with cellular units just like the iPhone and iPad that deal with SVG natively. (Android units don’t at present assist native SVG rendering, however they’re engaged on it.)

Earlier than we go additional, I simply need to level out that I’m not advocating one technique over one other; I feel there’s truly room for canvas, Raphaël, and SVG. There’s most likely even overlap, which is nice information for builders as a result of it lets us decide the method that works finest for our circumstances. I’ve discovered that canvas appears notably nicely suited to instant, client-side raster graphic rendering; easy charts are an incredible use for canvas and the superb Flot library makes constructing charts with JavaScript extremely straightforward. SVG is nicely suited to displaying advanced shapes, like a map, that you simply would possibly desire to attract in an utility like Illustrator first after which use JavaScript to hyperlink dynamic information on prime of it.

An information map with SVG#section3

Right here’s a request my crew of designers and builders at will get on a regular basis: Create a map as an instance a information story. Maps are useful and we’ve developed a set of templates to rapidly publish them, a few of that are constructed on prime of present tile-based providers like Google or Bing, a few of that are customized Flash functions. A lot has already been mentioned concerning the energy of constructing on prime of one thing like Google maps and even rolling your individual tile-based map engine. For information graphics, nonetheless, tile-based maps will be overkill and even distracting; it’s good typically to have a customized drawing.

A traditional instance could be a nation-wide map displaying information by state, just like the purple/blue maps on election evening. For this instance, we’ll use information from the newest U.S. census to indicate which states gained or misplaced representatives.

Earlier than we get began, there’s one little bit of configuration to arrange. As a result of some browsers have a tough time loading the required script and Flash file instantly out of your laptop’s filesystem, it’s finest to serve them from an online server. You might add every thing to your internet host however you most likely have a webserver constructed proper into the pc you’re growing on. On a Mac, create a brand new folder referred to as svg-info within the Websites folder in your house listing, then go into System Preferences > Sharing and allow Net Sharing. Level an online browser to http://localhost/~your-username/svg-info (changing your-username along with your precise username) and also you’ll see your svg-info folder within the browser.

With that performed, you’re going to wish a map, in SVG. These can come from quite a lot of sources—the designer you’re working with might construct one in Illustrator or use a instrument like ArcGIS to generate one from a shapefile. Or you possibly can nab one from Wikipedia, which has an entire assortment of free SVG maps, together with a clean US map with every state as its personal labeled form. Correctly labeling every form is vital when it comes time to hyperlink the info with the map; fortuitously, SVG information have a DOM very similar to HTML information, with every state contained in its personal labeled node. That is positively one thing you’ll need to bear in mind if you happen to’re producing your individual maps or shapes.

This map’s a bit of large for many internet pages, so the very first thing you’ll need to do is measurement it down a bit of, utilizing Illustrator or Inkscape, each of which is able to open and edit SVG information natively. This already reveals one of many benefits of utilizing SVG—a designer can open and edit vector information utilizing the instruments she makes use of each day. I sized the map right down to 500 pixels huge in order that it will match on a web page. Be sure to measurement the containing doc down as nicely. (In Illustrator, go to File > Doc Setup > Edit Artboards then set “Match Artboard to Art work bounds” from the presets.)

Subsequent, you’ll want some information, which we’ll write into the web page as a desk to make it as accessible as potential. The desk will look one thing like this:

<desk id="results-data">
 <!-- snip! -->

Now, this desk doesn’t precisely replicate the kind of real-world complexities you run into with actual information, however it ought to do for our functions.

You would possibly ask why write out a desk in any respect if the aim is to indicate a graphic and the reply is all about making your information accessible. Search engine spiders and display screen readers, even JavaScript-aware ones, most likely received’t be capable to perceive the info in your map in any form of a significant manner, so this desk will assist them index your information. SVG is, in concept, extra accessible than raster graphics like JPEG, GIF, and PNG (for one, SVG is scalable so readers with low imaginative and prescient can zoom in with out shedding constancy) as a result of the picture itself is described as XML. The truth, nonetheless, is that assist for accessibility in SVG remains to be pretty nascent so you possibly can’t depend on display screen readers with the ability to entry the knowledge in SVG. A humble desk will work wonders right here.

With that information on the web page, now we’ll begin writing some JavaScript to do one thing extra fascinating with it. First, obtain the most recent svgweb information (the most recent official launch is from this previous August however a brand new one is coming any day now) and unzip them.

Open the svgweb folder you uncompressed, then open the src folder and duplicate svg.js, svg.swf, and to a folder in your webserver. Utilizing a subfolder like js is ok, simply ensure that to maintain all three information in the identical folder. Now, embrace the svg.js as the primary script tag within the head of your HTML file.

<script src=""></script>

Now, let’s write a perform that may seize the info from the desk and convert it right into a JSON object. Drop this in a script tag after the script supply to incorporate the svgweb library (Line wraps marked » —Ed.):

//convert desk to json
//@param t is the id of the desk (string)
//returns a json object with an array containing an object for every row
perform tableToJSON(t){
    var desk = doc.getElementById(t),
        header_row = desk.rows[0],
        n_headers = header_row.cells.size,
        n_rows = desk.rows.size,
        keys = [],
        n_keys = 0,
        json_data = [],
        json = {};    //rip via each row to create the JSON information objects
    //assume the primary row comprises the headers
    for(var i=0; i < n_rows; i++){
            for(var j=0; j < n_headers; j++){
        } else{
            var this_row = desk.rows[ i ]
            var information = {};
            n_keys = keys.size;            for( var j=0; j < n_keys; j++){
                information[keys[j]] = this_row.cells[j].firstChild.nodeValue;
            }            json_data.push(information);
        }    }    json[t] = json_data

There’s actually not a lot to this perform—it takes as a single parameter (the title of the desk) after which loops via each row to assemble and return a JSON object. It assumes the primary row of the desk are labels for every column, that are then used for every of the title worth pairs. Given the desk above, our JSON object will look one thing like:

{ "results-data": [
    {"state": "AL", "change": 0},
     //... snip! ...
    {"state": "WI", "change": 0}

(One fast manufacturing be aware: that is an try and preserve the code accessible with out delving too deeply into the trivia of backend implementations. Your wants would possibly require a separate JSON feed out of your database, as an example.)

Sufficient concerning the information, let’s add the map. We’re going to make use of an object tag to load the SVG map as an exterior useful resource, with a conditional remark to take care of IE. The IE-specific object makes use of a number of totally different parameters, particularly src as a substitute of information and classid as a substitute of sort. Additionally be aware that of the SVG information you load, most come from the identical supply (your webserver) because the HTML file itself—no cross-site scripting allowed.

<div id="results-map">
   <!--[if IE]-->
       <object src="" classid="picture/svg+xml"
           width="500" peak="375"
           id="state-map" alt="Interactive map graphic displaying»
electoral positive aspects and loses per state as of the 2010 census">
   <!--[if !IE]-->
       <object information="" sort="picture/svg" 
           width="500" peak="375"
           id="state-map" alt="Interactive map graphic displaying»
electoral positive aspects and loses per state as of the 2010 census">

This needs to be fairly easy—the src/information attribute (relying on the browser) factors to the SVG file; the width and peak needs to be set to at the very least as giant as the scale you saved the SVG file earlier. You must also give every object the identical id for later reference. Observe that setting the width or peak within the object tag received’t have an effect on the scale of the embedded file, simply the item containing it. If the item’s width/peak are smaller, you’ll see scrollbars; greater, you’ll have whitespace. The alt attributes will present some steering to bots and display screen readers.

For those who load this web page in your browser, you’ll see a grey map of the US of A. And if you happen to use the browser’s native zoom out and in, you’ll see that the graphic is, the truth is, scalable.

Now, it’s time to hyperlink the info to the map. As is so typically the case with JavaScript programming, you need to ensure that the map has loaded earlier than you attempt to entry it with a script. Happily, svgweb gives an onsvgload occasion that you would be able to pay attention for that fires as soon as the SVG has loaded. We’ll have it name an init perform that may deal with the data-to-map processing:

perform init(){}window.onsvgload = init;

Within that init perform, we have to first seize the map, utilizing the usual getElementById with an additional property, contentDocument, which lets us seize the SVG itself.

var map_svg = doc.getElementById('state-map').contentDocument;

When you’ve grabbed the SVG map, it behaves equally to an bizarre DOM object.

Subsequent, we’ll name our tableToJSON perform to get the info.

//tableToJSON will return a JSON object with our information
var map_json = tableToJSON('results-data');
//seize the precise array from the json object
var map_data = map_json['results-data'];
//get the array size so you do not calculate it»
for each loop iteration
var n_map_data = map_data.size;

Now, we simply loop via the outcomes and apply the info to our map.

//loop via the map information and assign properties»
to every state on the map
for(var i=0; i < n_map_data; i++){
    //get the state on the map based mostly on the ID within the information array
    //on this case, the ID is the state abbreviation
    var map_state = map_svg.getElementById(map_data[ i].state);    if(map_data[ i].change === '-2 or extra' ){
        map_state.model.fill = '#B26600';
    } else if (map_data[ i].change === '-1'){
        map_state.model.fill = '#FF9200';
    } else if (map_data[ i].change === '+1'){
        map_state.model.fill = '#19ABFF';
    } else if (map_data[ i].change === '+2 or extra'){
        map_state.model.fill = '#0071B2';
    }    //assign the state a title, on this case the title of the state»
and the change in seats
    map_state.title = map_data[ i].state + '»
can have a change of ' + map_data[ i].change + ' seats';    //give every state an occasion
    //for simplicity, the occasion is an easy alert that shows»
   the title param we simply assigned
    //sure, addEventListener even works in IE, due to svgweb
    map_state.addEventListener('mouseup', perform(e){
    }, false);

What this loop does is first search for any SVG node with an ID that matches the state in our information array—each are abbreviations resembling “AL” for Alabama. When it matches the state on the map to the state on our information array, it colours the state based on the change, from a darkish orange to darkish blue.

Lastly, we give every node a title tag. It will allow us to entry this data after we assign a click on handler to every state. You could discover that we use addEventListener, a DOM-but-not-IE-supported commonplace for listening for JavaScript occasions. Fortunately, the sensible people behind svgweb have dealt with that for us and have abstracted occasion dealing with to make use of the usual mannequin. It is a quite simple occasion that pops up a JavaScript alert with the title that we simply assigned.

SVG has held plenty of unrealized promise for over a decade now, with baked in assist lastly turning into mainstream (even IE9 will embrace native SVG rendering when it launches later this yr). In contrast to canvas or different script-only approaches, SVG will be simply divided into design and code parts, with just a bit code so as to add interactivity. It even works on units just like the iPad and iPhone. And now, due to svgweb and a intelligent use of Flash, it really works on older platforms nobody might have ever imagined supporting SVG.

It’s time so as to add SVG to our arsenal of instruments for constructing a tremendous internet.

Leave a Comment