double theta = from.getLongitude() - to.getLongitude();
        double dist = Math.sin(deg2rad(from.getLatitude())) * Math.sin(deg2rad(to.getLatitude()))
                + Math.cos(deg2rad(from.getLatitude())) * Math.cos(deg2rad(to.getLatitude())) * Math.cos(deg2rad(theta));
        dist = Math.acos(dist);
        dist = rad2deg(dist);
        dist = dist * 60 * 1.1515;
        dist = dist * 1.609344 * 1000;

        return (long) dist;

    static public OffsetCoord qoffsetFromCube(Hex h)
    {
        int col = h.q;
        int row = h.r + (int)((h.q + (h.q & 1)) / 2);
        return new OffsetCoord(col, row);
    }


    static public Hex qoffsetToCube(OffsetCoord h)
    {
        int q = h.col;
        int r = h.row - (int)((h.col + (h.col & 1)) / 2);
        int s = -q - r;
        return new Hex(q, r, s);
    }

    public FractionalHex pixelToHex(Point p)
    {
        Orientation M = orientation;
        Point pt = new Point((p.x - origin.x) / size.x, (p.y - origin.y) / size.y);
        double q = M.b0 * pt.x + M.b1 * pt.y;
        double r = M.b2 * pt.x + M.b3 * pt.y;
        return new FractionalHex(q, r, -q - r);
    }

    public FractionalHex(double q, double r, double s) {
        this.q = q;
        this.r = r;
        this.s = s;
        if (Math.round(q + r + s) != 0) throw new IllegalArgumentException("q + r + s must be 0");
    }

    public final double q;
    public final double r;
    public final double s;

    public Hex hexRound() {
        int qi = (int) (Math.round(q));
        int ri = (int) (Math.round(r));
        int si = (int) (Math.round(s));
        double q_diff = Math.abs(qi - q);
        double r_diff = Math.abs(ri - r);
        double s_diff = Math.abs(si - s);
        if (q_diff > r_diff && q_diff > s_diff) {
            qi = -ri - si;
        } else if (r_diff > s_diff) {
            ri = -qi - si;
        } else {
            si = -qi - ri;
        }
        return new Hex(qi, ri, si);
    }

    Hex target = layout.pixelToHex(new Point(x, y).hexRound());

    double rate = 110.574 / (111.320 * Math.cos(37.550396 * Math.PI / 180));
    Point center = new Point(126.978955, 37.550396);
    Layout layout = new Layout(Layout.pointy, new Point(rate * 0.0001, 0.0001), center);

        PriorityQueue<HexDepth> frontier = new PriorityQueue<>(10000, (o1, o2) -> o1.priority - o2.priority);
        frontier.add(new HexDepth(nearStart, 0));
        HashMap<Hex, Hex> cameFrom = new HashMap<>(2500);
        HashMap<Hex, Integer> costSoFar = new HashMap<>(2500);
        cameFrom.put(nearStart, null);
        costSoFar.put(nearStart, 0);

        HexDepth currentDepth;
        while ((currentDepth = frontier.poll()) != null) {
            Hex current = currentDepth.hex;
            if (current.equals(nearGoal)) {
                break;
            }

            // 6방향
            List<Hex> neighbors = new ArrayList<>();
            for (Hex direction : Hex.directions) {
                Hex neighbor = current.add(direction);
                neighbors.add(neighbor);
            }

            for (Hex next : neighbors) {
                int nextHexCost = findHexCost(cacheCosts, bigHexCosts, next);
                int newCost = costSoFar.get(current).intValue() + nextHexCost;
                Integer nextCost = costSoFar.get(next);
                if (nextCost == null || newCost < nextCost.intValue()) {
                    costSoFar.put(next, newCost);

                    int priority = newCost + heuristic(nearGoal, next);
                    frontier.add(new HexDepth(next, priority));
                    cameFrom.put(next, current);
                }
            }
        }

public class HexCostUDF extends UDF {

    public int evaluate(int cnt, int avg_count, int max_count) {
        int cost = 50;
        if (avg_count < cnt) {
            // 1 ~ 10
            cost = 1;
        } else if (max_count == avg_count) {
            // 최대 와 평균이 일치하면 한곳에 몰린곳이다.
            cost = 50;
        } else if (avg_count < 2) {
            cost = 50;
        }  else {
            cost = (int) Math.round((avg_count - cnt) * (24.0 / avg_count) + 1);
            cost = Math.max(2, cost);
            cost = Math.min(25, cost);
        }
        return cost;
    }
}

    GeometryFactory gf = JTSFactoryFinder.getGeometryFactory();

.....

    Set<Hex> hexSet = new HashSet<>();
    try {
        ShpFiles shpFiles = new ShpFiles(res);
        String filename = res.getAbsolutePath();
        log.debug("open filename:{}", filename);
        shapefileReader = new ShapefileReader(shpFiles, true, true, gf);
        dbaseFileReader = new DbaseFileReader(shpFiles, true, Charset.forName("CP949"));
        DbaseFileHeader header = dbaseFileReader.getHeader();
        int numFields = header.getNumFields();

        // 특정 도로는 제외(자동차전용도로)하기 위해 header정보를 얻습니다.
        int WDR_RD_CD_FIELD = 0;
        for (int iField = 0; iField < numFields; ++iField) {
            String fieldName = header.getFieldName(iField);
            if ("WDR_RD_CD".equals(fieldName)) {
                WDR_RD_CD_FIELD = iField;
                break;
            }
        }

        while (shapefileReader.hasNext() && dbaseFileReader.hasNext()) {
            ShapefileReader.Record record = shapefileReader.nextRecord();
            String WDR_RD_CD = (String) dbaseFileReader.readRow().read(WDR_RD_CD_FIELD);
            // 행자부도로는 제외
            if ("1".equals(WDR_RD_CD)) {
                continue;
            }

            Object shape = record.shape();
            if (shape.getClass().isAssignableFrom(MultiLineString.class)) {
                MultiLineString ob = (MultiLineString) shape;
                Coordinate[] coordinates = ob.getCoordinates();

                List<FractionalHex> path = new ArrayList<>();
                for (Coordinate coordinate : coordinates) {
                    double x = coordinate.x;
                    double y = coordinate.y;

                    // WGS84 좌표계로 변환합니다.
                    double[] transmit = JTSTransformUtils.transmit(gf, x, y);

                    // 위도 경도
                    double latitude = transmit[0];
                    double longitude = transmit[1];

                    FractionalHex hex = lc.getLayout().pixelToHex(new Point(longitude, latitude));
                    path.add(hex);
                }

                // 도로 정보를 from to 직선라인 정보임으로 직선을 Hex로 모두 변환합니다.
                FractionalHex prev = null;
                for (FractionalHex cur : path) {
                    if (prev != null) {
                        ArrayList<Hex> hexes = FractionalHex.hexLinedraw(prev.hexRound(), cur.hexRound());
                        for (Hex hex : hexes) {
                            hexSet.add(hex);
                        }
                    }
                    prev = cur;
                }
            }
        }
    } catch (IOException e) {
        throw new ItemStreamException(e);
    }