Exemplo n.º 1
0
        /// <summary>
        /// Produces an index for ijk+ coordinates anchored by an origin.
        ///
        /// The coordinate space used by this function may have deleted
        /// regions or warping due to pentagonal distortion.
        ///
        /// Failure may occur if the coordinates are too far away from the origin
        /// or if the index is on the other side of a pentagon.
        /// </summary>
        /// <param name="origin">An anchoring index for the ijk+ coordinate system.</param>
        /// <param name="ijk">IJK+ Coordinates to find the index of</param>
        /// <param name="out_h3">The index will be placed here on success</param>
        /// <returns>0 on success, or another value on failure</returns>
        /// <!-- Based off 3.2.0 -->
        internal static int localIjkToH3(H3Index origin, CoordIJK ijk, ref H3Index out_h3)
        {
            int res            = H3Index.H3_GET_RESOLUTION(origin);
            int originBaseCell = H3Index.H3_GET_BASE_CELL(origin);
            int originOnPent   = BaseCells._isBaseCellPentagon(originBaseCell)
                                   ? 1
                                   : 0;

            // This logic is very similar to faceIjkToH3
            // initialize the index
            out_h3 = H3Index.H3_INIT;
            H3Index.H3_SET_MODE(ref out_h3, Constants.H3_HEXAGON_MODE);
            H3Index.H3_SET_RESOLUTION(ref out_h3, res);
            Direction dir;

            // check for res 0/base cell
            if (res == 0)
            {
                if (ijk.i > 1 || ijk.j > 1 || ijk.k > 1)
                {
                    // out of range input
                    return(1);
                }

                dir = CoordIJK._unitIjkToDigit(ref ijk);
                int newBaseCell = BaseCells._getBaseCellNeighbor(originBaseCell, dir);
                if (newBaseCell == BaseCells.INVALID_BASE_CELL)
                {
                    // Moving in an invalid direction off a pentagon.
                    return(1);
                }

                H3Index.H3_SET_BASE_CELL(ref out_h3, newBaseCell);
                return(0);
            }

            // we need to find the correct base cell offset (if any) for this H3 index;
            // start with the passed in base cell and resolution res ijk coordinates
            // in that base cell's coordinate system
            CoordIJK ijkCopy = new CoordIJK(ijk.i, ijk.j, ijk.k);

            // build the H3Index from finest res up
            // adjust r for the fact that the res 0 base cell offsets the indexing
            // digits
            for (int r = res - 1; r >= 0; r--)
            {
                CoordIJK lastIJK = ijkCopy;
                CoordIJK lastCenter;
                if (H3Index.isResClassIII(r + 1))
                {
                    // rotate ccw
                    CoordIJK._upAp7(ref ijkCopy);
                    lastCenter = ijkCopy;
                    CoordIJK._downAp7(ref lastCenter);
                }
                else
                {
                    // rotate cw
                    CoordIJK._upAp7r(ref ijkCopy);
                    lastCenter = ijkCopy;
                    CoordIJK._downAp7r(ref lastCenter);
                }

                CoordIJK diff = new CoordIJK();
                CoordIJK._ijkSub(ref lastIJK, ref lastCenter, ref diff);
                CoordIJK._ijkNormalize(ref diff);

                H3Index.H3_SET_INDEX_DIGIT(ref out_h3, r + 1, (ulong)CoordIJK._unitIjkToDigit(ref diff));
            }

            // ijkCopy should now hold the IJK of the base cell in the
            // coordinate system of the current base cell

            if (ijkCopy.i > 1 || ijkCopy.j > 1 || ijkCopy.k > 1)
            {
                // out of range input
                return(2);
            }

            // lookup the correct base cell
            dir = CoordIJK._unitIjkToDigit(ref ijkCopy);
            int baseCell = BaseCells._getBaseCellNeighbor(originBaseCell, dir);
            // If baseCell is invalid, it must be because the origin base cell is a
            // pentagon, and because pentagon base cells do not border each other,
            // baseCell must not be a pentagon.
            int indexOnPent =
                (baseCell == BaseCells.INVALID_BASE_CELL
                     ? 0
                     : BaseCells._isBaseCellPentagon(baseCell)
                         ? 1
                         : 0);

            if (dir != (int)Direction.CENTER_DIGIT)
            {
                // If the index is in a warped direction, we need to unwarp the base
                // cell direction. There may be further need to rotate the index digits.
                int pentagonRotations = 0;
                if (originOnPent != 0)
                {
                    Direction originLeadingDigit = H3Index._h3LeadingNonZeroDigit(origin);
                    pentagonRotations =
                        PENTAGON_ROTATIONS_REVERSE[(int)originLeadingDigit, (int)dir];
                    for (int i = 0; i < pentagonRotations; i++)
                    {
                        dir = CoordIJK._rotate60ccw(dir);
                    }

                    // The pentagon rotations are being chosen so that dir is not the
                    // deleted direction. If it still happens, it means we're moving
                    // into a deleted subsequence, so there is no index here.
                    if (dir == Direction.K_AXES_DIGIT)
                    {
                        return(3);
                    }

                    baseCell = BaseCells._getBaseCellNeighbor(originBaseCell, dir);

                    // indexOnPent does not need to be checked again since no pentagon
                    // base cells border each other.
                    if (baseCell == BaseCells.INVALID_BASE_CELL)
                    {
                        throw new Exception("assert(baseCell != BaseCells.INVALID_BASE_CELL);");
                    }

                    if (BaseCells._isBaseCellPolarPentagon(baseCell))
                    {
                        throw new Exception("assert(!BaseCells._isBaseCellPentagon(baseCell));");
                    }
                }

                // Now we can determine the relation between the origin and target base
                // cell.
                int baseCellRotations =
                    BaseCells.baseCellNeighbor60CCWRots[originBaseCell, (int)dir];
                if (baseCellRotations < 0)
                {
                    throw new Exception("assert(baseCellRotations >= 0);");
                }

                // Adjust for pentagon warping within the base cell. The base cell
                // should be in the right location, so now we need to rotate the index
                // back. We might not need to check for errors since we would just be
                // double mapping.
                if (indexOnPent != 0)
                {
                    Direction revDir =
                        BaseCells._getBaseCellDirection(baseCell, originBaseCell);

                    if (revDir == Direction.INVALID_DIGIT)
                    {
                        throw new Exception("assert(revDir != Direction.INVALID_DIGIT);");
                    }


                    // Adjust for the different coordinate space in the two base cells.
                    // This is done first because we need to do the pentagon rotations
                    // based on the leading digit in the pentagon's coordinate system.
                    for (int i = 0; i < baseCellRotations; i++)
                    {
                        out_h3 = H3Index._h3Rotate60ccw(ref out_h3);
                    }

                    Direction indexLeadingDigit = H3Index._h3LeadingNonZeroDigit(out_h3);
                    if (BaseCells._isBaseCellPolarPentagon(baseCell))
                    {
                        pentagonRotations =
                            PENTAGON_ROTATIONS_REVERSE_POLAR[(int)revDir, (int)indexLeadingDigit];
                    }
                    else
                    {
                        pentagonRotations =
                            PENTAGON_ROTATIONS_REVERSE_NONPOLAR[(int)revDir, (int)indexLeadingDigit];
                    }

                    if (pentagonRotations < 0)
                    {
                        throw new Exception("assert(pentagonRotations >= 0);");
                    }


                    for (int i = 0; i < pentagonRotations; i++)
                    {
                        out_h3 = H3Index._h3RotatePent60ccw(ref out_h3);
                    }
                }
                else
                {
                    if (pentagonRotations < 0)
                    {
                        throw new Exception("assert(pentagonRotations >= 0);");
                    }


                    for (int i = 0; i < pentagonRotations; i++)
                    {
                        out_h3 = H3Index._h3Rotate60ccw(ref out_h3);
                    }

                    // Adjust for the different coordinate space in the two base cells.
                    for (int i = 0; i < baseCellRotations; i++)
                    {
                        out_h3 = H3Index._h3Rotate60ccw(ref out_h3);
                    }
                }
            }
            else if (originOnPent != 0 && indexOnPent != 0)
            {
                int originLeadingDigit = (int)H3Index._h3LeadingNonZeroDigit(origin);
                int indexLeadingDigit  = (int)H3Index._h3LeadingNonZeroDigit(out_h3);

                int withinPentagonRotations =
                    PENTAGON_ROTATIONS_REVERSE[originLeadingDigit, indexLeadingDigit];
                if (withinPentagonRotations < 0)
                {
                    throw new Exception("assert(withinPentagonRotations >= 0);");
                }

                for (int i = 0; i < withinPentagonRotations; i++)
                {
                    out_h3 = H3Index._h3Rotate60ccw(ref out_h3);
                }
            }

            if (indexOnPent != 0)
            {
                // TODO: There are cases in h3ToLocalIjk which are failed but not
                // accounted for here - instead just fail if the recovered index is
                // invalid.
                if (H3Index._h3LeadingNonZeroDigit(out_h3) == Direction.K_AXES_DIGIT)
                {
                    return(4);
                }
            }

            H3Index.H3_SET_BASE_CELL(ref out_h3, baseCell);

            return(0);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Returns the hexagon index neighboring the origin, in the direction dir.
        ///
        /// Implementation note: The only reachable case where this returns 0 is if the
        /// origin is a pentagon and the translation is in the k direction. Thus,
        /// 0 can only be returned if origin is a pentagon.
        /// </summary>
        /// <param name="origin">Origin index</param>
        /// <param name="dir">Direction to move in</param>
        /// <param name="rotations">
        /// Number of ccw rotations to perform to reorient the translation vector.
        /// Will be modified to the new number of rotations to perform (such as
        /// when crossing a face edge.)
        /// </param>
        /// <returns>H3Index of the specified neighbor or 0 if deleted k-subsequence distortion is encountered.</returns>
        /// <!-- Based off 3.2.0 -->
        internal static ulong h3NeighborRotations(H3Index origin, Direction dir, ref int rotations)
        {
            H3Index out_hex = origin;

            for (int i = 0; i < rotations; i++)
            {
                dir = CoordIJK._rotate60ccw(dir);
            }

            int       newRotations    = 0;
            int       oldBaseCell     = H3Index.H3_GET_BASE_CELL(out_hex);
            Direction oldLeadingDigit = H3Index._h3LeadingNonZeroDigit(out_hex);

            // Adjust the indexing digits and, if needed, the base cell.
            int r = H3Index.H3_GET_RESOLUTION(out_hex) - 1;

            while (true)
            {
                if (r == -1)
                {
                    H3Index.H3_SET_BASE_CELL(ref out_hex, BaseCells.baseCellNeighbors[oldBaseCell, (int)dir]);
                    newRotations = BaseCells.baseCellNeighbor60CCWRots[oldBaseCell, (int)dir];

                    if (H3Index.H3_GET_BASE_CELL(out_hex) == BaseCells.INVALID_BASE_CELL)
                    {
                        // Adjust for the deleted k vertex at the base cell level.
                        // This edge actually borders a different neighbor.
                        H3Index.H3_SET_BASE_CELL(ref out_hex,
                                                 BaseCells.baseCellNeighbors[oldBaseCell, (int)Direction.IK_AXES_DIGIT]);
                        newRotations =
                            BaseCells.baseCellNeighbor60CCWRots[oldBaseCell, (int)Direction.IK_AXES_DIGIT];

                        // perform the adjustment for the k-subsequence we're skipping
                        // over.
                        out_hex = H3Index._h3Rotate60ccw(ref out_hex);
                        rotations++;
                    }

                    break;
                }

                Direction oldDigit = H3Index.H3_GET_INDEX_DIGIT(out_hex, r + 1);
                Direction nextDir;
                if (H3Index.isResClassIII(r + 1))
                {
                    H3Index.H3_SET_INDEX_DIGIT(ref out_hex, r + 1, (ulong)NEW_DIGIT_II[(int)oldDigit, (int)dir]);
                    nextDir = NEW_ADJUSTMENT_II[(int)oldDigit, (int)dir];
                }
                else
                {
                    H3Index.H3_SET_INDEX_DIGIT(ref out_hex, r + 1,
                                               (ulong)NEW_DIGIT_III[(int)oldDigit, (int)dir]);
                    nextDir = NEW_ADJUSTMENT_III[(int)oldDigit, (int)dir];
                }

                if (nextDir != Direction.CENTER_DIGIT)
                {
                    dir = nextDir;
                    r--;
                }
                else
                {
                    // No more adjustment to perform
                    break;
                }
            }

            int newBaseCell = H3Index.H3_GET_BASE_CELL(out_hex);

            if (BaseCells._isBaseCellPentagon(newBaseCell))
            {
                int alreadyAdjustedKSubsequence = 0;

                // force rotation out of missing k-axes sub-sequence
                if (H3Index._h3LeadingNonZeroDigit(out_hex) == Direction.K_AXES_DIGIT)
                {
                    if (oldBaseCell != newBaseCell)
                    {
                        // in this case, we traversed into the deleted
                        // k subsequence of a pentagon base cell.
                        // We need to rotate out of that case depending
                        // on how we got here.
                        // check for a cw/ccw offset face; default is ccw
                        if (BaseCells._baseCellIsCwOffset(
                                newBaseCell, BaseCells.baseCellData[oldBaseCell].homeFijk.face))
                        {
                            out_hex = H3Index._h3Rotate60cw(ref out_hex);
                        }
                        else
                        {
                            out_hex = H3Index._h3Rotate60ccw(ref out_hex); // LCOV_EXCL_LINE
                        }

                        // See cwOffsetPent in testKRing.c for why this is
                        // unreachable.

                        alreadyAdjustedKSubsequence = 1;
                    }
                    else
                    {
                        // In this case, we traversed into the deleted
                        // k subsequence from within the same pentagon
                        // base cell.
                        if (oldLeadingDigit == Direction.CENTER_DIGIT)
                        {
                            // Undefined: the k direction is deleted from here
                            return(H3Index.H3_INVALID_INDEX);
                        }

                        switch (oldLeadingDigit)
                        {
                        case Direction.JK_AXES_DIGIT:
                            // Rotate out of the deleted k subsequence
                            // We also need an additional change to the direction we're
                            // moving in
                            out_hex = H3Index._h3Rotate60ccw(ref out_hex);
                            rotations++;
                            break;

                        case Direction.IK_AXES_DIGIT:
                            // Rotate out of the deleted k subsequence
                            // We also need an additional change to the direction we're
                            // moving in
                            out_hex    = H3Index._h3Rotate60cw(ref out_hex);
                            rotations += 5;
                            break;

                        default:
                            // Should never occur
                            return(H3Index.H3_INVALID_INDEX);    // LCOV_EXCL_LINE
                        }
                    }
                }

                for (int i = 0; i < newRotations; i++)
                {
                    out_hex = H3Index._h3RotatePent60ccw(ref out_hex);
                }

                // Account for differing orientation of the base cells (this edge
                // might not follow properties of some other edges.)
                if (oldBaseCell != newBaseCell)
                {
                    if (BaseCells._isBaseCellPolarPentagon(newBaseCell))
                    {
                        // 'polar' base cells behave differently because they have all
                        // i neighbors.
                        if (oldBaseCell != 118 && oldBaseCell != 8 &&
                            H3Index._h3LeadingNonZeroDigit(out_hex) != Direction.JK_AXES_DIGIT)
                        {
                            rotations++;
                        }
                    }
                    else if (H3Index._h3LeadingNonZeroDigit(out_hex) == Direction.IK_AXES_DIGIT &&
                             alreadyAdjustedKSubsequence == 0)
                    {
                        // account for distortion introduced to the 5 neighbor by the
                        // deleted k subsequence.
                        rotations++;
                    }
                }
            }
            else
            {
                for (int i = 0; i < newRotations; i++)
                {
                    out_hex = H3Index._h3Rotate60ccw(ref out_hex);
                }
            }

            rotations = (rotations + newRotations) % 6;
            return(out_hex);
        }