{"id":298,"date":"2015-09-17T11:16:24","date_gmt":"2015-09-17T15:16:24","guid":{"rendered":"https:\/\/blogs.mathworks.com\/graphics\/?p=298"},"modified":"2015-09-17T11:16:24","modified_gmt":"2015-09-17T15:16:24","slug":"what-is-a-contour","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/graphics\/2015\/09\/17\/what-is-a-contour\/","title":{"rendered":"What is a Contour?"},"content":{"rendered":"

What is a Contour?<\/h3>

Last year we explored how surfaces perform interpolation<\/a>. Today we're going to take a look at some closely related functions; the contour family. The family of contour functions consists contour<\/a>, contour3<\/a>, and contourf<\/a> and a couple of other minor ones.<\/p>

We'll start with a simple 7x5 array. We'll create a surface and a filled contour using contourf.<\/p>

rng default<\/span>\r\nz = randn(7,5)\r\n\r\na1 = subplot(1,2,1);\r\nh = surf(z);\r\nh.FaceColor = 'interp'<\/span>;\r\naxis tight<\/span>\r\n\r\na2 = subplot(1,2,2);\r\ncontourf(z)\r\n<\/pre>
\r\nz =\r\n\r\n    0.5377    0.3426    0.7147   -1.2075    0.2939\r\n    1.8339    3.5784   -0.2050    0.7172   -0.7873\r\n   -2.2588    2.7694   -0.1241    1.6302    0.8884\r\n    0.8622   -1.3499    1.4897    0.4889   -1.1471\r\n    0.3188    3.0349    1.4090    1.0347   -1.0689\r\n   -1.3077    0.7254    1.4172    0.7269   -0.8095\r\n   -0.4336   -0.0631    0.6715   -0.3034   -2.9443\r\n\r\n<\/pre>\"\" 
It's hard to see the relationship at first. But if we look straight down on the surface and square up the aspect ratio of the axes (and squint a little) we can see that they are related.<\/p>
axes(a1)\r\nview(2)\r\naxis([a1 a2],'equal'<\/span>)\r\n<\/pre>\"\" 
But, they certainly don't look the same though, do they?<\/p>
It's easier to see what's going on if we look at a single contour level. That's easy to do with contour by setting the LevelList property. With surface we can simulate it by adding a white plane a Z==0 to hide the part of the surface which is below that.<\/p>
axes(a1)\r\np = surface([1 5;1 5],[1 1; 7 7],zeros(2));\r\np.FaceColor = 'white'<\/span>;\r\np.EdgeColor = 'none'<\/span>;\r\n\r\naxes(a2)\r\ncontourf(z,'LevelList'<\/span>,0)\r\naxis equal<\/span>\r\ngrid on<\/span>\r\n<\/pre>\"\" 
They still don't look like they're showing the same thing though, do they? But look closely. Look at where the curve intersects the grid lines. The intersection points are the same in the two pictures. The differences are all between those intersection points. What we're seeing is the same thing we saw when we looked at surfaces. The interpolation function matters, and surface and contour use different interpolation functions.<\/p>
Last time<\/a> we learned about the piecewise linear interpolation that surface uses, and we wrote an interpsurf function to give use more control by using the interp2 function<\/a>. Let's try using that with interp2's linear method and see if that matches what contour is doing.<\/p>
axes(a1)\r\ninterpsurf(z,'linear'<\/span>)\r\np = surface([1 5;1 5],[1 1; 7 7],zeros(2));\r\np.FaceColor = 'white'<\/span>;\r\np.EdgeColor = 'none'<\/span>;\r\nview(2)\r\naxis tight<\/span>\r\naxis equal<\/span>\r\n<\/pre>\"\" 
No, they're still not the same. We can see that interpsurf is drawing curves in between the grid lines. You may remember that when we discussed the bilinear interpolation that interp2 is using here, we saw that it's giving us a quadratic equation of this form.<\/p>
$$f(x,y) = c_1 + c_2 x + c_3 y + c_4 x y$$<\/p>
This tells us that the curves we're seeing between the grids are actually segments of hyperbolas. But contour is drawing straight lines in between the grid. Its interpolation scheme is basically to do linear interpolation on each of the edges and then draw a straight line connecting them.<\/p>
But there's another important difference, isn't there? You can see that in the squares where the curve intersects all four sides, there are a couple of different ways to connect the intersections. These are called the ambiguous cases. There are a couple of different ways to decide which way to go in these cases, and the surface and contour functionss don't use the same technique. Can you spot the square where the two algorithms connected the intersections differently?<\/p>
We can use the same technique we used in the intersurf function to perform our own interpolation on the input to contour like this:<\/p>
axes(a2)\r\n[x, y] = meshgrid(1:5,1:7);\r\n[x2,y2] = meshgrid(1:.1:5,1:.1:7);\r\nz2 = interp2(x,y,z, x2,y2, 'linear'<\/span>);\r\ncontourf(x2,y2,z2,'LevelList'<\/span>,0)\r\naxis equal<\/span>\r\ngrid on<\/span>\r\n<\/pre>\"\" 
That looks pretty good, and it matches our surface, but when we go back to the default LevelList we can see that it still doesn't look very smooth. That's because bilinear interpolation is only C0 continuous<\/a> between 2x2 sections. This shows up as sudden changes of direction as the curves cross these boundaries.<\/p>
axes(a1)\r\ninterpsurf(z,'linear'<\/span>)\r\nview(2)\r\naxis tight<\/span>\r\naxis equal<\/span>\r\naxes(a2)\r\ncontourf(x2,y2,z2)\r\naxis equal<\/span>\r\ngrid on<\/span>\r\n<\/pre>\"\" 
We don't usually notice this too much with surfaces because the colors or lighting tends to soften these discontinuities in the derivative. But the hard edges in a contour make it very noticeable.<\/p>
What if we switch to a smoother interpolation method? For example, cubic.<\/p>
axes(a1)\r\ninterpsurf(z,'cubic'<\/span>)\r\nview(2)\r\naxis tight<\/span>\r\naxis equal<\/span>\r\naxes(a2)\r\nz2 = interp2(x,y,z, x2,y2, 'cubic'<\/span>);\r\ncontourf(x2,y2,z2)\r\naxis equal<\/span>\r\ngrid on<\/span>\r\n<\/pre>\"\" 
That looks pretty nice, doesn't it? Can you use that to create an interpcontourf function, just like the interpsurf function<\/a> we created last time?  But remember, there is no single \"correct\" interpolation scheme. You need to know something about the characteristics of your data to know which scheme is most appropriate. In some cases a very smooth interpolation method like cubic can result in a contour which makes your data look smoother than it really should.<\/p>
The contour and surface functions use the simplest and fastest interpolation schemes for their jobs. That's because you can always do preprocessing up front to get characteristics like smoother interpolation, but you really can't do preprocessing to get performance.<\/p>