{"id":423,"date":"2016-02-24T14:35:06","date_gmt":"2016-02-24T19:35:06","guid":{"rendered":"https:\/\/blogs.mathworks.com\/graphics\/?p=423"},"modified":"2017-09-03T17:50:34","modified_gmt":"2017-09-03T21:50:34","slug":"on-the-grid","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/graphics\/2016\/02\/24\/on-the-grid\/","title":{"rendered":"On the Grid"},"content":{"rendered":"

One type of question that I'm often asked is about how to use various visualization techniques with what is sometimes called \"scatter data\". This is data that is a list of individual measurements. These measurements often have locations associated with them, but that's not enough for many visualization techniques. These techniques also want grid information. This is information about how the measurements connect to each other. Let's take a look at a couple of ways in which we can get this grid information.<\/p>

First we'll need some example data. Here I have 250 measurements. Each one has a 2D location and a value.<\/p>

npts = 250;\r\nrng default<\/span>\r\nx = 2*randn(npts,1);\r\ny = 2*randn(npts,1);\r\nv = sin(x) .* sin(y);\r\n<\/pre>
Scatter data, which is sometimes known as column data, gets its name from the fact that the scatter plot<\/a> is the one visualization technique which is really designed for this type of data.<\/p>
scatter(x,y,36,v,'filled'<\/span>)\r\ncolorbar\r\nxlim([-2*pi 2*pi])\r\nylim([-2*pi 2*pi])\r\n<\/pre>\"\" 
You can sort of see the pattern of v in that picture. If you squint hard enough. But it'd be a lot nicer if we had colors in between the dots. The pcolor function<\/a> can draw that kind of picture, but it needs a particular type of input known as a \"structured grid\". We can create this type of grid by using the meshgrid function<\/a>.<\/p>
[xg,yg] = meshgrid(linspace(-2*pi,2*pi,125));\r\nsize(xg)\r\nsize(yg)\r\n<\/pre>
\r\nans =\r\n\r\n   125   125\r\n\r\n\r\nans =\r\n\r\n   125   125\r\n\r\n<\/pre>
But that's just the grid. That's not enough. We also need to get our values onto the grid. One good way to do this is with scatteredInterpolant.<\/p>
F = scatteredInterpolant(x,y,v);\r\nvg = F(xg,yg);\r\nh = pcolor(xg,yg,vg);\r\n<\/pre>\"\" 
We don't really want to see the grid here, so I'll turn it off.<\/p>
h.EdgeColor = 'none'<\/span>;\r\n<\/pre>\"\" 
And add a colorbar so we can see what values we're getting.<\/p>
colorbar\r\n<\/pre>\"\" 
That looks pretty good, but not great. For one thing, the range of values is way too large. We can't possibly have sin(x)*sin(y) reaching values less than -2, can we?<\/p>
caxis([-1 1])\r\n<\/pre>\"\" 
And while the middle of the picture is pretty good, look at that big yellow blob in the upper left and the big blue blob on the bottom. Where did those come from?<\/p>
Both of these issues are because out at the edges of the grid scatteredInterpolant is extrapolating past the values we gave it, rather than interpolating between them. Extrapolation is almost always a fairly dicey operation. To do it successfully, you really need to know a lot about the data you're working with, and use a lot of care in choosing your extrapolation function.<\/p>
Often it's better to just discard the parts of the grid which require extrapolation. That's actually pretty easy to do. We just need to insert nans into the values at those points on the grid. We can find those points on the grid by using convhull<\/a> and inpolygon<\/a>.<\/p>
p = convhull(x,y);\r\nxp = x(p);\r\nyp = y(p);\r\ninmask = inpolygon(xg(:),yg(:), xp,yp);\r\nvg(~inmask) = nan;\r\nh = pcolor(xg,yg,vg);\r\nh.EdgeColor = 'none'<\/span>;\r\nxlim([-2*pi 2*pi])\r\nylim([-2*pi 2*pi])\r\ncaxis([-1 1])\r\ncolorbar\r\n<\/pre>\"\" 
I could use either the boundary function<\/a> or the alphaShape function<\/a> instead of convhull here.<\/p>
As you can see, boundary will be more aggressive about removing portions of the grid which are far away from any sample points. It also has a parameter which lets you adjust that.<\/p>
b = boundary(x,y);\r\ninmask = inpolygon(xg(:),yg(:), x(b),y(b));\r\n\r\nvg = F(xg,yg);\r\nvg(~inmask) = nan;\r\nh = pcolor(xg,yg,vg);\r\nh.EdgeColor = 'none'<\/span>;\r\nxlim([-2*pi 2*pi])\r\nylim([-2*pi 2*pi])\r\ncaxis([-1 1])\r\ncolorbar\r\n<\/pre>\"\" 
Another thing that is very important when you're gridding scatter data is choosing the right grid resolution. The scatteredInterpolant is going to work best when the resolution of the grid is close to the spacing of your original sample points. A grid that's too fine usually isn't a big problem (except for the amount of memory you consume), but if your grid is much coarser than the spacing of the input points, then you may see aliasing artifacts. That's because the scatteredInterpolant doesn't really low-pass filter for you. This issue can become quite challenging when the spacing between your sample points varies widely. A good grid resolution for one area of your data might not be appropriate for another area.<\/p>
But the \"structured grid\" isn't the only type of grid available to us. There's also what's known as an \"unstructured grid\". In a structured grid, we just lay out the values in a 2D array, and know that each one is connected to its immediate neighbors. In an unstructured mesh, we'll keep our columns of data values, and add an extra variable that lists how they're connected.<\/p>
BTW, I've always thought this naming convention was a little silly because the whole point of an unstructured grid is that you have to spell out the structure in detail. The word \"unstructured\" doesn't seem like a good description of that.<\/p>
The simplest type of unstructured grid is a \"triangle mesh\". In a triangle mesh, we have Nx3 array which is a list of triangles which each connect three of the original points. One easy way to create a triangle mesh is to use the delaunayTriangulation function.<\/p>
dt = delaunayTriangulation(x,y);\r\n<\/pre>
Once we have our triangle mesh, we can draw it using the trisurf function<\/a>.<\/p>
h = trisurf(dt.ConnectivityList,x,y,zeros(npts,1),v);\r\nh.FaceColor = 'interp'<\/span>;\r\nview(2)\r\nxlim([-2*pi 2*pi])\r\nylim([-2*pi 2*pi])\r\ncaxis([-1 1])\r\ncolorbar\r\n<\/pre>\"\" 
Again, I'll hide the grid.<\/p>
h.EdgeColor = 'none'<\/span>;\r\n<\/pre>\"\" 
There are some advantages to each of these two approaches.<\/p>
The triangle mesh is nice and compact, and it often has fewer gridding artifacts. In particular, it naturally handles that case where the spacing between the points varies a lot by placing more triangles where the data is sampled more finely.<\/p>
On the other hand, MATLAB has more visualization techniques which work on a structured grid. For example, I could use one of the contour functions<\/a> on the structured grid, but MATLAB doesn't come with a contour function that will work on triangle meshes, although you can find some on the File Exchange<\/a>.<\/p>
These two examples are just an introduction to the powerful tools that MATLAB provides for gridding scatter data. If you find one of them useful, you might want to explore the different options that scatteredInterpolant accepts, and some of the other functions<\/a> that are available. And you might also want to start a conversation on MATLAB Answers<\/a>. There are a number of people there who have experience with gridding different types of data.<\/p>