com.badlogic.gdx.math.ConvexHull.java Source code

Introduction

Here is the source code for com.badlogic.gdx.math.ConvexHull.java

Source

/*******************************************************************************
 * Copyright 2011 See AUTHORS file.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 ******************************************************************************/

package com.badlogic.gdx.math;

import com.badlogic.gdx.utils.FloatArray;
import com.badlogic.gdx.utils.IntArray;
import com.badlogic.gdx.utils.ShortArray;

/** Computes the convex hull of a set of points using the monotone chain convex hull algorithm (aka Andrew's algorithm).
 * @author Nathan Sweet */
public class ConvexHull {
    private final IntArray quicksortStack = new IntArray();
    private float[] sortedPoints;
    private final FloatArray hull = new FloatArray();
    private final IntArray indices = new IntArray();
    private final ShortArray originalIndices = new ShortArray(false, 0);

    /** @see #computePolygon(float[], int, int, boolean) */
    public FloatArray computePolygon(FloatArray points, boolean sorted) {
        return computePolygon(points.items, 0, points.size, sorted);
    }

    /** @see #computePolygon(float[], int, int, boolean) */
    public FloatArray computePolygon(float[] polygon, boolean sorted) {
        return computePolygon(polygon, 0, polygon.length, sorted);
    }

    /** Returns a list of points on the convex hull in counter-clockwise order. Note: the last point in the returned list is the
     * same as the first one. */
    /** Returns the convex hull polygon for the given point cloud.
     * @param points x,y pairs describing points. Duplicate points will result in undefined behavior.
     * @param sorted If false, the points will be sorted by the x coordinate then the y coordinate, which is required by the convex
     *           hull algorithm. If sorting is done the input array is not modified and count additional working memory is needed.
     * @return pairs of coordinates that describe the convex hull polygon in counterclockwise order. Note the returned array is
     *         reused for later calls to the same method. */
    public FloatArray computePolygon(float[] points, int offset, int count, boolean sorted) {
        int end = offset + count;

        if (!sorted) {
            if (sortedPoints == null || sortedPoints.length < count)
                sortedPoints = new float[count];
            System.arraycopy(points, offset, sortedPoints, 0, count);
            points = sortedPoints;
            offset = 0;
            sort(points, count);
        }

        FloatArray hull = this.hull;
        hull.clear();

        // Lower hull.
        for (int i = offset; i < end; i += 2) {
            float x = points[i];
            float y = points[i + 1];
            while (hull.size >= 4 && ccw(x, y) <= 0)
                hull.size -= 2;
            hull.add(x);
            hull.add(y);
        }

        // Upper hull.
        for (int i = end - 4, t = hull.size + 2; i >= offset; i -= 2) {
            float x = points[i];
            float y = points[i + 1];
            while (hull.size >= t && ccw(x, y) <= 0)
                hull.size -= 2;
            hull.add(x);
            hull.add(y);
        }

        return hull;
    }

    /** @see #computeIndices(float[], int, int, boolean, boolean) */
    public IntArray computeIndices(FloatArray points, boolean sorted, boolean yDown) {
        return computeIndices(points.items, 0, points.size, sorted, yDown);
    }

    /** @see #computeIndices(float[], int, int, boolean, boolean) */
    public IntArray computeIndices(float[] polygon, boolean sorted, boolean yDown) {
        return computeIndices(polygon, 0, polygon.length, sorted, yDown);
    }

    /** Computes a hull the same as {@link #computePolygon(float[], int, int, boolean)} but returns indices of the specified points. */
    public IntArray computeIndices(float[] points, int offset, int count, boolean sorted, boolean yDown) {
        int end = offset + count;

        if (!sorted) {
            if (sortedPoints == null || sortedPoints.length < count)
                sortedPoints = new float[count];
            System.arraycopy(points, offset, sortedPoints, 0, count);
            points = sortedPoints;
            offset = 0;
            sortWithIndices(points, count, yDown);
        }

        IntArray indices = this.indices;
        indices.clear();

        FloatArray hull = this.hull;
        hull.clear();

        // Lower hull.
        for (int i = offset, index = i / 2; i < end; i += 2, index++) {
            float x = points[i];
            float y = points[i + 1];
            while (hull.size >= 4 && ccw(x, y) <= 0) {
                hull.size -= 2;
                indices.size--;
            }
            hull.add(x);
            hull.add(y);
            indices.add(index);
        }

        // Upper hull.
        for (int i = end - 4, index = i / 2, t = hull.size + 2; i >= offset; i -= 2, index--) {
            float x = points[i];
            float y = points[i + 1];
            while (hull.size >= t && ccw(x, y) <= 0) {
                hull.size -= 2;
                indices.size--;
            }
            hull.add(x);
            hull.add(y);
            indices.add(index);
        }

        // Convert sorted to unsorted indices.
        if (!sorted) {
            short[] originalIndicesArray = originalIndices.items;
            int[] indicesArray = indices.items;
            for (int i = 0, n = indices.size; i < n; i++)
                indicesArray[i] = originalIndicesArray[indicesArray[i]];
        }

        return indices;
    }

    /** Returns > 0 if the points are a counterclockwise turn, < 0 if clockwise, and 0 if colinear. */
    private float ccw(float p3x, float p3y) {
        FloatArray hull = this.hull;
        int size = hull.size;
        float p1x = hull.get(size - 4);
        float p1y = hull.get(size - 3);
        float p2x = hull.get(size - 2);
        float p2y = hull.peek();
        return (p2x - p1x) * (p3y - p1y) - (p2y - p1y) * (p3x - p1x);
    }

    /** Sorts x,y pairs of values by the x value, then the y value.
     * @param count Number of indices, must be even. */
    private void sort(float[] values, int count) {
        int lower = 0;
        int upper = count - 1;
        IntArray stack = quicksortStack;
        stack.add(lower);
        stack.add(upper - 1);
        while (stack.size > 0) {
            upper = stack.pop();
            lower = stack.pop();
            if (upper <= lower)
                continue;
            int i = quicksortPartition(values, lower, upper);
            if (i - lower > upper - i) {
                stack.add(lower);
                stack.add(i - 2);
            }
            stack.add(i + 2);
            stack.add(upper);
            if (upper - i >= i - lower) {
                stack.add(lower);
                stack.add(i - 2);
            }
        }
    }

    private int quicksortPartition(final float[] values, int lower, int upper) {
        float x = values[lower];
        float y = values[lower + 1];
        int up = upper;
        int down = lower;
        float temp;
        short tempIndex;
        while (down < up) {
            while (down < up && values[down] <= x)
                down = down + 2;
            while (values[up] > x || (values[up] == x && values[up + 1] < y))
                up = up - 2;
            if (down < up) {
                temp = values[down];
                values[down] = values[up];
                values[up] = temp;

                temp = values[down + 1];
                values[down + 1] = values[up + 1];
                values[up + 1] = temp;
            }
        }
        values[lower] = values[up];
        values[up] = x;

        values[lower + 1] = values[up + 1];
        values[up + 1] = y;

        return up;
    }

    /** Sorts x,y pairs of values by the x value, then the y value and stores unsorted original indices.
     * @param count Number of indices, must be even. */
    private void sortWithIndices(float[] values, int count, boolean yDown) {
        int pointCount = count / 2;
        originalIndices.clear();
        originalIndices.ensureCapacity(pointCount);
        short[] originalIndicesArray = originalIndices.items;
        for (short i = 0; i < pointCount; i++)
            originalIndicesArray[i] = i;

        int lower = 0;
        int upper = count - 1;
        IntArray stack = quicksortStack;
        stack.add(lower);
        stack.add(upper - 1);
        while (stack.size > 0) {
            upper = stack.pop();
            lower = stack.pop();
            if (upper <= lower)
                continue;
            int i = quicksortPartitionWithIndices(values, lower, upper, yDown, originalIndicesArray);
            if (i - lower > upper - i) {
                stack.add(lower);
                stack.add(i - 2);
            }
            stack.add(i + 2);
            stack.add(upper);
            if (upper - i >= i - lower) {
                stack.add(lower);
                stack.add(i - 2);
            }
        }
    }

    private int quicksortPartitionWithIndices(final float[] values, int lower, int upper, boolean yDown,
            short[] originalIndices) {
        float x = values[lower];
        float y = values[lower + 1];
        int up = upper;
        int down = lower;
        float temp;
        short tempIndex;
        while (down < up) {
            while (down < up && values[down] <= x)
                down = down + 2;
            if (yDown) {
                while (values[up] > x || (values[up] == x && values[up + 1] < y))
                    up = up - 2;
            } else {
                while (values[up] > x || (values[up] == x && values[up + 1] > y))
                    up = up - 2;
            }
            if (down < up) {
                temp = values[down];
                values[down] = values[up];
                values[up] = temp;

                temp = values[down + 1];
                values[down + 1] = values[up + 1];
                values[up + 1] = temp;

                tempIndex = originalIndices[down / 2];
                originalIndices[down / 2] = originalIndices[up / 2];
                originalIndices[up / 2] = tempIndex;
            }
        }
        values[lower] = values[up];
        values[up] = x;

        values[lower + 1] = values[up + 1];
        values[up + 1] = y;

        tempIndex = originalIndices[lower / 2];
        originalIndices[lower / 2] = originalIndices[up / 2];
        originalIndices[up / 2] = tempIndex;

        return up;
    }
}