{"id":1188,"date":"2015-07-01T13:46:23","date_gmt":"2015-07-01T18:46:23","guid":{"rendered":"https:\/\/blogs.mathworks.com\/loren\/?p=1188"},"modified":"2017-09-24T19:33:31","modified_gmt":"2017-09-25T00:33:31","slug":"natural-neighbor-a-superb-interpolation-method","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/loren\/2015\/07\/01\/natural-neighbor-a-superb-interpolation-method\/","title":{"rendered":"Natural Neighbor &#8211; A Superb Interpolation Method"},"content":{"rendered":"<div class=\"content\"><!--introduction--><p>I'm happy to welcome Damian Sheehy as this week's guest blogger. Damian works on the development of geometry-related features at MathWorks. He will provide answers to two frequently asked questions; one on scattered data interpolation that he will cover in this blog and the other on Delaunay triangulation that he will cover in the next. Over to you, Damian...<\/p><!--\/introduction--><h3>Contents<\/h3><div><ul><li><a href=\"#c8276392-4979-462d-bf6c-f798fd779fc7\">An Email from Customer Support<\/a><\/li><li><a href=\"#c491d6ad-1368-407f-995f-19b7f7cb242d\">Why <tt>griddata<\/tt> or <tt>scatteredInterpolant<\/tt> May Be Inconsistent<\/a><\/li><li><a href=\"#7a01ea34-8c73-458e-9b8e-e630cff78318\">Example of Inconsistent Behavior in Linear Interpolation<\/a><\/li><li><a href=\"#751036ed-b908-46fb-a9e4-d118d46b160e\">Why Natural Neighbor Interpolation is Superior<\/a><\/li><li><a href=\"#bf52fed3-9df2-40ce-bec8-55caa4255249\">You Tell Me!<\/a><\/li><\/ul><\/div><h4>An Email from Customer Support<a name=\"c8276392-4979-462d-bf6c-f798fd779fc7\"><\/a><\/h4><p>I occasionally get an email from customer support with a title similar to this one: \"griddata gives different results. . . \".  The support engineers are great, they really know how to choose a good subject line that will get a developer's attention and get a response back to the customer quickly. The subject line could equally well cite <tt>scatteredInterpolant<\/tt> as it shares the same underlying code as <a href=\"https:\/\/www.mathworks.com\/help\/matlab\/ref\/griddata.html\"><tt>griddata<\/tt><\/a>. Before I open the email I have a strong suspicion about the cause of the difference. If the first line opens with this: \"A customer upgraded to MATLAB R20** and <tt>griddata<\/tt> gives different results to the previous . . .\", then I'm fairly confident what the problem is. I look at the customer's dataset, perform a couple of computations, create a plot, and bingo!, I have a canned response and recommendation at the ready and I turn around the question in a matter of minutes.<\/p><h4>Why <tt>griddata<\/tt> or <tt>scatteredInterpolant<\/tt> May Be Inconsistent<a name=\"c491d6ad-1368-407f-995f-19b7f7cb242d\"><\/a><\/h4><p>So why should <tt>griddata<\/tt> or <tt>scatteredInterpolant<\/tt> give different answers after upgrading MATLAB? What has MathWorks done to address this problem? Are there issues with scattered data interpolation that users should be aware of? Yes, there are some subtle behaviors associated with the Nearest Neighbor and Linear interpolation methods for scattered data interpolation.  These problems present themselves in specific datasets and the effects may show up as numerical differences after a MATLAB upgrade. I will explain the origin of these problems and the options you have as a user to avoid them altogether. I will also highlight what MathWorks has done to address the problems.<\/p><p>First, let's take a look at the behavior and the data that triggers the problem. To demonstrate, I will choose a simple data set where we have four points at the corners of a square. Each sample point has a different value associated with it and our goal is to compute an interpolated value at some query point within the square. Here's a diagram:<\/p><pre class=\"codeinput\">Px = [0; 1; 1; 0];\r\nPy = [0; 0; 1; 1];\r\nV = [10; 1000; 50; 100];\r\nplot(Px, Py, <span class=\"string\">'or'<\/span>)\r\nhold <span class=\"string\">on<\/span>\r\ntext(Px+0.02, Py+0.02, {<span class=\"string\">'P1 (10)'<\/span>, <span class=\"string\">'P2 (1000)'<\/span>, <span class=\"string\">'P3 (50)'<\/span>, <span class=\"string\">'P4 (100)'<\/span>})\r\npq = [0.5 0.5];\r\nplot(pq(:,1), pq(:,2), <span class=\"string\">'*b'<\/span>)\r\nhold <span class=\"string\">off<\/span>\r\naxis <span class=\"string\">equal<\/span>\r\n<\/pre><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/blogs.mathworks.com\/images\/loren\/2015\/NaturalNeighborBlog_01.png\" alt=\"\"> <p>First, let's consider the Nearest Neighbor interpolation method.  For any query point within the square, the interpolated value is the value associated with the nearest neighbor. The figure shown above illustrates the configuration and sample values in parenthesis. We can see an ambiguity arises when the query point lies at the center of the square. There are four possible interpolation solutions and based on the definition of the method any of the four values is a valid solution. Ideally, we would like to have the same result, no matter what computer MATLAB is running on and no matter what version.<\/p><p>This type of problem can also arise with the Linear interpolation method. To perform linear interpolation, the scattered dataset is first triangulated using a Delaunay triangulation. The interpolated value at a query point is then derived from the values of the vertices of the triangle that enclose the point. But a Delaunay triangulation of this dataset is not unique, the illustration below shows two valid configurations.<\/p><pre class=\"codeinput\">subplot(1,2,1);\r\nPx = [0; 1; 1; 0; 0; 1];\r\nPy = [0; 0; 1; 1; 0; 1];\r\npq = [0.5 0.25];\r\nplot(Px, Py, <span class=\"string\">'-b'<\/span>)\r\nhold <span class=\"string\">on<\/span>\r\nplot(pq(:,1), pq(:,2),<span class=\"string\">'or'<\/span>)\r\nhold <span class=\"string\">off<\/span>\r\naxis <span class=\"string\">equal<\/span>\r\nsubplot(1,2,2);\r\nPx = [0; 0; 1; 1; 0; 1];\r\nPy = [1; 0; 0; 1; 1; 0];\r\nplot(Px, Py, <span class=\"string\">'-b'<\/span>)\r\nhold <span class=\"string\">on<\/span>\r\nplot(pq(:,1), pq(:,2),<span class=\"string\">'or'<\/span>)\r\nhold <span class=\"string\">off<\/span>\r\naxis <span class=\"string\">equal<\/span>\r\n<\/pre><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"https:\/\/blogs.mathworks.com\/images\/loren\/2015\/NaturalNeighborBlog_02.png\" alt=\"\"> <h4>Example of Inconsistent Behavior in Linear Interpolation<a name=\"7a01ea34-8c73-458e-9b8e-e630cff78318\"><\/a><\/h4><p>The interpolated result is different in each scenario. The code to demonstrate this is given in the frame below, I have perturbed one data point to flip the diagonal of the triangulation and illustrate the effect.<\/p><pre class=\"codeinput\">P = [0 0; 1 0; 1 1; eps (1-eps);];\r\nV = [10; 1000; 50; 100];\r\npq = [0.5 0.25];\r\n\r\nF = scatteredInterpolant(P,V);\r\nlinearVq = F(pq)\r\n\r\nP = [0 0; 1 0; 1 1; -eps (1+eps);];\r\nF.Points = P;\r\nlinearVq = F(pq)\r\n<\/pre><pre class=\"codeoutput\">linearVq =\r\n        527.5\r\nlinearVq =\r\n        267.5\r\n<\/pre><h4>Why Natural Neighbor Interpolation is Superior<a name=\"751036ed-b908-46fb-a9e4-d118d46b160e\"><\/a><\/h4><p>The interpolated value at the query point, <tt>linearVq<\/tt>, is sensitive to how the triangulation edge is created in the tiebreak case. This tiebreak is called a degeneracy and the problem arises in Delaunay triangulations when we have 4 or more cocircular points in 2-D or 5 or more cospherical points in 3-D. Now observe the behavior when we choose the Natural Neighbor interpolation method. This method is also based on an underlying Delaunay triangulation, but it produces the same result in the presence of a diagonal edge swap. Here it is:<\/p><pre class=\"codeinput\">P = [0 0; 1 0; 1 1; eps (1-eps);];\r\nF.Points = P;\r\nF.Method = <span class=\"string\">'natural'<\/span>;\r\nnaturalVq = F(pq)\r\n\r\nP = [0 0; 1 0; 1 1; -eps (1+eps);];\r\nF.Points = P;\r\nnaturalVq = F(pq)\r\n<\/pre><pre class=\"codeoutput\">naturalVq =\r\n        397.5\r\nnaturalVq =\r\n        397.5\r\n<\/pre><p>Natural Neighbor is also a smoother interpolating function, so it makes a lot of sense to favor Natural Neighbor over Linear.  Well that begs the question: shouldn&#8217;t the Natural Neighbor method be the default? This would be our preferred choice of default, but this method was added to MATLAB long after the <tt>griddata<\/tt> Linear method was introduced. Changing a default would have a significant impact, so the change would be more disruptive than the problem it addresses. The Natural Neighbor method is also more computationally expensive, so for large datasets Linear may be preferred for performance reasons.<\/p><p>The example we just reviewed highlights the nature of the problem and gives you a more stable alternative to avoid potential differences from scattered data interpolation after you upgrade MATLAB.  For our part here in development, we have long recognized these types of issues create problems for users and we have adopted better underlying algorithms to address them. If you are a long-time user of MATLAB and the <tt>griddata<\/tt> function, you may recall more annoying past behavior. Prior to R2009a, repeated calls to the function using the now redundant <tt>{'QJ'}<\/tt> Qhull option gave potentially different results on each call. That problem was resolved in R2009a along with the introduction of Natural Neighbor interpolation for its stability and superior interpolation properties. Since then, improvements in the underlying triangulation algorithms have led to stable and consistent results across all platforms, first for 2-D and then for 3-D. Unfortunately, introducing these improvements meant a potential change in behavior of the upgrade for specific datasets, but that's like having to break eggs to make cake. Looking ahead, the behavior of Delaunay triangulation based functions should be much more stable. Of course, fundamental changes to the coded algorithm are likely to trigger changes like the ones we've seen, though the scope of the problem has been reduced substantially.<\/p><h4>You Tell Me!<a name=\"bf52fed3-9df2-40ce-bec8-55caa4255249\"><\/a><\/h4><p>I haven't received many support escalations questions related to Natural Neighbor interpolation since it shipped in R2009a. I often wonder if this is because it is working well for users or if users may not be using it. The similar naming to Nearest Neighbor interpolation may cause some to misunderstand the method. How about you, have you used Natural Neighbor interpolation and how has it worked out?  Let me know <a href=\"https:\/\/blogs.mathworks.com\/loren\/?p=1188#respond\">here<\/a>.<\/p><script language=\"JavaScript\"> <!-- \r\n    function grabCode_582e609b58184b9dbc472d47811e5d16() {\r\n        \/\/ Remember the title so we can use it in the new page\r\n        title = document.title;\r\n\r\n        \/\/ Break up these strings so that their presence\r\n        \/\/ in the Javascript doesn't mess up the search for\r\n        \/\/ the MATLAB code.\r\n        t1='582e609b58184b9dbc472d47811e5d16 ' + '##### ' + 'SOURCE BEGIN' + ' #####';\r\n        t2='##### ' + 'SOURCE END' + ' #####' + ' 582e609b58184b9dbc472d47811e5d16';\r\n    \r\n        b=document.getElementsByTagName('body')[0];\r\n        i1=b.innerHTML.indexOf(t1)+t1.length;\r\n        i2=b.innerHTML.indexOf(t2);\r\n \r\n        code_string = b.innerHTML.substring(i1, i2);\r\n        code_string = code_string.replace(\/REPLACE_WITH_DASH_DASH\/g,'--');\r\n\r\n        \/\/ Use \/x3C\/g instead of the less-than character to avoid errors \r\n        \/\/ in the XML parser.\r\n        \/\/ Use '\\x26#60;' instead of '<' so that the XML parser\r\n        \/\/ doesn't go ahead and substitute the less-than character. \r\n        code_string = code_string.replace(\/\\x3C\/g, '\\x26#60;');\r\n\r\n        copyright = 'Copyright 2015 The MathWorks, Inc.';\r\n\r\n        w = window.open();\r\n        d = w.document;\r\n        d.write('<pre>\\n');\r\n        d.write(code_string);\r\n\r\n        \/\/ Add copyright line at the bottom if specified.\r\n        if (copyright.length > 0) {\r\n            d.writeln('');\r\n            d.writeln('%%');\r\n            if (copyright.length > 0) {\r\n                d.writeln('% _' + copyright + '_');\r\n            }\r\n        }\r\n\r\n        d.write('<\/pre>\\n');\r\n\r\n        d.title = title + ' (MATLAB code)';\r\n        d.close();\r\n    }   \r\n     --> <\/script><p style=\"text-align: right; font-size: xx-small; font-weight:lighter;   font-style: italic; color: gray\"><br><a href=\"javascript:grabCode_582e609b58184b9dbc472d47811e5d16()\"><span style=\"font-size: x-small;        font-style: italic;\">Get \r\n      the MATLAB code <noscript>(requires JavaScript)<\/noscript><\/span><\/a><br><br>\r\n      Published with MATLAB&reg; R2015a<br><\/p><\/div><!--\r\n582e609b58184b9dbc472d47811e5d16 ##### SOURCE BEGIN #####\r\n%% Natural Neighbor - A Superb Interpolation Method\r\n% I'm happy to welcome Damian Sheehy as this week's guest blogger. Damian\r\n% works on the development of geometry-related features at MathWorks. He\r\n% will provide answers to two frequently asked questions; one on scattered\r\n% data interpolation that he will cover in this blog and the other on\r\n% Delaunay triangulation that he will cover in the next. Over to you,\r\n% Damian...\r\n% \r\n%% An Email from Customer Support\r\n% I occasionally get an email from customer support with a title similar to\r\n% this one: \"griddata gives different results. . . \".  The support\r\n% engineers are great, they really know how to choose a good subject line\r\n% that will get a developer's attention and get a response back to the\r\n% customer quickly. The subject line could equally well cite\r\n% <https:\/\/www.mathworks.com\/help\/matlab\/ref\/scatteredinterpolant-class.html\r\n% |scatteredInterpolant|> as it shares the same underlying code as\r\n% <https:\/\/www.mathworks.com\/help\/matlab\/ref\/griddata.html |griddata|>.\r\n% Before I open the email I have a strong suspicion about the cause of the\r\n% difference. If the first line opens with this: \"A customer upgraded to\r\n% MATLAB R20** and |griddata| gives different results to the previous . .\r\n% .\", then I'm fairly confident what the problem is. I look at the\r\n% customer's dataset, perform a couple of computations, create a plot, and\r\n% bingo!, I have a canned response and recommendation at the ready and I\r\n% turn around the question in a matter of minutes.\r\n% \r\n%% Why |griddata| or |scatteredInterpolant| May Be Inconsistent\r\n% So why should |griddata| or |scatteredInterpolant| give different answers\r\n% after upgrading MATLAB? What has MathWorks done to address this problem?\r\n% Are there issues with scattered data interpolation that users should be\r\n% aware of? Yes, there are some subtle behaviors associated with the\r\n% Nearest Neighbor and Linear interpolation methods for scattered data\r\n% interpolation.  These problems present themselves in specific datasets\r\n% and the effects may show up as numerical differences after a MATLAB\r\n% upgrade. I will explain the origin of these problems and the options you\r\n% have as a user to avoid them altogether. I will also highlight what\r\n% MathWorks has done to address the problems.\r\n% \r\n% First, let's take a look at the behavior and the data that triggers the\r\n% problem. To demonstrate, I will choose a simple data set where we have\r\n% four points at the corners of a square. Each sample point has a different\r\n% value associated with it and our goal is to compute an interpolated value\r\n% at some query point within the square. Here's a diagram:\r\n\r\nPx = [0; 1; 1; 0];\r\nPy = [0; 0; 1; 1];\r\nV = [10; 1000; 50; 100];\r\nplot(Px, Py, 'or')\r\nhold on\r\ntext(Px+0.02, Py+0.02, {'P1 (10)', 'P2 (1000)', 'P3 (50)', 'P4 (100)'})\r\npq = [0.5 0.5];\r\nplot(pq(:,1), pq(:,2), '*b')\r\nhold off\r\naxis equal\r\n\r\n%%\r\n% First, let's consider the Nearest Neighbor interpolation method.  For any\r\n% query point within the square, the interpolated value is the value\r\n% associated with the nearest neighbor. The figure shown above illustrates\r\n% the configuration and sample values in parenthesis. We can see an\r\n% ambiguity arises when the query point lies at the center of the square.\r\n% There are four possible interpolation solutions and based on the\r\n% definition of the method any of the four values is a valid solution.\r\n% Ideally, we would like to have the same result, no matter what computer\r\n% MATLAB is running on and no matter what version.\r\n% \r\n% This type of problem can also arise with the Linear interpolation method.\r\n% To perform linear interpolation, the scattered dataset is first\r\n% triangulated using a Delaunay triangulation. The interpolated value at a\r\n% query point is then derived from the values of the vertices of the\r\n% triangle that enclose the point. But a Delaunay triangulation of this\r\n% dataset is not unique, the illustration below shows two valid\r\n% configurations.\r\n\r\nsubplot(1,2,1);\r\nPx = [0; 1; 1; 0; 0; 1];\r\nPy = [0; 0; 1; 1; 0; 1];\r\npq = [0.5 0.25];\r\nplot(Px, Py, '-b')\r\nhold on\r\nplot(pq(:,1), pq(:,2),'or')\r\nhold off\r\naxis equal\r\nsubplot(1,2,2);\r\nPx = [0; 0; 1; 1; 0; 1];\r\nPy = [1; 0; 0; 1; 1; 0];\r\nplot(Px, Py, '-b')\r\nhold on\r\nplot(pq(:,1), pq(:,2),'or')\r\nhold off\r\naxis equal\r\n\r\n%% Example of Inconsistent Behavior in Linear Interpolation\r\n% The interpolated result is different in each scenario. The code to\r\n% demonstrate this is given in the frame below, I have perturbed one data\r\n% point to flip the diagonal of the triangulation and illustrate the\r\n% effect.\r\n\r\nP = [0 0; 1 0; 1 1; eps (1-eps);];\r\nV = [10; 1000; 50; 100];\r\npq = [0.5 0.25];\r\n\r\nF = scatteredInterpolant(P,V);\r\nlinearVq = F(pq)\r\n\r\nP = [0 0; 1 0; 1 1; -eps (1+eps);];\r\nF.Points = P;\r\nlinearVq = F(pq)\r\n\r\n%% Why Natural Neighbor Interpolation is Superior\r\n% The interpolated value at the query point, |linearVq|, is sensitive to\r\n% how the triangulation edge is created in the tiebreak case. This tiebreak\r\n% is called a degeneracy and the problem arises in Delaunay triangulations\r\n% when we have 4 or more cocircular points in 2-D or 5 or more cospherical\r\n% points in 3-D. Now observe the behavior when we choose the Natural\r\n% Neighbor interpolation method. This method is also based on an underlying\r\n% Delaunay triangulation, but it produces the same result in the presence\r\n% of a diagonal edge swap. Here it is:\r\n\r\nP = [0 0; 1 0; 1 1; eps (1-eps);];\r\nF.Points = P;\r\nF.Method = 'natural';\r\nnaturalVq = F(pq)\r\n\r\nP = [0 0; 1 0; 1 1; -eps (1+eps);];\r\nF.Points = P;\r\nnaturalVq = F(pq)\r\n\r\n%%\r\n% Natural Neighbor is also a smoother interpolating function, so it makes a\r\n% lot of sense to favor Natural Neighbor over Linear.  Well that begs the\r\n% question: shouldn\u00e2\u20ac\u2122t the Natural Neighbor method be the default? This\r\n% would be our preferred choice of default, but this method was added to\r\n% MATLAB long after the |griddata| Linear method was introduced. Changing a\r\n% default would have a significant impact, so the change would be more\r\n% disruptive than the problem it addresses. The Natural Neighbor method is\r\n% also more computationally expensive, so for large datasets Linear may be\r\n% preferred for performance reasons.\r\n% \r\n% The example we just reviewed highlights the nature of the problem and\r\n% gives you a more stable alternative to avoid potential differences from\r\n% scattered data interpolation after you upgrade MATLAB.  For our part here\r\n% in development, we have long recognized these types of issues create\r\n% problems for users and we have adopted better underlying algorithms to\r\n% address them. If you are a long-time user of MATLAB and the |griddata|\r\n% function, you may recall more annoying past behavior. Prior to R2009a,\r\n% repeated calls to the function using the now redundant |{'QJ'}| Qhull\r\n% option gave potentially different results on each call. That problem was\r\n% resolved in R2009a along with the introduction of Natural Neighbor\r\n% interpolation for its stability and superior interpolation properties.\r\n% Since then, improvements in the underlying triangulation algorithms have\r\n% led to stable and consistent results across all platforms, first for 2-D\r\n% and then for 3-D. Unfortunately, introducing these improvements meant a\r\n% potential change in behavior of the upgrade for specific datasets, but\r\n% that's like having to break eggs to make cake. Looking ahead, the\r\n% behavior of Delaunay triangulation based functions should be much more\r\n% stable. Of course, fundamental changes to the coded algorithm are likely\r\n% to trigger changes like the ones we've seen, though the scope of the\r\n% problem has been reduced substantially.\r\n%% You Tell Me!\r\n% I haven't received many support escalations questions related to Natural\r\n% Neighbor interpolation since it shipped in R2009a. I often wonder if this\r\n% is because it is working well for users or if users may not be using it.\r\n% The similar naming to Nearest Neighbor interpolation may cause some to\r\n% misunderstand the method. How about you, have you used Natural Neighbor\r\n% interpolation and how has it worked out?  Let me know\r\n% <https:\/\/blogs.mathworks.com\/loren\/?p=1188#respond here>.\r\n\r\n##### SOURCE END ##### 582e609b58184b9dbc472d47811e5d16\r\n-->","protected":false},"excerpt":{"rendered":"<div class=\"overview-image\"><img decoding=\"async\"  class=\"img-responsive\" src=\"https:\/\/blogs.mathworks.com\/images\/loren\/2015\/NaturalNeighborBlog_02.png\" onError=\"this.style.display ='none';\" \/><\/div><!--introduction--><p>I'm happy to welcome Damian Sheehy as this week's guest blogger. Damian works on the development of geometry-related features at MathWorks. He will provide answers to two frequently asked questions; one on scattered data interpolation that he will cover in this blog and the other on Delaunay triangulation that he will cover in the next. Over to you, Damian...... <a class=\"read-more\" href=\"https:\/\/blogs.mathworks.com\/loren\/2015\/07\/01\/natural-neighbor-a-superb-interpolation-method\/\">read more >><\/a><\/p>","protected":false},"author":39,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[32,10,23,45],"tags":[],"_links":{"self":[{"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/posts\/1188"}],"collection":[{"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/users\/39"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/comments?post=1188"}],"version-history":[{"count":3,"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/posts\/1188\/revisions"}],"predecessor-version":[{"id":2447,"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/posts\/1188\/revisions\/2447"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/media?parent=1188"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/categories?post=1188"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/loren\/wp-json\/wp\/v2\/tags?post=1188"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}