Vega at a Glance

​Source code is located at the end of this topic.
This tutorial provides an overiew of Vega and a simple example to visualize tweets in the EMEA geographic region:
Defining the Source Data
The Vega JSON structure maps data to geometric primitives.
A first task is to specify the data source. You can either define data statically or use a SQL query. This examples uses a SQL query to get tweet geolocation information from a tweets database:
1
SELECT goog_x as x, goog_y as y, tweets_nov_feb.rowid FROM tweets_nov_feb
Copied!
The resulting SQL columns can be referenced in other parts of the specification to drive visualization elements. In this example, the projected columns are goog_x and goog_y, which are renamed x and y, and rowid, which is a requirement for hit-testing.
Creating a Visualization using Vega
The Vega specification for this example includes the following top-level properties:
height and width, which define the height and width of the visualization area.
data, which defines the data source. The SQL data described above is defined here with the label tweets for later referencing.
marks, which describes the geometric primitives used to render the visualization.
scales, which are referenced by marks to map input domain values to appropriate output range values.
Here is the full Vega specification used in this example:
1
const exampleVega = {
2
  "width": 384,
3
  "height": 564,
4
  "data": [
5
    {
6
      "name": "tweets",
7
      "sql": "SELECT goog_x as x, goog_y as y, tweets_nov_feb.rowid FROM tweets_nov_feb"
8
    }
9
  ],
10
  "scales": [
11
    {
12
      "name": "x",
13
      "type": "linear",
14
      "domain": [
15
        -3650484.1235206556,
16
        7413325.514451755
17
      ],
18
      "range": "width"
19
    },
20
    {
21
      "name": "y",
22
      "type": "linear",
23
      "domain": [
24
        -5778161.9183506705,
25
        10471808.487466192
26
      ],
27
      "range": "height"
28
    }
29
  ],
30
  "marks": [
31
    {
32
      "type": "points",
33
      "from": {
34
        "data": "tweets"
35
      },
36
      "properties": {
37
        "x": {
38
          "scale": "x",
39
          "field": "x"
40
        },
41
        "y": {
42
          "scale": "y",
43
          "field": "y"
44
        },
45
        "fillColor": "blue",
46
        "size": {
47
          "value": 3
48
        }
49
      }
50
    }
51
  ]
52
};
Copied!
The following sections describe the top-level Vega specification properties.
Define the Visualization Area Dimensions
The width and height properties define a visualization area 384 pixels wide and 564 pixels high:
1
"width": 384
2
"height": 564
Copied!
The scales position encoding properties map the marks into this visualization area.
Define the Marks
The marks property defines visualization geometric primitives. The OmniSci Vega implementation defines the following primitive types:
lines A line
points A point
polys A polygon
symbol A geometric symbol, such as a circle or square
Each primitive type has a set of properties that describe how the primitive is positioned and styled.
This example uses points to represent the tweets data:
1
"marks": [
2
  {
3
    "type": "points",
4
    "from": {
5
      "data": "tweets"
6
    },
7
    "properties": {
8
      "x": {
9
        "scale": "x",
10
        "field": "x"
11
      },
12
      "y": {
13
        "scale": "y",
14
        "field": "y"
15
      },
16
      "fillColor": "blue",
17
      "size": {
18
        "value": 3
19
      }
20
    }
21
  }
22
]
Copied!
Points support the following properties; not all are included in the example:
x The x position of the point in pixels.
y The y position of the point in pixels.
z The depth coordinate of the point in pixels.
fillColor The color of the point.
fillOpacity The opacity of the fill, from transparent (0) to opaque (1).
opacity The opacity of the point as a whole, from transparent (0) to opaque (1).
size The diameter of the point in pixels.
The points in the example reference the tweets SQL data and use the x and y columns from the SQL to drive the position of the points. The positions are appropriately mapped to the visualization area using scales as described in Scale Input Domain to Output Range. The fill color is set to blue and point size is set to three pixels.
Scale Input Domain to Output Range
The scales definition maps data domain values to visual range values, where the domain property determines the input domain for the scale. See the d3-scale reference for background information about how scaling works.
This example uses linear scales to map mercator-projected coordinates into pixel coordinates for rendering.
1
"scales": [
2
  {
3
    "name": "x",
4
    "type": "linear",
5
    "domain": [
6
      -3650484.1235206556,
7
      7413325.514451755
8
    ],
9
    "range": "width"
10
  },
11
  {
12
    "name": "y",
13
    "type": "linear",
14
    "domain": [
15
      -5778161.9183506705,
16
      10471808.487466192
17
    ],
18
    "range": "height"
19
  },
20
]
Copied!
The x and y scales use linear interpolation to map point x- and y-coordinates to the width and height of the viewing area. The width and height properties are predefined keywords that equate to the range [0, <current width>] and [0, <current height>].
After completing the Vega specification, you send the JSON structure to the backend for rendering.
Connecting to the Server and Rendering the Visualization
The following steps summarize the rendering and visualization sequence:
1.Instantiate the MapdCon object for connecting to the backend.
2.Call the connect method with server information, user credentials, and data table name.
3.Provide the renderVega() callback function to connect() and include the Vega specification as a parameter.
4.Display the returned PNG image in you client browser window.
OmniSci uses Apache Thrift for cross-language client communication with the backend. Include the browser-connector.js, connector API, which includes Thrift interface libraries and the renderVega() function:
1
<script src="js/browser-connector.js"></script>
Copied!
The following example encapsulates the connect, render request, and response handling sequence:
1
var vegaOptions = {}
2
var connector = new MapdCon()
3
  .protocol("http")
4
  .host("my.host.com")
5
  .port("6273")
6
  .dbName("omnisci")
7
  .user("omnisci")
8
  .password("changeme")
9
  .connect(function(error, con) {
10
    con.renderVega(1, JSON.stringify(exampleVega), vegaOptions, function(error, result) {
11
      if (error) {
12
        console.log(error.message);
13
      }
14
      else {
15
        var blobUrl = `data:image/png;base64,${result.image}`
16
        var body = document.querySelector('body')
17
        var vegaImg = new Image()
18
        vegaImg.src = blobUrl
19
        body.append(vegaImg)
20
      }
21
    });
22
  });
Copied!
Next Steps
This example demonstrated the basic concepts for understanding and using Vega. To become comfortable with Vega, try this example using your own OmniSci instance, changing the MapdCon() parameters according to match your host environment and database.
As you gain experience with Vega and begin writing your own applications, see the Reference for detailed information about Vega code.
Source Code
HTML
Vega at a Glance index.html
1
<!DOCTYPE html>
2
<html lang="en">
3
  <head>
4
    <title>OmniSci</title>
5
    <meta charset="UTF-8">
6
    <style>
7
      .title {
8
        font-weight: bold;
9
        text-align:center;
10
      }
11
      .omnisci {
12
        position: relative;
13
        top: 2px;
14
      }
15
      .search{
16
        displa"y": inline-block;
17
        margin-top: 12px;
18
        margin-left: 50px;
19
      }
20
      .data-count {
21
        padding-right:20px;
22
      }
23
      .filter-count {
24
        font-weight: bold;
25
        color:  #45B1E8;
26
      }
27
    </style>
28
  </head>
29
  <body>
30
​
31
    <script src="js/browser-connector.js"></script>
32
​
33
    <script>
34
​
35
    function init() {
36
      const exampleVega = {
37
        "width": 384,
38
        "height": 564,
39
        "data": [
40
          {
41
            "name": "tweets",
42
            "sql": "SELECT goog_x as x, goog_y as y, tweets_data_table.rowid FROM tweets_data_table"
43
          }
44
        ],
45
        "scales": [
46
          {
47
            "name": "x",
48
            "type": "linear",
49
            "domain": [
50
              -3650484.1235206556,
51
              7413325.514451755
52
            ],
53
            "range": "width"
54
          },
55
          {
56
            "name": "y",
57
            "type": "linear",
58
            "domain": [
59
              -5778161.9183506705,
60
              10471808.487466192
61
            ],
62
            "range": "height"
63
          }
64
        ],
65
        "marks": [
66
          {
67
            "type": "points",
68
            "from": {
69
              "data": "tweets"
70
            },
71
            "properties": {
72
              "x": {
73
                "scale": "x",
74
                "field": "x"
75
              },
76
              "y": {
77
                "scale": "y",
78
                "field": "y"
79
              },
80
              "fillColor": "blue",
81
              "size": {
82
                "value": 3
83
              }
84
            }
85
          }
86
        ]
87
      };
88
​
89
       var vegaOptions = {}
90
       var connector = new MapdCon()
91
         .protocol("http")
92
         .host("my.host.com")
93
         .port("6273")
94
         .dbName("omnisci")
95
         .user("omnisci")
96
         .password("changeme")
97
         .connect(function(error, con) {
98
           con.renderVega(1, JSON.stringify(exampleVega), vegaOptions, function(error, result) {
99
             if (error) {
100
               console.log(error.message);
101
             }
102
             else {
103
               var blobUrl = `data:image/png;base64,${result.image}`
104
               var body = document.querySelector('body')
105
               var vegaImg = new Image()
106
               vegaImg.src = blobUrl
107
               body.append(vegaImg)
108
             }
109
           });
110
         });
111
    }
112
​
113
    document.addEventListener('DOMContentLoaded', init, false);
114
    </script>
115
  </body>
116
</html>
Copied!

Vega Tutorials

Getting Started with Vega

Last modified 1yr ago

Export as PDF

Copy link

Contents

Defining the Source Data

Creating a Visualization using Vega

Define the Visualization Area Dimensions

Define the Marks

Scale Input Domain to Output Range

Connecting to the Server and Rendering the Visualization

Next Steps

Source Code

HTML