h3 3.4.0 → 3.4.4

data/ext/h3/src/src/apps/testapps/testH3Line.c

@@ -25,7 +25,6 @@
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"
-#include "stackAlloc.h"
 #include "test.h"
 #include "utility.h"
 
@@ -37,7 +36,7 @@ static const int MAX_DISTANCES[] = {1, 2, 5, 12, 19, 26};
 static void h3Line_assertions(H3Index start, H3Index end) {
     int sz = H3_EXPORT(h3LineSize)(start, end);
     t_assert(sz > 0, "got valid size");
-    STACK_ARRAY_CALLOC(H3Index, line, sz);
+    H3Index *line = calloc(sz, sizeof(H3Index));
 
     int err = H3_EXPORT(h3Line)(start, end, line);
 
@@ -51,10 +50,12 @@ static void h3Line_assertions(H3Index start, H3Index end) {
                  "index is a neighbor of the previous index");
         if (i > 1) {
             t_assert(
-                !H3_EXPORT(h3IndexesAreNeighbors)(line[i], line[i - 3]),
+                !H3_EXPORT(h3IndexesAreNeighbors)(line[i], line[i - 2]),
                 "index is not a neighbor of the index before the previous");
         }
     }
+
+    free(line);
 }
 
 /**
@@ -64,7 +65,7 @@ static void h3Line_invalid_assertions(H3Index start, H3Index end) {
     int sz = H3_EXPORT(h3LineSize)(start, end);
     t_assert(sz < 0, "line size marked as invalid");
 
-    H3Index* line = {0};
+    H3Index *line = {0};
     int err = H3_EXPORT(h3Line)(start, end, line);
     t_assert(err != 0, "line marked as invalid");
 }
@@ -78,13 +79,14 @@ static void h3Line_kRing_assertions(H3Index h3) {
     int maxK = MAX_DISTANCES[r];
 
     int sz = H3_EXPORT(maxKringSize)(maxK);
-    STACK_ARRAY_CALLOC(H3Index, neighbors, sz);
-    H3_EXPORT(kRing)(h3, maxK, neighbors);
 
     if (H3_EXPORT(h3IsPentagon)(h3)) {
         return;
     }
 
+    H3Index *neighbors = calloc(sz, sizeof(H3Index));
+    H3_EXPORT(kRing)(h3, maxK, neighbors);
+
     for (int i = 0; i < sz; i++) {
         if (neighbors[i] == 0) {
             continue;
@@ -96,6 +98,8 @@ static void h3Line_kRing_assertions(H3Index h3) {
             h3Line_invalid_assertions(h3, neighbors[i]);
         }
     }
+
+    free(neighbors);
 }
 
 SUITE(h3Line) {
@@ -107,4 +111,12 @@ SUITE(h3Line) {
         iterateAllIndexesAtResPartial(3, h3Line_kRing_assertions, 6);
         // Further resolutions aren't tested to save time.
     }
+
+    TEST(h3Line_acrossMultipleFaces) {
+        H3Index start = 0x85285aa7fffffff;
+        H3Index end = 0x851d9b1bfffffff;
+
+        int lineSz = H3_EXPORT(h3LineSize)(start, end);
+        t_assert(lineSz < 0, "Line not computable across multiple icosa faces");
+    }
 }

data/ext/h3/src/src/apps/testapps/testH3ToLocalIj.c

@@ -29,7 +29,6 @@
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"
-#include "stackAlloc.h"
 #include "test.h"
 #include "utility.h"
 
@@ -131,8 +130,8 @@ void localIjToH3_kRing_assertions(H3Index h3) {
     int maxK = MAX_DISTANCES[r];
 
     int sz = H3_EXPORT(maxKringSize)(maxK);
-    STACK_ARRAY_CALLOC(H3Index, neighbors, sz);
-    STACK_ARRAY_CALLOC(int, distances, sz);
+    H3Index *neighbors = calloc(sz, sizeof(H3Index));
+    int *distances = calloc(sz, sizeof(int));
 
     H3_EXPORT(kRingDistances)(h3, maxK, neighbors, distances);
 
@@ -152,6 +151,9 @@ void localIjToH3_kRing_assertions(H3Index h3) {
                      "round trip neighboring index matches expected");
         }
     }
+
+    free(distances);
+    free(neighbors);
 }
 
 void localIjToH3_traverse_assertions(H3Index h3) {
@@ -339,4 +341,74 @@ SUITE(h3ToLocalIj) {
         t_assert(H3_EXPORT(experimentalH3ToLocalIj)(pent1, bc3, &ij) != 0,
                  "found IJ (5)");
     }
+
+    /**
+     * Test that coming from the same direction outside the pentagon is handled
+     * the same as coming from the same direction inside the pentagon.
+     */
+    TEST(onOffPentagonSame) {
+        for (int bc = 0; bc < NUM_BASE_CELLS; bc++) {
+            for (int res = 1; res <= MAX_H3_RES; res++) {
+                // K_AXES_DIGIT is the first internal direction, and it's also
+                // invalid for pentagons, so skip to next.
+                Direction startDir = K_AXES_DIGIT;
+                if (_isBaseCellPentagon(bc)) {
+                    startDir++;
+                }
+
+                for (Direction dir = startDir; dir < NUM_DIGITS; dir++) {
+                    H3Index internalOrigin;
+                    setH3Index(&internalOrigin, res, bc, dir);
+
+                    H3Index externalOrigin;
+                    setH3Index(&externalOrigin, res,
+                               _getBaseCellNeighbor(bc, dir), CENTER_DIGIT);
+
+                    for (Direction testDir = startDir; testDir < NUM_DIGITS;
+                         testDir++) {
+                        H3Index testIndex;
+                        setH3Index(&testIndex, res, bc, testDir);
+
+                        CoordIJ internalIj;
+                        int internalIjFailed =
+                            H3_EXPORT(experimentalH3ToLocalIj)(
+                                internalOrigin, testIndex, &internalIj);
+                        CoordIJ externalIj;
+                        int externalIjFailed =
+                            H3_EXPORT(experimentalH3ToLocalIj)(
+                                externalOrigin, testIndex, &externalIj);
+
+                        t_assert(
+                            (bool)internalIjFailed == (bool)externalIjFailed,
+                            "internal/external failed matches when getting IJ");
+
+                        if (internalIjFailed) {
+                            continue;
+                        }
+
+                        H3Index internalIndex;
+                        int internalIjFailed2 =
+                            H3_EXPORT(experimentalLocalIjToH3)(
+                                internalOrigin, &internalIj, &internalIndex);
+                        H3Index externalIndex;
+                        int externalIjFailed2 =
+                            H3_EXPORT(experimentalLocalIjToH3)(
+                                externalOrigin, &externalIj, &externalIndex);
+
+                        t_assert(
+                            (bool)internalIjFailed2 == (bool)externalIjFailed2,
+                            "internal/external failed matches when getting "
+                            "index");
+
+                        if (internalIjFailed2) {
+                            continue;
+                        }
+
+                        t_assert(internalIndex == externalIndex,
+                                 "internal/external index matches");
+                    }
+                }
+            }
+        }
+    }
 }

data/ext/h3/src/src/apps/testapps/testH3UniEdge.c

@@ -23,7 +23,6 @@
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3Index.h"
-#include "stackAlloc.h"
 #include "test.h"
 
 // Fixtures
@@ -32,7 +31,7 @@ static GeoCoord sfGeo = {0.659966917655, -2.1364398519396};
 SUITE(h3UniEdge) {
     TEST(h3IndexesAreNeighbors) {
         H3Index sf = H3_EXPORT(geoToH3)(&sfGeo, 9);
-        STACK_ARRAY_CALLOC(H3Index, ring, H3_EXPORT(maxKringSize)(1));
+        H3Index ring[7] = {0};
         H3_EXPORT(hexRing)(sf, 1, ring);
 
         t_assert(H3_EXPORT(h3IndexesAreNeighbors)(sf, sf) == 0,
@@ -47,7 +46,7 @@ SUITE(h3UniEdge) {
         t_assert(neighbors == 6,
                  "got the expected number of neighbors from a k-ring of 1");
 
-        STACK_ARRAY_CALLOC(H3Index, largerRing, H3_EXPORT(maxKringSize)(2));
+        H3Index largerRing[19] = {0};
         H3_EXPORT(hexRing)(sf, 2, largerRing);
 
         neighbors = 0;
@@ -64,6 +63,8 @@ SUITE(h3UniEdge) {
         H3_SET_MODE(sfBroken, H3_UNIEDGE_MODE);
         t_assert(H3_EXPORT(h3IndexesAreNeighbors)(sf, sfBroken) == 0,
                  "broken H3Indexes can't be neighbors");
+        t_assert(H3_EXPORT(h3IndexesAreNeighbors)(sfBroken, sf) == 0,
+                 "broken H3Indexes can't be neighbors (reversed)");
 
         H3Index sfBigger = H3_EXPORT(geoToH3)(&sfGeo, 7);
         t_assert(H3_EXPORT(h3IndexesAreNeighbors)(sf, sfBigger) == 0,
@@ -75,7 +76,7 @@ SUITE(h3UniEdge) {
 
     TEST(getH3UnidirectionalEdgeAndFriends) {
         H3Index sf = H3_EXPORT(geoToH3)(&sfGeo, 9);
-        STACK_ARRAY_CALLOC(H3Index, ring, H3_EXPORT(maxKringSize)(1));
+        H3Index ring[7] = {0};
         H3_EXPORT(hexRing)(sf, 1, ring);
         H3Index sf2 = ring[0];
 
@@ -93,7 +94,7 @@ SUITE(h3UniEdge) {
         t_assert(originDestination[1] == sf2,
                  "got the destination last in the pair request");
 
-        STACK_ARRAY_CALLOC(H3Index, largerRing, H3_EXPORT(maxKringSize)(2));
+        H3Index largerRing[19] = {0};
         H3_EXPORT(hexRing)(sf, 2, largerRing);
         H3Index sf3 = largerRing[0];
 
@@ -133,7 +134,7 @@ SUITE(h3UniEdge) {
 
     TEST(h3UnidirectionalEdgeIsValid) {
         H3Index sf = H3_EXPORT(geoToH3)(&sfGeo, 9);
-        STACK_ARRAY_CALLOC(H3Index, ring, H3_EXPORT(maxKringSize)(1));
+        H3Index ring[7] = {0};
         H3_EXPORT(hexRing)(sf, 1, ring);
         H3Index sf2 = ring[0];
 
@@ -147,6 +148,11 @@ SUITE(h3UniEdge) {
         H3_SET_MODE(fakeEdge, H3_UNIEDGE_MODE);
         t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(fakeEdge) == 0,
                  "edges without an edge specified don't work");
+        H3Index invalidEdge = sf;
+        H3_SET_MODE(invalidEdge, H3_UNIEDGE_MODE);
+        H3_SET_RESERVED_BITS(invalidEdge, INVALID_DIGIT);
+        t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(invalidEdge) == 0,
+                 "edges with an invalid edge specified don't work");
 
         H3Index pentagon = 0x821c07fffffffff;
         H3Index goodPentagonalEdge = pentagon;
@@ -164,7 +170,7 @@ SUITE(h3UniEdge) {
 
     TEST(getH3UnidirectionalEdgesFromHexagon) {
         H3Index sf = H3_EXPORT(geoToH3)(&sfGeo, 9);
-        STACK_ARRAY_CALLOC(H3Index, edges, 6);
+        H3Index edges[6] = {0};
         H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(sf, edges);
 
         for (int i = 0; i < 6; i++) {
@@ -182,7 +188,7 @@ SUITE(h3UniEdge) {
 
     TEST(getH3UnidirectionalEdgesFromPentagon) {
         H3Index pentagon = 0x821c07fffffffff;
-        STACK_ARRAY_CALLOC(H3Index, edges, 6);
+        H3Index edges[6] = {0};
         H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(pentagon, edges);
 
         int missingEdgeCount = 0;
@@ -211,7 +217,7 @@ SUITE(h3UniEdge) {
         H3Index sf;
         GeoBoundary boundary;
         GeoBoundary edgeBoundary;
-        STACK_ARRAY_CALLOC(H3Index, edges, 6);
+        H3Index edges[6] = {0};
 
         const int expectedVertices[][2] = {{3, 4}, {1, 2}, {2, 3},
                                            {5, 0}, {4, 5}, {0, 1}};
@@ -242,7 +248,7 @@ SUITE(h3UniEdge) {
         H3Index pentagon;
         GeoBoundary boundary;
         GeoBoundary edgeBoundary;
-        STACK_ARRAY_CALLOC(H3Index, edges, 6);
+        H3Index edges[6] = {0};
 
         const int expectedVertices[][3] = {{-1, -1, -1}, {2, 3, 4}, {4, 5, 6},
                                            {8, 9, 0},    {6, 7, 8}, {0, 1, 2}};
@@ -282,7 +288,7 @@ SUITE(h3UniEdge) {
         H3Index pentagon;
         GeoBoundary boundary;
         GeoBoundary edgeBoundary;
-        STACK_ARRAY_CALLOC(H3Index, edges, 6);
+        H3Index edges[6] = {0};
 
         const int expectedVertices[][3] = {{-1, -1}, {1, 2}, {2, 3},
                                            {4, 0},   {3, 4}, {0, 1}};

data/ext/h3/src/src/apps/testapps/testHexRanges.c

@@ -25,6 +25,7 @@ SUITE(hexRanges) {
 
     H3Index k1[] = {0x89283080ddbffff, 0x89283080c37ffff, 0x89283080c27ffff,
                     0x89283080d53ffff, 0x89283080dcfffff, 0x89283080dc3ffff};
+    H3Index withPentagon[] = {0x8029fffffffffff, 0x801dfffffffffff};
 
     TEST(identityKRing) {
         int err;
@@ -74,4 +75,13 @@ SUITE(hexRanges) {
         }
         free(allKrings2);
     }
+
+    TEST(failed) {
+        int err;
+        H3Index* allKrings = calloc(2 * (1 + 6), sizeof(H3Index));
+        err = H3_EXPORT(hexRanges)(withPentagon, 2, 1, allKrings);
+
+        t_assert(err != 0, "Expected error on hexRanges");
+        free(allKrings);
+    }
 }

data/ext/h3/src/src/apps/testapps/testKRing.c

@@ -19,7 +19,6 @@
  *  usage: `testKRing`
  */
 
-#include <stackAlloc.h>
 #include <stdlib.h>
 #include "algos.h"
 #include "baseCells.h"
@@ -31,13 +30,12 @@ static void kRing_equals_kRingInternal_assertions(H3Index h3) {
     for (int k = 0; k < 3; k++) {
         int kSz = H3_EXPORT(maxKringSize)(k);
 
-        STACK_ARRAY_CALLOC(H3Index, neighbors, kSz);
-        STACK_ARRAY_CALLOC(int, distances, kSz);
-        H3_EXPORT(kRingDistances)
-        (h3, k, neighbors, distances);
+        H3Index *neighbors = calloc(kSz, sizeof(H3Index));
+        int *distances = calloc(kSz, sizeof(int));
+        H3_EXPORT(kRingDistances)(h3, k, neighbors, distances);
 
-        STACK_ARRAY_CALLOC(H3Index, internalNeighbors, kSz);
-        STACK_ARRAY_CALLOC(int, internalDistances, kSz);
+        H3Index *internalNeighbors = calloc(kSz, sizeof(H3Index));
+        int *internalDistances = calloc(kSz, sizeof(int));
         _kRingInternal(h3, k, internalNeighbors, internalDistances, kSz, 0);
 
         int found = 0;
@@ -64,6 +62,12 @@ static void kRing_equals_kRingInternal_assertions(H3Index h3) {
                          "produce same output");
             }
         }
+
+        free(internalDistances);
+        free(internalNeighbors);
+
+        free(distances);
+        free(neighbors);
     }
 }
 

data/ext/h3/src/src/h3lib/lib/algos.c

@@ -18,10 +18,12 @@
  */
 
 #include "algos.h"
+#include <assert.h>
 #include <float.h>
 #include <math.h>
 #include <stdbool.h>
 #include <stdlib.h>
+#include <string.h>
 #include "baseCells.h"
 #include "bbox.h"
 #include "faceijk.h"
@@ -30,7 +32,6 @@
 #include "h3api.h"
 #include "linkedGeo.h"
 #include "polygon.h"
-#include "stackAlloc.h"
 #include "vertexGraph.h"
 
 /*

data/ext/h3/src/src/h3lib/lib/geoCoord.c

@@ -221,36 +221,36 @@ void _geoAzDistanceRads(const GeoCoord* p1, double az, double distance,
         if (fabs(p2->lat - M_PI_2) < EPSILON)  // north pole
         {
             p2->lat = M_PI_2;
-            p2->lon = 0.0L;
+            p2->lon = 0.0;
         } else if (fabs(p2->lat + M_PI_2) < EPSILON)  // south pole
         {
             p2->lat = -M_PI_2;
-            p2->lon = 0.0L;
+            p2->lon = 0.0;
         } else
             p2->lon = constrainLng(p1->lon);
     } else  // not due north or south
     {
         sinlat = sin(p1->lat) * cos(distance) +
                  cos(p1->lat) * sin(distance) * cos(az);
-        if (sinlat > 1.0L) sinlat = 1.0L;
-        if (sinlat < -1.0L) sinlat = -1.0L;
+        if (sinlat > 1.0) sinlat = 1.0;
+        if (sinlat < -1.0) sinlat = -1.0;
         p2->lat = asin(sinlat);
         if (fabs(p2->lat - M_PI_2) < EPSILON)  // north pole
         {
             p2->lat = M_PI_2;
-            p2->lon = 0.0L;
+            p2->lon = 0.0;
         } else if (fabs(p2->lat + M_PI_2) < EPSILON)  // south pole
         {
             p2->lat = -M_PI_2;
-            p2->lon = 0.0L;
+            p2->lon = 0.0;
         } else {
             sinlon = sin(az) * sin(distance) / cos(p2->lat);
             coslon = (cos(distance) - sin(p1->lat) * sin(p2->lat)) /
                      cos(p1->lat) / cos(p2->lat);
-            if (sinlon > 1.0L) sinlon = 1.0L;
-            if (sinlon < -1.0L) sinlon = -1.0L;
-            if (coslon > 1.0L) sinlon = 1.0L;
-            if (coslon < -1.0L) sinlon = -1.0L;
+            if (sinlon > 1.0) sinlon = 1.0;
+            if (sinlon < -1.0) sinlon = -1.0;
+            if (coslon > 1.0) coslon = 1.0;
+            if (coslon < -1.0) coslon = -1.0;
             p2->lon = constrainLng(p1->lon + atan2(sinlon, coslon));
         }
     }

data/ext/h3/src/src/h3lib/lib/h3Index.c

@@ -26,7 +26,6 @@
 #include "baseCells.h"
 #include "faceijk.h"
 #include "mathExtensions.h"
-#include "stackAlloc.h"
 
 /**
  * Returns the H3 resolution of an H3 index.
@@ -388,11 +387,11 @@ int H3_EXPORT(uncompact)(const H3Index* compactedSet, const int numHexes,
                          H3Index* h3Set, const int maxHexes, const int res) {
     int outOffset = 0;
     for (int i = 0; i < numHexes; i++) {
+        if (compactedSet[i] == 0) continue;
         if (outOffset >= maxHexes) {
             // We went too far, abort!
             return -1;
         }
-        if (compactedSet[i] == 0) continue;
         int currentRes = H3_GET_RESOLUTION(compactedSet[i]);
         if (currentRes > res) {
             // Nonsensical. Abort.

data/ext/h3/src/src/h3lib/lib/localij.c

@@ -19,6 +19,7 @@
  * These functions try to provide a useful coordinate space in the vicinity of
  * an origin index.
  */
+#include <assert.h>
 #include <faceijk.h>
 #include <inttypes.h>
 #include <math.h>
@@ -28,7 +29,6 @@
 #include "faceijk.h"
 #include "h3Index.h"
 #include "mathExtensions.h"
-#include "stackAlloc.h"
 
 /**
  * Origin leading digit -> index leading digit -> rotations 60 cw
@@ -87,24 +87,28 @@ const int PENTAGON_ROTATIONS_REVERSE_POLAR[7][7] = {
     {0, 1, 1, 0, 1, 1, 1},         // 6
 };
 
-// Simply prohibit many pentagon distortion cases rather than handling them.
-const bool FAILED_DIRECTIONS_II[7][7] = {
-    {false, false, false, false, false, false, false},  // 0
-    {false, false, false, false, false, false, false},  // 1
-    {false, false, false, false, true, false, false},   // 2
-    {false, false, false, false, false, false, true},   // 3
-    {false, false, false, true, false, false, false},   // 4
-    {false, false, true, false, false, false, false},   // 5
-    {false, false, false, false, false, true, false},   // 6
-};
-const bool FAILED_DIRECTIONS_III[7][7] = {
+/**
+ * Prohibited directions when unfolding a pentagon.
+ *
+ * Indexes by two directions, both relative to the pentagon base cell. The first
+ * is the direction of the origin index and the second is the direction of the
+ * index to unfold. Direction refers to the direction from base cell to base
+ * cell if the indexes are on different base cells, or the leading digit if
+ * within the pentagon base cell.
+ *
+ * This previously included a Class II/Class III check but these were removed
+ * due to failure cases. It's possible this could be restricted to a narrower
+ * set of a failure cases. Currently, the logic is any unfolding across more
+ * than one icosahedron face is not permitted.
+ */
+const bool FAILED_DIRECTIONS[7][7] = {
     {false, false, false, false, false, false, false},  // 0
     {false, false, false, false, false, false, false},  // 1
-    {false, false, false, false, false, true, false},   // 2
-    {false, false, false, false, true, false, false},   // 3
-    {false, false, true, false, false, false, false},   // 4
-    {false, false, false, false, false, false, true},   // 5
-    {false, false, false, true, false, false, false},   // 6
+    {false, false, false, false, true, true, false},    // 2
+    {false, false, false, false, true, false, true},    // 3
+    {false, false, true, true, false, false, false},    // 4
+    {false, false, true, false, false, false, true},    // 5
+    {false, false, false, true, false, true, false},    // 6
 };
 
 /**
@@ -183,15 +187,10 @@ int h3ToLocalIjk(H3Index origin, H3Index h3, CoordIJK* out) {
         if (originOnPent) {
             int originLeadingDigit = _h3LeadingNonZeroDigit(origin);
 
-            // TODO: This previously included the Class III-based checks
-            // as in the index-on-pentagon case below, but these were
-            // removed due to some failure cases. It is possible that we
-            // could restrict this error to a narrower set of cases.
-            // https://github.com/uber/h3/issues/163
-            if (FAILED_DIRECTIONS_III[originLeadingDigit][dir] ||
-                FAILED_DIRECTIONS_II[originLeadingDigit][dir]) {
-                // TODO this part of the pentagon might not be unfolded
-                // correctly.
+            if (FAILED_DIRECTIONS[originLeadingDigit][dir]) {
+                // TODO: We may be unfolding the pentagon incorrectly in this
+                // case; return an error code until this is guaranteed to be
+                // correct.
                 return 3;
             }
 
@@ -200,12 +199,10 @@ int h3ToLocalIjk(H3Index origin, H3Index h3, CoordIJK* out) {
         } else if (indexOnPent) {
             int indexLeadingDigit = _h3LeadingNonZeroDigit(h3);
 
-            if ((isResClassIII(res) &&
-                 FAILED_DIRECTIONS_III[indexLeadingDigit][revDir]) ||
-                (!isResClassIII(res) &&
-                 FAILED_DIRECTIONS_II[indexLeadingDigit][revDir])) {
-                // TODO this part of the pentagon might not be unfolded
-                // correctly.
+            if (FAILED_DIRECTIONS[indexLeadingDigit][revDir]) {
+                // TODO: We may be unfolding the pentagon incorrectly in this
+                // case; return an error code until this is guaranteed to be
+                // correct.
                 return 4;
             }
 
@@ -248,10 +245,9 @@ int h3ToLocalIjk(H3Index origin, H3Index h3, CoordIJK* out) {
         int originLeadingDigit = _h3LeadingNonZeroDigit(origin);
         int indexLeadingDigit = _h3LeadingNonZeroDigit(h3);
 
-        if (FAILED_DIRECTIONS_III[originLeadingDigit][indexLeadingDigit] ||
-            FAILED_DIRECTIONS_II[originLeadingDigit][indexLeadingDigit]) {
-            // TODO this part of the pentagon might not be unfolded
-            // correctly.
+        if (FAILED_DIRECTIONS[originLeadingDigit][indexLeadingDigit]) {
+            // TODO: We may be unfolding the pentagon incorrectly in this case;
+            // return an error code until this is guaranteed to be correct.
             return 5;
         }