{"id":99,"date":"2006-12-05T10:09:21","date_gmt":"2006-12-05T15:09:21","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/?p=99"},"modified":"2019-10-22T16:36:41","modified_gmt":"2019-10-22T20:36:41","slug":"poly2mask-and-roipoly-part-1","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2006\/12\/05\/poly2mask-and-roipoly-part-1\/","title":{"rendered":"POLY2MASK and ROIPOLY – Part 1"},"content":{"rendered":"
\r\n

This is the first of several blogs about the algorithm behind poly2mask<\/tt> and roipoly<\/tt>. poly2mask<\/tt> takes a set of polygon vertices and produces a binary mask image. The binary mask has 1s for pixels inside the polygon and\r\n 0s for pixels outside.\r\n <\/p>\r\n

Here's a quick peek at what it does.<\/p>

x1 = [40 225 160 40];\r\ny1 = [230 170 45 230];\r\nmask = poly2mask(x1, y1, 300, 300);\r\nimshow(mask)\r\nhold on<\/span>\r\nplot(x1,y1,'LineWidth'<\/span>,3,'Color'<\/span>,'r'<\/span>);\r\nhold off<\/span><\/pre> 
Earlier versions of the Image Processing Toolbox just had roipoly<\/tt>. It contained both the core algorithm as well as a simple GUI for specifying the polygon vertices with mouse clicks.  A few\r\n      releases ago, we separated the core algorithm into its own function, poly2mask<\/tt>.  Now roipoly<\/tt> handles image display and grabbing mouse clicks, and it calls poly2mask<\/tt> for the computation.\r\n   <\/p>\r\n   
You can see that the computation might be nontrivial if you use a more complicated polygon, and if you zoom in a bit so you\r\n      can see what's going on along the polygon edges.  My second example computes a 25-by-25 mask, displays the mask using high\r\n      magnification, and displays a gray grid showing the edges of the pixels.\r\n   <\/p>
x2 = [10 24 5 15.5 10];\r\ny2 = [2 5 15 20.5 2];\r\nM = 25;\r\nN = 25;\r\n\r\nmask = poly2mask(x2,y2,25,25);\r\nmap = [255 255 255; 218 157 30] \/ 255;\r\nimshow(mask,map,'InitialMagnification'<\/span>,1000)\r\n\r\nhold on<\/span>\r\nxx = 0.5:1:N+0.5;\r\nyy = 0.5:1:M+0.5;\r\nfor<\/span> k = 1:numel(xx)\r\n    plot([xx(k) xx(k)], [0.5 M+0.5], 'Color'<\/span>, [.8 .8 .8]);\r\nend<\/span>\r\n\r\nfor<\/span> k = 1:numel(yy)\r\n    plot([0.5 N+0.5], [yy(k) yy(k)], 'Color'<\/span>, [.8 .8 .8]);\r\nend<\/span>\r\n\r\nplot(x2,y2,'LineWidth'<\/span>,2,'Color'<\/span>,[189 50 21]\/255);\r\nhold off<\/span><\/pre> 
The interesting pixels are those which are only partially inside the polygon.  How do we decide the mask value for those pixels?<\/p>\r\n   
In the computer graphics space, I believe the most common term for this operation is polygon scan conversion<\/i>.  If you do a Web search on this term you'll find lots of links, many of which go to computer graphics course notes.\r\n   <\/p>\r\n   
My own educational background is in electrical engineering, specializing in digital image and signal processing.  When I left\r\n      academia to become a software developer, implementing image processing algorithms, I found that many things I really needed\r\n      to know were in the computer graphics literature, not in the image processing literature.  (That's why the image processing\r\n      team has Graphics Gems<\/i> volumes 1-5 on our bookshelf.)  That is most certainly the case for polygon scan conversion.\r\n   <\/p>\r\n   
In my next blogs on this topic, I'll explain the desirable properties that a polygon scan conversion algorithm should have,\r\n      the special cases that tend to trip up simple implementations, and the details of the Image Processing Toolbox implementation.\r\n   <\/p>