{"id":64,"date":"2011-10-14T01:00:48","date_gmt":"2011-10-14T01:00:48","guid":{"rendered":"http:\/\/aftbit.com\/?p=64"},"modified":"2015-09-12T22:45:33","modified_gmt":"2015-09-13T05:45:33","slug":"cell-noise-2","status":"publish","type":"post","link":"https:\/\/aftbit.com\/cell-noise-2\/","title":{"rendered":"Cell Noise"},"content":{"rendered":"<p>&nbsp;<\/p>\n<div style=\"text-align: left;\">\n<h3>What is Cell Noise?<\/h3>\n<p>Cell noise (sometimes called Worley noise)\u00a0is a is a procedural texture primitive like <a title=\"Perlin Noise\" href=\"http:\/\/en.wikipedia.org\/wiki\/Perlin_noise\" target=\"_blank\" rel=\"nofollow\">Perlin Noise<\/a>. Despite its numerous applications there are few good implementations and explanations available online. Perhaps the best way to be introduced to cell noise \u00a0is with a demo.\u00a0By the end of this blog post you will understand all of the options\u00a0available\u00a0in the demo \ud83d\ude42<\/p>\n<p><div id=\"silverlightControlHost\"><object data=\"data:application\/x-silverlight-2,\" type=\"application\/x-silverlight-2\" width=\"450\" height=\"500\"><param name=\"source\" value=\"http:\/\/aftbit.com\/\/wp-content\/uploads\/CellNoise\/CellNoiseDemo.xap\"\/><param name=\"background\" value=\"white\" \/><param name=\"minRuntimeVersion\" value=\"3.0.40723.0\" \/><param name=\"autoupgrade\" value=\"true\" \/><param name=\"enableHtmlAccess\" value=\"true\" \/><a href=\"http:\/\/go.microsoft.com\/fwlink\/?LinkID=149156\" style=\"text-decoration: none;\"><img src=\"\/wp-content\/plugins\/silverlight-for-wordpress\/sl4wp-ph.png\" alt=\"Install Microsoft Silverlight\" style=\"border-style: none; width:400px; height:200px\"\/><\/a><\/object><iframe style=\"visibility:hidden;height:0;width:0;border:0px\" id=\"_sl_historyFrame\"><\/iframe><\/div><br \/><\/p>\n<h3>Theory<\/h3>\n<p>The evaluated value of cell noise at a given position is simply the distance to the nearest feature point. Feature points are points placed randomly\u00a0throughout space. The image below illustrates\u00a0this.<\/p>\n<p><img loading=\"lazy\" class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"FeaturePoints\" src=\"\/wp-content\/uploads\/CellNoise\/FeaturePoints.png\" alt=\"\" width=\"292\" height=\"183\" \/><\/p>\n<p>In the above image the circled green dot (point A) is the position at\u00a0which\u00a0the noise function is being evaluated and all the red dots are the feature points. \u00a0Feature point D is the closest point to the evaluation point, A. The noise function evaluated at point A is the distance between point A and point D (0.49 in this case).<\/p>\n<h3>Naive Implementation<\/h3>\n<p>The obvious\u00a0implementation\u00a0of cell noise is to:<\/p>\n<ol>\n<li>Generate and store a bunch of random feature points<\/li>\n<li>Evaluate a point by looking through all feature points and finding the closest point.<\/li>\n<\/ol>\n<p>There are\u00a0several major\u00a0drawbacks to this naive implementation\u00a0including\u00a0storage\u00a0requirements and computational cost making the naive implementation\u00a0impractical. In 1996,\u00a0Steven\u00a0Worley devised an\u00a0<a href=\"http:\/\/citeseerx.ist.psu.edu\/viewdoc\/download?doi=10.1.1.95.412&amp;rep=rep1&amp;type=pdf\" target=\"_blank\" rel=\"nofollow\">efficient algorithm<\/a> for\u00a0\u00a0evaluating cell noise. The rest of this blog post will detail his algorithm.<\/p>\n<h3>Efficient Implementation<\/h3>\n<p>Evaluating a point using\u00a0Steven Worley&#8217;s algorithm\u00a0consist\u00a0of the following steps<\/p>\n<ol>\n<li><a href=\"#DetermineCube\">Determine which cube the evaluation point is in<\/a><\/li>\n<li><a href=\"#GenerateRnd\">Generate a\u00a0reproducible\u00a0random number generator for the cube<\/a><\/li>\n<li><a href=\"#NumberPoints\">Determine how many feature points are in the cube<\/a><\/li>\n<li><a href=\"#RndPlace\">Randomly place the feature points in the cube<\/a><\/li>\n<li><a href=\"#ClosestFeaturePoint\">Find the feature point closest to the evaluation point<\/a><\/li>\n<li><a href=\"#CheckNeighbors\">Check the\u00a0neighboring cubes to ensure their are no closer evaluation points.<\/a><\/li>\n<\/ol>\n<p><a name=\"DetermineCube\"><\/a><\/p>\n<h4>1. Determine which cube the evaluation point is in<\/h4>\n<p>Steven Worley&#8217;s algorithm divides space into a regular grid of cubes whose locations are at integer locations. In the image below the evaluation point is the green dot, point A. Point A is located at ( 3.45, 2.65) in the cube ( 3, 2).<\/p>\n<p><img loading=\"lazy\" class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/CubeSpace.png\" alt=\"\" width=\"263\" height=\"228\" \/><\/p>\n<p><a name=\"GenerateRnd\"><\/a><\/p>\n<h4>2. Generate a random number generator for the cube<\/h4>\n<p>We need to generate a\u00a0reproducible\u00a0random number generator uniquely seeded for the cube. It is critical that the seed is the same each time a point is evaluated within the cube. The seed can be created by hashing the integer\u00a0coordinates of the cube. There are many hash functions\u00a0suitable\u00a0for this purpose. In the demo and sample code I used the <a title=\"FNV Hashing\" href=\"http:\/\/isthe.com\/chongo\/tech\/comp\/fnv\/\" target=\"_blank\" rel=\"nofollow\">FNV hashing algorithm<\/a>. Once we have a seed unique to the cube we can generate random numbers using a <a href=\"http:\/\/en.wikipedia.org\/wiki\/Linear_congruential_generator\" target=\"_blank\" rel=\"nofollow\">LCG random number generator<\/a>.<\/p>\n<p><a name=\"NumberPoints\"><\/a><\/p>\n<h4>3. Determine how many feature points are in the cube<\/h4>\n<p>In order to\u00a0determine\u00a0how many feature points are in the cube we must consider how feature points are distributed in space. The simplest distribution is probably the\u00a0<a href=\"http:\/\/en.wikipedia.org\/wiki\/Poisson_distribution\" target=\"_blank\" rel=\"nofollow\">Poisson\u00a0distribution<\/a>, feature points are placed randomly and independently of\u00a0each other. The only parameter the\u00a0Poisson\u00a0distribution requires is the average number of feature points per unit space. Using the discrete Poisson distribution function\u00a0we can calculate the probability of\u00a0having 0,1,2, or more points in a cube. By generating a random\u00a0number\u00a0between zero and one (using the generator from step 2)\u00a0and comparing its value with the calculated probabilities we can\u00a0determine\u00a0the number of feature points in a specific cube. For performance reasons, which will be discuss later, the number of points in a cube will be\u00a0clamped\u00a0between one and nine.<\/p>\n<p><a name=\"RndPlace\"><\/a><\/p>\n<h4>4. Randomly place the feature points in the cube<\/h4>\n<p>Using the random number generator\u00a0initialized in step 2, we generate coordinates for each feature point are inserted in the cube.<\/p>\n<p><a name=\"ClosestFeaturePoint\"><\/a><\/p>\n<h4>5. Find the feature point closest to the evaluation point<\/h4>\n<p>As we place the feature points into the cube we do not store them. Rather, we simply keep track of the distance to the closest feature point inserted thus far. When we are done placing all the feature points we have found the closest feature point.<\/p>\n<p><a name=\"CheckNeighbors\"><\/a><\/p>\n<h4>6. Check the\u00a0neighboring cubes to ensure their are no closer evaluation points.<\/h4>\n<p>The closest feature point to the evaluation point may not be in the same cube as the evaluation point. The image below is an example of such a case.<\/p>\n<p><img class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/CheckNeighbors.png\" alt=\"\" width=\"250\" \/><\/p>\n<p>In the above image the closest feature point to the evaluation point A is obviously the feature point B which is not in the same cube as the evaluation point A.<\/p>\n<p>Because the closest feature point may not be in the same cube as the evaluation point all the neighboring cubes must be checked to see if they contain the closest feature point. This is done by repeating steps 2 through 5 for each neighboring cube.<\/p>\n<p>In step 3 we clamped the number of feature points in a cube between 1 and 9. The lower bound of 1 guarantees that the closest feature point is either in the same cube as the evaluation point or in an immediately neighboring cube. If we do not have this lower bound we may have to check many neighbors and performance would suffer. In the image below each cube is not required to have at least one feature point. The closest feature point to the evaluation point A is feature point E. Feature point E is not in the same cube as the evaluation cube or in an immediately neighboring cube.<\/p>\n<p><img class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/PointClamp.png\" alt=\"\" width=\"250\" \/><\/p>\n<h3>Extensions<\/h3>\n<h4>Combining the N closest feature points<\/h4>\n<p>So far we have only concerned ourselves with finding the distance to the closest feature point. If we find the distances to the closest several feature points we can combine their distances to achieve some cool effects. For example, in the image below the value at the evaluation point is the distance to the second closest feature point minus the distance to the closest feature point.<\/p>\n<p><img class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/EuclideanDistanceMetric.png\" alt=\"\" width=\"200\" \/><\/p>\n<p>Keeping track of the closest n feature points requires a simple modification to our algorithm. Instead of only keeping track of the distance to the closest point (for step 5), we keep track of an array of the distances to the closest n feature points. To determine if a feature point is in the closest n feature points we simply insert the feature point\u2019s distance from the evaluation point into the array using <a href=\"http:\/\/en.wikipedia.org\/wiki\/Insertion_sort\" rel=\"nofollow\">insertion sort<\/a>.<\/p>\n<h4>Alternative Distance Functions<\/h4>\n<p>To this point we have been measuring distance using the the <a href=\"http:\/\/en.wikipedia.org\/wiki\/Euclidean_distance\" rel=\"nofollow\">euclidean distance metric<\/a>. There are other distance metrics which will produce very different result. Look at the images below for examples of different distance metrics.<\/p>\n<ul>\n<li><a href=\"http:\/\/en.wikipedia.org\/wiki\/Euclidean_distance\" rel=\"nofollow\">Euclidean distance metric<\/a>\n<p><img class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/EuclideanDistanceMetric.png\" alt=\"\" width=\"200\" \/><\/li>\n<li><a href=\"http:\/\/en.wikipedia.org\/wiki\/Taxicab_geometry\" rel=\"nofollow\">Manhattan distance metric<\/a>\n<p><img class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/ManhattanDistanceMetric.png\" alt=\"\" width=\"200\" \/><\/li>\n<li><a href=\"http:\/\/en.wikipedia.org\/wiki\/Chebyshev_distance\" rel=\"nofollow\">Chebyshev distance metric<\/a>\n<p><img class=\"aligncenter\" style=\"border: 1px solid black;\" title=\"CubeSpace\" src=\"\/wp-content\/uploads\/CellNoise\/ChebyshevDistanceMetric.png\" alt=\"\" width=\"200\" \/><\/li>\n<\/ul>\n<h3>Code<\/h3>\n<p>The commented critical code from the demo is listed below. The full source for the demo is hosted at github and can be found at <a href=\"https:\/\/github.com\/freethenation\/CellNoiseDemo\">https:\/\/github.com\/freethenation\/CellNoiseDemo<\/a>. The source code below is not optimized for performance but rather written to be easily understood. I may post an optimized version at some later time.<\/p>\n<div>\n<pre class=\"brush: csharp; title: ; notranslate\" title=\"\">\r\npublic static class CellNoise\r\n{\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ Generates Cell Noise\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\t\/\/\/ &lt;param name=&quot;input&quot;&gt;The location at which the cell noise function should be evaluated at.&lt;\/param&gt;\r\n\t\/\/\/ &lt;param name=&quot;seed&quot;&gt;The seed for the noise function&lt;\/param&gt;\r\n\t\/\/\/ &lt;param name=&quot;distanceFunc&quot;&gt;The function used to calculate the distance between two points. Several of these are defined as statics on the WorleyNoise class.&lt;\/param&gt;\r\n\t\/\/\/ &lt;param name=&quot;distanceArray&quot;&gt;An array which will store the distances computed by the Worley noise function. \r\n\t\/\/\/ The length of the array determines how many distances will be computed.&lt;\/param&gt;\r\n\t\/\/\/ &lt;param name=&quot;combineDistancesFunc&quot;&gt;The function used to color the location. The color takes the populated distanceArray\r\n\t\/\/\/ param and returns a float which is the greyscale value outputed by the worley noise function.&lt;\/param&gt;\r\n\t\/\/\/ &lt;returns&gt;The color worley noise returns at the input position&lt;\/returns&gt;\r\n\tpublic static Vector4 CellNoiseFunc(this Vector3 input, int seed, Func&lt;Vector3, Vector3, float&gt; distanceFunc, ref float[] distanceArray, Func&lt;float&amp;#91;&amp;#93;, float&gt; combineDistancesFunc)\r\n\t{\r\n\t\t\/\/Declare some values for later use\r\n\t\tuint lastRandom, numberFeaturePoints;\r\n\t\tVector3 randomDiff, featurePoint;\r\n\t\tint cubeX, cubeY, cubeZ;\r\n\r\n\t\t\/\/Initialize values in distance array to large values\r\n\t\tfor (int i = 0; i &lt; distanceArray.Length; i++)\r\n\t\t\tdistanceArray&amp;#91;i&amp;#93; = 6666;\r\n\r\n\t\t\/\/1. Determine which cube the evaluation point is in\r\n\t\tint evalCubeX = (int)Math.Floor(input.X);\r\n\t\tint evalCubeY = (int)Math.Floor(input.Y);\r\n\t\tint evalCubeZ = (int)Math.Floor(input.Z);\r\n\r\n\t\tfor (int i = -1; i &lt; 2; ++i)\r\n\t\t\tfor (int j = -1; j &lt; 2; ++j)\r\n\t\t\t\tfor (int k = -1; k &lt; 2; ++k)\r\n\t\t\t\t{\r\n\t\t\t\t\tcubeX = evalCubeX + i;\r\n\t\t\t\t\tcubeY = evalCubeY + j;\r\n\t\t\t\t\tcubeZ = evalCubeZ + k;\r\n\r\n\t\t\t\t\t\/\/2. Generate a reproducible random number generator for the cube\r\n\t\t\t\t\tlastRandom = lcgRandom(hash((uint)(cubeX + seed), (uint)(cubeY), (uint)(cubeZ)));\r\n\t\t\t\t\t\/\/3. Determine how many feature points are in the cube\r\n\t\t\t\t\tnumberFeaturePoints = probLookup(lastRandom);\r\n\t\t\t\t\t\/\/4. Randomly place the feature points in the cube\r\n\t\t\t\t\tfor (uint l = 0; l &lt; numberFeaturePoints; ++l)\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tlastRandom = lcgRandom(lastRandom);\r\n\t\t\t\t\t\trandomDiff.X = (float)lastRandom \/ 0x100000000;\r\n\r\n\t\t\t\t\t\tlastRandom = lcgRandom(lastRandom);\r\n\t\t\t\t\t\trandomDiff.Y = (float)lastRandom \/ 0x100000000;\r\n\r\n\t\t\t\t\t\tlastRandom = lcgRandom(lastRandom);\r\n\t\t\t\t\t\trandomDiff.Z = (float)lastRandom \/ 0x100000000;\r\n\r\n\t\t\t\t\t\tfeaturePoint = new Vector3(randomDiff.X + (float)cubeX, randomDiff.Y + (float)cubeY, randomDiff.Z + (float)cubeZ);\r\n\r\n\t\t\t\t\t\t\/\/5. Find the feature point closest to the evaluation point. \r\n\t\t\t\t\t\t\/\/This is done by inserting the distances to the feature points into a sorted list\r\n\t\t\t\t\t\tinsert(distanceArray, distanceFunc(input, featurePoint));\r\n\t\t\t\t\t}\r\n\t\t\t\t\t\/\/6. Check the neighboring cubes to ensure their are no closer evaluation points.\r\n\t\t\t\t\t\/\/ This is done by repeating steps 1 through 5 above for each neighboring cube\r\n\t\t\t\t}\r\n\r\n\t\tfloat color = combineDistancesFunc(distanceArray);\r\n\t\tif(color &lt; 0) color = 0;\r\n\t\tif(color &gt; 1) color = 1;\r\n\t\treturn new Vector4(color, color, color, 1);\r\n\t}\r\n\r\n\tpublic static float EuclidianDistanceFunc(Vector3 p1, Vector3 p2)\r\n\t{\r\n\t\treturn (p1.X - p2.X) * (p1.X - p2.X) + (p1.Y - p2.Y) * (p1.Y - p2.Y) + (p1.Z - p2.Z) * (p1.Z - p2.Z);\r\n\t}\r\n\r\n\tpublic static float ManhattanDistanceFunc(Vector3 p1, Vector3 p2)\r\n\t{\r\n\t\treturn Math.Abs(p1.X - p2.X) + Math.Abs(p1.Y - p2.Y) + Math.Abs(p1.Z - p2.Z);\r\n\t}\r\n\r\n\tpublic static float ChebyshevDistanceFunc(Vector3 p1, Vector3 p2)\r\n\t{\r\n\t\tVector3 diff = p1 - p2;\r\n\t\treturn Math.Max(Math.Max(Math.Abs(diff.X), Math.Abs(diff.Y)), Math.Abs(diff.Z));\r\n\t}\r\n\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ Given a uniformly distributed random number this function returns the number of feature points in a given cube.\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\t\/\/\/ &lt;param name=&quot;value&quot;&gt;a uniformly distributed random number&lt;\/param&gt;\r\n\t\/\/\/ &lt;returns&gt;The number of feature points in a cube.&lt;\/returns&gt;\r\n\t\/\/ Generated using mathmatica with &quot;AccountingForm[N[Table[CDF[PoissonDistribution[4], i], {i, 1, 9}], 20]*2^32]&quot;\r\n\tprivate static uint probLookup(uint value)\r\n\t{\r\n\t\tif (value &lt; 393325350) return 1;\r\n\t\tif (value &lt; 1022645910) return 2;\r\n\t\tif (value &lt; 1861739990) return 3;\r\n\t\tif (value &lt; 2700834071) return 4;\r\n\t\tif (value &lt; 3372109335) return 5;\r\n\t\tif (value &lt; 3819626178) return 6;\r\n\t\tif (value &lt; 4075350088) return 7;\r\n\t\tif (value &lt; 4203212043) return 8;\r\n\t\treturn 9;\r\n\t}\r\n\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ Inserts value into array using insertion sort. If the value is greater than the largest value in the array\r\n\t\/\/\/ it will not be added to the array.\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\t\/\/\/ &lt;param name=&quot;arr&quot;&gt;The array to insert the value into.&lt;\/param&gt;\r\n\t\/\/\/ &lt;param name=&quot;value&quot;&gt;The value to insert into the array.&lt;\/param&gt;\r\n\tprivate static void insert(float[] arr, float value)\r\n\t{\r\n\t\tfloat temp;\r\n\t\tfor (int i = arr.Length - 1; i &gt;= 0; i--)\r\n\t\t{\r\n\t\t\tif (value &gt; arr[i]) break;\r\n\t\t\ttemp = arr[i];\r\n\t\t\tarr[i] = value;\r\n\t\t\tif (i + 1 &lt; arr.Length) arr&amp;#91;i + 1&amp;#93; = temp;\r\n\t\t}\r\n\t}\r\n\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ LCG Random Number Generator.\r\n\t\/\/\/ LCG: http:\/\/en.wikipedia.org\/wiki\/Linear_congruential_generator\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\t\/\/\/ &lt;param name=&quot;lastValue&quot;&gt;The last value calculated by the lcg or a seed&lt;\/param&gt;\r\n\t\/\/\/ &lt;returns&gt;A new random number&lt;\/returns&gt;\r\n\tprivate static uint lcgRandom(uint lastValue)\r\n\t{\r\n\t\treturn (uint)((1103515245u * lastValue + 12345u) % 0x100000000u);\r\n\t}\r\n\r\n\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ Constant used in FNV hash function.\r\n\t\/\/\/ FNV hash: http:\/\/isthe.com\/chongo\/tech\/comp\/fnv\/#FNV-source\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\tprivate const uint OFFSET_BASIS = 2166136261;\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ Constant used in FNV hash function\r\n\t\/\/\/ FNV hash: http:\/\/isthe.com\/chongo\/tech\/comp\/fnv\/#FNV-source\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\tprivate const uint FNV_PRIME = 16777619;\r\n\t\/\/\/ &lt;summary&gt;\r\n\t\/\/\/ Hashes three integers into a single integer using FNV hash.\r\n\t\/\/\/ FNV hash: http:\/\/isthe.com\/chongo\/tech\/comp\/fnv\/#FNV-source\r\n\t\/\/\/ &lt;\/summary&gt;\r\n\t\/\/\/ &lt;returns&gt;hash value&lt;\/returns&gt;\r\n\tprivate static uint hash(uint i, uint j, uint k)\r\n\t{\r\n\t\treturn (uint)((((((OFFSET_BASIS ^ (uint)i) * FNV_PRIME) ^ (uint)j) * FNV_PRIME) ^ (uint)k) * FNV_PRIME);\r\n\t}\r\n}\r\n\t<\/pre>\n<h3>Conclusion<\/h3>\n<p>I hope this post has provided you with an understanding of what cell noise is and how it can be efficiently implemented. If you are confused about anything above leave a comment or read Steven\u00a0Worley&#8217;s <a href=\"http:\/\/citeseerx.ist.psu.edu\/viewdoc\/download?doi=10.1.1.95.412&amp;rep=rep1&amp;type=pdf\" target=\"_blank\" rel=\"nofollow\">paper on cell noise<\/a>.<\/p>\n<\/div>\n<p>&nbsp;<\/p>\n<\/div>\n","protected":false},"excerpt":{"rendered":"<p>&nbsp; What is Cell Noise? Cell noise (sometimes called Worley noise)\u00a0is a is a procedural texture primitive like Perlin Noise. Despite its numerous applications there are few good implementations and explanations available online. Perhaps the best way to be introduced to cell noise \u00a0is with a demo.\u00a0By the end of this blog post you will [&hellip;]<\/p>\n","protected":false},"author":3,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[5,3,4,6,7],"tags":[],"_links":{"self":[{"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/posts\/64"}],"collection":[{"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/comments?post=64"}],"version-history":[{"count":42,"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/posts\/64\/revisions"}],"predecessor-version":[{"id":143,"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/posts\/64\/revisions\/143"}],"wp:attachment":[{"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/media?parent=64"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/categories?post=64"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/aftbit.com\/wp-json\/wp\/v2\/tags?post=64"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}