/// <summary> /// Encodes a coordinate on the sphere to the corresponding icosahedral face and /// containing 2D hex coordinates relative to that face center. /// </summary> /// <param name="g">The spherical coordinates to encode.</param> /// <param name="res">The desired H3 resolution for the encoding.</param> /// <param name="face">The icosahedral face containing the spherical coordinates.</param> /// <param name="v">The 2D hex coordinates of the cell containing the point.</param> /// <!-- Based off 3.1.1 --> public static void _geoToHex2d(GeoCoord g, int res, ref int face, ref Vec2d v) { Vec3d v3d = new Vec3d(); Vec3d._geoToVec3d(g, ref v3d); // determine the icosahedron face face = 0; double sqd = Vec3d._pointSquareDist(faceCenterPoint[0], v3d); for (int f = 1; f < Constants.NUM_ICOSA_FACES; f++) { double sqdT = Vec3d._pointSquareDist(faceCenterPoint[f], v3d); if (sqdT < sqd) { face = f; sqd = sqdT; } } // cos(r) = 1 - 2 * sin^2(r/2) = 1 - 2 * (sqd / 4) = 1 - sqd/2 double r = Math.Acos(1 - sqd / 2); if (r < Constants.EPSILON) { v.x = 0.0; v.y = 0.0; return; } // now have face and r, now find CCW theta from CII i-axis double theta = GeoCoord._posAngleRads(faceAxesAzRadsCII[face, 0] - GeoCoord._posAngleRads(GeoCoord._geoAzimuthRads(faceCenterGeo[face], g))); // adjust theta for Class III (odd resolutions) if (H3Index.isResClassIII(res)) { theta = GeoCoord._posAngleRads(theta - Constants.M_AP7_ROT_RADS); } // perform gnomonic scaling of r r = Math.Tan(r); // scale for current resolution length u r /= Constants.RES0_U_GNOMONIC; for (int i = 0; i < res; i++) { r *= M_SQRT7; } // we now have (r, theta) in hex2d with theta ccw from x-axes // convert to local x,y v.x = r * Math.Cos(theta); v.y = r * Math.Sin(theta); }
/// <summary> /// Determines the center point in spherical coordinates of a cell given by 2D /// hex coordinates on a particular icosahedral face. /// </summary> /// <param name="v">The 2D hex coordinates of the cell.</param> /// <param name="face">The icosahedral face upon which the 2D hex coordinate system is centered</param> /// <param name="res">The H3 resolution of the cell</param> /// <param name="substrate">Indicates whether or not this grid is actually a substrate /// grid relative to the specified resolution.</param> /// <param name="g">The spherical coordinates of the cell center point.</param> /// <!-- Based off 3.1.1 --> public static void _hex2dToGeo(ref Vec2d v, int face, int res, int substrate, ref GeoCoord g) { // calculate (r, theta) in hex2d double r = Vec2d._v2dMag(v); if (r < Constants.EPSILON) { g = faceCenterGeo[face]; return; } double theta = Math.Atan2(v.y, v.x); // scale for current resolution length u for (int i = 0; i < res; i++) { r /= M_SQRT7; } // scale accordingly if this is a substrate grid if (substrate > 0) { r /= 3.0; if (H3Index.isResClassIII(res)) { r /= M_SQRT7; } } r *= Constants.RES0_U_GNOMONIC; // perform inverse gnomonic scaling of r r = Math.Atan(r); // adjust theta for Class III // if a substrate grid, then it's already been adjusted for Class III if (substrate == 0 && H3Index.isResClassIII(res)) { theta = GeoCoord._posAngleRads(theta + Constants.M_AP7_ROT_RADS); } // find theta as an azimuth theta = GeoCoord._posAngleRads(faceAxesAzRadsCII[face, 0] - theta); // now find the point at (r,theta) from the face center GeoCoord._geoAzDistanceRads(ref faceCenterGeo[face], theta, r, ref g); }
/// <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); }
/// <summary> /// Produces ijk+ coordinates for an index anchored by an origin. /// /// The coordinate space used by this function may have deleted /// regions or warping due to pentagonal distortion. /// /// Coordinates are only comparable if they come from the same /// origin index. /// /// Failure may occur if the index is 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="h3">Index to find the coordinates of</param> /// <param name="out_coord">ijk+ coordinates of the index will be placed here on success</param> /// <returns>0 on success, or another value on failure.</returns> /// <!-- Based off 3.2.0 --> static int h3ToLocalIjk(H3Index origin, H3Index h3, ref CoordIJK out_coord) { int res = H3Index.H3_GET_RESOLUTION(origin); if (res != H3Index.H3_GET_RESOLUTION(h3)) { return(1); } int originBaseCell = H3Index.H3_GET_BASE_CELL(origin); int baseCell = H3Index.H3_GET_BASE_CELL(h3); // Direction from origin base cell to index base cell Direction dir = 0; Direction revDir = 0; if (originBaseCell != baseCell) { dir = BaseCells._getBaseCellDirection(originBaseCell, baseCell); if (dir == Direction.INVALID_DIGIT) { // Base cells are not neighbors, can't unfold. return(2); } revDir = BaseCells._getBaseCellDirection(baseCell, originBaseCell); if (revDir == Direction.INVALID_DIGIT) { throw new Exception("assert(revDir != INVALID_DIGIT)"); } } int originOnPent = (BaseCells._isBaseCellPentagon(originBaseCell) ? 1 : 0); int indexOnPent = (BaseCells._isBaseCellPentagon(baseCell) ? 1 : 0); FaceIJK indexFijk = new FaceIJK(); if (dir != Direction.CENTER_DIGIT) { // Rotate index into the orientation of the origin base cell. // cw because we are undoing the rotation into that base cell. int baseCellRotations = BaseCells.baseCellNeighbor60CCWRots[originBaseCell, (int)dir]; if (indexOnPent != 0) { for (int i = 0; i < baseCellRotations; i++) { h3 = H3Index._h3RotatePent60cw(h3); revDir = CoordIJK._rotate60cw(revDir); if (revDir == Direction.K_AXES_DIGIT) { revDir = CoordIJK._rotate60cw(revDir); } } } else { for (int i = 0; i < baseCellRotations; i++) { h3 = H3Index._h3Rotate60cw(ref h3); revDir = CoordIJK._rotate60cw(revDir); } } } // Face is unused. This produces coordinates in base cell coordinate space. H3Index._h3ToFaceIjkWithInitializedFijk(h3, ref indexFijk); if (dir != Direction.CENTER_DIGIT) { if (baseCell == originBaseCell) { throw new Exception("assert(baseCell != originBaseCell);"); } if ((originOnPent != 0) && (indexOnPent != 0)) { throw new Exception("assert(!(originOnPent && indexOnPent));"); } int pentagonRotations = 0; int directionRotations = 0; if (originOnPent != 0) { int originLeadingDigit = (int)H3Index._h3LeadingNonZeroDigit(origin); if ((H3Index.isResClassIII(res) && FAILED_DIRECTIONS_III[originLeadingDigit, (int)dir]) || (!H3Index.isResClassIII(res) && FAILED_DIRECTIONS_II[originLeadingDigit, (int)dir])) { // TODO this part of the pentagon might not be unfolded // correctly. return(3); } directionRotations = PENTAGON_ROTATIONS[originLeadingDigit, (int)dir]; pentagonRotations = directionRotations; } else if (indexOnPent != 0) { int indexLeadingDigit = (int)H3Index._h3LeadingNonZeroDigit(h3); if ((H3Index.isResClassIII(res) && FAILED_DIRECTIONS_III[indexLeadingDigit, (int)revDir]) || (!H3Index.isResClassIII(res) && FAILED_DIRECTIONS_II[indexLeadingDigit, (int)revDir])) { // TODO this part of the pentagon might not be unfolded // correctly. return(4); } pentagonRotations = PENTAGON_ROTATIONS[(int)revDir, indexLeadingDigit]; } if (pentagonRotations < 0) { throw new Exception("assert(pentagonRotations >= 0);"); } if (directionRotations < 0) { throw new Exception("assert(directionRotations >= 0);"); } for (int i = 0; i < pentagonRotations; i++) { CoordIJK._ijkRotate60cw(ref indexFijk.coord); } CoordIJK offset = new CoordIJK(); CoordIJK._neighbor(ref offset, dir); // Scale offset based on resolution for (int r = res - 1; r >= 0; r--) { if (H3Index.isResClassIII(r + 1)) { // rotate ccw CoordIJK._downAp7(ref offset); } else { // rotate cw CoordIJK._downAp7r(ref offset); } } for (int i = 0; i < directionRotations; i++) { CoordIJK._ijkRotate60cw(ref offset); } // Perform necessary translation CoordIJK._ijkAdd(indexFijk.coord, offset, ref indexFijk.coord); CoordIJK._ijkNormalize(ref indexFijk.coord); } else if (originOnPent != 0 && indexOnPent != 0) { // If the origin and index are on pentagon, and we checked that the base // cells are the same or neighboring, then they must be the same base // cell. if (baseCell != originBaseCell) { throw new Exception("assert(baseCell == originBaseCell);"); } int originLeadingDigit = (int)H3Index._h3LeadingNonZeroDigit(origin); int indexLeadingDigit = (int)H3Index._h3LeadingNonZeroDigit(h3); if (FAILED_DIRECTIONS_III[originLeadingDigit, indexLeadingDigit] || FAILED_DIRECTIONS_II[originLeadingDigit, indexLeadingDigit]) { // TODO this part of the pentagon might not be unfolded // correctly. return(5); } int withinPentagonRotations = PENTAGON_ROTATIONS[originLeadingDigit, indexLeadingDigit]; for (int i = 0; i < withinPentagonRotations; i++) { CoordIJK._ijkRotate60cw(ref indexFijk.coord); } } out_coord = indexFijk.coord; return(0); }
/// <summary> /// Generates the cell boundary in spherical coordinates for a cell given by a /// FaceIJK address at a specified resolution. /// </summary> /// <param name="h">The FaceIJK address of the cell.</param> /// <param name="res">The H3 resolution of the cell.</param> /// <param name="isPentagon">Whether or not the cell is a pentagon.</param> /// <param name="g">The spherical coordinates of the cell boundary.</param> /// <!-- Based off 3.1.1 --> public static void _faceIjkToGeoBoundary(ref FaceIJK h, int res, int isPentagon, ref GeoBoundary g) { if (isPentagon > 0) { _faceIjkPentToGeoBoundary(ref h, res, ref g); return; } // the vertexes of an origin-centered cell in a Class II resolution on a // substrate grid with aperture sequence 33r. The aperture 3 gets us the // vertices, and the 3r gets us back to Class II. // vertices listed ccw from the i-axes CoordIJK[] vertsCII = { new CoordIJK { i = 2, j = 1, k = 0 }, // 0 new CoordIJK { i = 1, j = 2, k = 0 }, // 1 new CoordIJK { i = 0, j = 2, k = 1 }, // 2 new CoordIJK { i = 0, j = 1, k = 2 }, // 3 new CoordIJK { i = 1, j = 0, k = 2 }, // 4 new CoordIJK { i = 2, j = 0, k = 1 } // 5 }; // the vertexes of an origin-centered cell in a Class III resolution on a // substrate grid with aperture sequence 33r7r. The aperture 3 gets us the // vertices, and the 3r7r gets us to Class II. // vertices listed ccw from the i-axes CoordIJK[] vertsCIII = { new CoordIJK { i = 5, j = 4, k = 0 }, // 0 new CoordIJK { i = 1, j = 5, k = 0 }, // 1 new CoordIJK { i = 0, j = 5, k = 4 }, // 2 new CoordIJK { i = 0, j = 1, k = 5 }, // 3 new CoordIJK { i = 4, j = 0, k = 5 }, // 4 new CoordIJK { i = 5, j = 0, k = 1 } // 5 }; // get the correct set of substrate vertices for this resolution CoordIJK[] verts; if (H3Index.isResClassIII(res)) { verts = vertsCIII; } else { verts = vertsCII; } // adjust the center point to be in an aperture 33r substrate grid // these should be composed for speed FaceIJK centerIJK = new FaceIJK(h.face, new CoordIJK(h.coord.i, h.coord.j, h.coord.k)); CoordIJK._downAp3(ref centerIJK.coord); CoordIJK._downAp3r(ref centerIJK.coord); // if res is Class III we need to add a cw aperture 7 to get to // icosahedral Class II int adjRes = res; if (H3Index.isResClassIII(res)) { CoordIJK._downAp7r(ref centerIJK.coord); adjRes++; } // The center point is now in the same substrate grid as the origin // cell vertices. Add the center point substate coordinates // to each vertex to translate the vertices to that cell. FaceIJK[] fijkVerts = new FaceIJK[Constants.NUM_HEX_VERTS]; for (int v = 0; v < Constants.NUM_HEX_VERTS; v++) { fijkVerts[v] = new FaceIJK(); fijkVerts[v].face = centerIJK.face; CoordIJK._ijkAdd(centerIJK.coord, verts[v], ref fijkVerts[v].coord); CoordIJK._ijkNormalize(ref fijkVerts[v].coord); } // convert each vertex to lat/lon // adjust the face of each vertex as appropriate and introduce // edge-crossing vertices as needed g.numVerts = 0; int lastFace = -1; int lastOverage = 0; // 0: none; 1: edge; 2: overage for (int vert = 0; vert < Constants.NUM_HEX_VERTS + 1; vert++) { int v = vert % Constants.NUM_HEX_VERTS; FaceIJK fijk = new FaceIJK ( fijkVerts[v].face, new CoordIJK(fijkVerts[v].coord.i, fijkVerts[v].coord.j, fijkVerts[v].coord.k) ); int pentLeading4 = 0; int overage = _adjustOverageClassII(ref fijk, adjRes, pentLeading4, 1); /* * Check for edge-crossing. Each face of the underlying icosahedron is a * different projection plane. So if an edge of the hexagon crosses an * icosahedron edge, an additional vertex must be introduced at that * intersection point. Then each half of the cell edge can be projected * to geographic coordinates using the appropriate icosahedron face * projection. Note that Class II cell edges have vertices on the face * edge, with no edge line intersections. */ if (H3Index.isResClassIII(res) && vert > 0 && fijk.face != lastFace && lastOverage != 1) { // find hex2d of the two vertexes on original face int lastV = (v + 5) % Constants.NUM_HEX_VERTS; Vec2d orig2d0 = new Vec2d(); CoordIJK._ijkToHex2d(fijkVerts[lastV].coord, ref orig2d0); Vec2d orig2d1 = new Vec2d(); CoordIJK._ijkToHex2d(fijkVerts[v].coord, ref orig2d1); // find the appropriate icosa face edge vertexes int maxDim = maxDimByCIIres[adjRes]; Vec2d v0 = new Vec2d(3.0 * maxDim, 0.0); Vec2d v1 = new Vec2d(-1.5 * maxDim, 3.0 * Constants.M_SQRT3_2 * maxDim); Vec2d v2 = new Vec2d(-1.5 * maxDim, -3.0 * Constants.M_SQRT3_2 * maxDim); int face2 = lastFace == centerIJK.face ? fijk.face : lastFace; Vec2d edge0 = new Vec2d(); Vec2d edge1 = new Vec2d(); switch (adjacentFaceDir[centerIJK.face, face2]) { case IJ: edge0 = v0; edge1 = v1; break; case JK: edge0 = v1; edge1 = v2; break; case KI: default: if (adjacentFaceDir[centerIJK.face, face2] != KI) { throw new Exception("Default failure in _faceIjkToGeoBoundary"); } edge0 = v2; edge1 = v0; break; } // find the intersection and add the lat/lon point to the result Vec2d inter = new Vec2d(); Vec2d._v2dIntersect(orig2d0, orig2d1, edge0, edge1, ref inter); /* * If a point of intersection occurs at a hexagon vertex, then each * adjacent hexagon edge will lie completely on a single icosahedron * face, and no additional vertex is required. */ bool isIntersectionAtVertex = Vec2d._v2dEquals(orig2d0, inter) || Vec2d._v2dEquals(orig2d1, inter); if (!isIntersectionAtVertex) { var temp_verts = g.verts[g.numVerts]; _hex2dToGeo(ref inter, centerIJK.face, adjRes, 1, ref temp_verts); g.verts[g.numVerts] = temp_verts; g.numVerts++; Debug.WriteLine(string.Format("!IsIntersection {0}", g.numVerts)); } } // convert vertex to lat/lon and add to the result // vert == NUM_HEX_VERTS is only used to test for possible intersection // on last edge if (vert < Constants.NUM_HEX_VERTS) { Vec2d vec = new Vec2d(); CoordIJK._ijkToHex2d(fijk.coord, ref vec); var temp_verts = g.verts[g.numVerts]; _hex2dToGeo(ref vec, fijk.face, adjRes, 1, ref temp_verts); g.verts[g.numVerts] = temp_verts; g.numVerts++; } lastFace = fijk.face; lastOverage = overage; } }
/// <summary> /// Generates the cell boundary in spherical coordinates for a pentagonal cell /// given by a FaceIJK address at a specified resolution. /// </summary> /// <param name="h">The FaceIJK address of the pentagonal cell.</param> /// <param name="res">The H3 resolution of the cell.</param> /// <param name="g">The spherical coordinates of the cell boundary.</param> /// <!-- Based off 3.1.1 --> public static void _faceIjkPentToGeoBoundary(ref FaceIJK h, int res, ref GeoBoundary g) { // the vertexes of an origin-centered pentagon in a Class II resolution on a // substrate grid with aperture sequence 33r. The aperture 3 gets us the // vertices, and the 3r gets us back to Class II. // vertices listed ccw from the i-axes CoordIJK[] vertsCII = { new CoordIJK(2, 1, 0), // 0 new CoordIJK(1, 2, 0), // 1 new CoordIJK(0, 2, 1), // 2 new CoordIJK(0, 1, 2), // 3 new CoordIJK(1, 0, 2) // 4 }; // the vertexes of an origin-centered pentagon in a Class III resolution on // a substrate grid with aperture sequence 33r7r. The aperture 3 gets us the // vertices, and the 3r7r gets us to Class II. vertices listed ccw from the // i-axes CoordIJK[] vertsCIII = { new CoordIJK(5, 4, 0), // 0 new CoordIJK(1, 5, 0), // 1 new CoordIJK(0, 5, 4), // 2 new CoordIJK(0, 1, 5), // 3 new CoordIJK(4, 0, 5) // 4 }; // get the correct set of substrate vertices for this resolution List <CoordIJK> verts = new List <CoordIJK>(); verts = H3Index.isResClassIII(res) ? vertsCIII.ToList() : vertsCII.ToList(); // adjust the center point to be in an aperture 33r substrate grid // these should be composed for speed FaceIJK centerIJK = new FaceIJK(); centerIJK.face = h.face; centerIJK.coord = new CoordIJK(h.coord.i, h.coord.j, h.coord.k); CoordIJK._downAp3(ref centerIJK.coord); CoordIJK._downAp3r(ref centerIJK.coord); // if res is Class III we need to add a cw aperture 7 to get to // icosahedral Class II int adjRes = res; if (H3Index.isResClassIII(res)) { CoordIJK._downAp7r(ref centerIJK.coord); adjRes++; } // The center point is now in the same substrate grid as the origin // cell vertices. Add the center point substate coordinates // to each vertex to translate the vertices to that cell. FaceIJK[] fijkVerts = new FaceIJK[Constants.NUM_PENT_VERTS]; for (int v = 0; v < Constants.NUM_PENT_VERTS; v++) { fijkVerts[v] = new FaceIJK(); fijkVerts[v].face = centerIJK.face; CoordIJK._ijkAdd(centerIJK.coord, verts[v], ref fijkVerts[v].coord); CoordIJK._ijkNormalize(ref fijkVerts[v].coord); } // convert each vertex to lat/lon // adjust the face of each vertex as appropriate and introduce // edge-crossing vertices as needed g.numVerts = 0; for (int i = 0; i < g.verts.Count; i++) { g.verts[i] = new GeoCoord(); } FaceIJK lastFijk = new FaceIJK(); for (int vert = 0; vert < Constants.NUM_PENT_VERTS + 1; vert++) { int v = vert % Constants.NUM_PENT_VERTS; FaceIJK fijk = fijkVerts[v]; int pentLeading4 = 0; int overage = _adjustOverageClassII(ref fijk, adjRes, pentLeading4, 1); if (overage == 2) // in a different triangle { while (true) { overage = _adjustOverageClassII(ref fijk, adjRes, pentLeading4, 1); if (overage != 2) // not in a different triangle { break; } } } // all Class III pentagon edges cross icosa edges // note that Class II pentagons have vertices on the edge, // not edge intersections if (H3Index.isResClassIII(res) && vert > 0) { // find hex2d of the two vertexes on the last face FaceIJK tmpFijk = new FaceIJK(fijk.face, new CoordIJK(fijk.coord.i, fijk.coord.j, fijk.coord.k)); Vec2d orig2d0 = new Vec2d(); CoordIJK._ijkToHex2d(lastFijk.coord, ref orig2d0); int currentToLastDir = adjacentFaceDir[tmpFijk.face, lastFijk.face]; FaceOrientIJK fijkOrient = new FaceOrientIJK( faceNeighbors[tmpFijk.face, currentToLastDir].face, faceNeighbors[tmpFijk.face, currentToLastDir].translate.i, faceNeighbors[tmpFijk.face, currentToLastDir].translate.j, faceNeighbors[tmpFijk.face, currentToLastDir].translate.k, faceNeighbors[tmpFijk.face, currentToLastDir].ccwRot60 ); // faceNeighbors[tmpFijk.face,currentToLastDir]; tmpFijk.face = fijkOrient.face; //CoordIJK ijk = tmpFijk.coord; CoordIJK ijk = new CoordIJK(tmpFijk.coord.i, tmpFijk.coord.j, tmpFijk.coord.k); // rotate and translate for adjacent face for (int i = 0; i < fijkOrient.ccwRot60; i++) { CoordIJK._ijkRotate60ccw(ref ijk); } CoordIJK transVec = fijkOrient.translate; CoordIJK._ijkScale(ref transVec, unitScaleByCIIres[adjRes] * 3); CoordIJK._ijkAdd(ijk, transVec, ref ijk); CoordIJK._ijkNormalize(ref ijk); Vec2d orig2d1 = new Vec2d(); CoordIJK._ijkToHex2d(ijk, ref orig2d1); // find the appropriate icosa face edge vertexes int maxDim = maxDimByCIIres[adjRes]; Vec2d v0 = new Vec2d(3.0 * maxDim, 0.0); Vec2d v1 = new Vec2d(-1.5 * maxDim, 3.0 * Constants.M_SQRT3_2 * maxDim); Vec2d v2 = new Vec2d(-1.5 * maxDim, -3.0 * Constants.M_SQRT3_2 * maxDim); Vec2d edge0 = new Vec2d(); Vec2d edge1 = new Vec2d(); switch (adjacentFaceDir[tmpFijk.face, fijk.face]) { case IJ: edge0 = v0; edge1 = v1; break; case JK: edge0 = v1; edge1 = v2; break; case KI: default: if (adjacentFaceDir[tmpFijk.face, fijk.face] != KI) { throw new Exception("assert(adjacentFaceDir[tmpFijk.face][fijk.face] == KI);"); } edge0 = v2; edge1 = v0; break; } // find the intersection and add the lat/lon point to the result Vec2d inter = new Vec2d(); Vec2d._v2dIntersect(orig2d0, orig2d1, edge0, edge1, ref inter); var gnv = g.verts[g.numVerts]; _hex2dToGeo(ref inter, tmpFijk.face, adjRes, 1, ref gnv); g.verts[g.numVerts] = gnv; g.numVerts++; } // convert vertex to lat/lon and add to the result // vert == NUM_PENT_VERTS is only used to test for possible intersection // on last edge if (vert < Constants.NUM_PENT_VERTS) { Vec2d vec = new Vec2d(); CoordIJK._ijkToHex2d(fijk.coord, ref vec); var gnv = g.verts[g.numVerts]; _hex2dToGeo(ref vec, fijk.face, adjRes, 1, ref gnv); g.verts[g.numVerts] = gnv; g.numVerts++; } lastFijk = fijk; } }
/// <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); }