This algorithm will extract the bounding points of a given Entities model. This could be used for a more precise interacting, Triangulation, Notification, and just plain looking cool. :^)

Disclaimers: The utilities methods for model to points is not working perfectly right now, and it'll cause some weird issues, but its stable.


Example:



The Code:

import org.osbot.script.Script;import org.osbot.script.ScriptManifest;import org.osbot.script.rs2.model.Entity;import org.osbot.script.rs2.model.Model;import org.osbot.script.rs2.model.Player;import org.osbot.script.rs2.utility.Utilities;import java.awt.*;import java.util.Arrays;import java.util.HashSet;import java.util.Iterator;@ScriptManifest(author = "Brainfree", version = 1.0D, name = "OSModelHaulgorithm",        info = "Constructs a Convex Haul around a Entities model.")public class OSModelHaulgorithm extends Script {    public void onPaint(Graphics g) {        for (Player current_player : client.getLocalPlayers()) {            Polygon haul = buildEntityConvexPolygon(current_player);            if(haul == null) return;            ((Graphics2D) g).draw(haul);        }    }    public Polygon buildEntityConvexPolygon(Entity gameObject) {        PointSeries structure = buildModelConvexHaul(                gameObject.getModel(),                gameObject.getGridX(),                gameObject.getGridY()        );        if (structure == null) return null;        return new Polygon(structure.x_points, structure.y_points, structure.num_points);    }    public PointSeries buildModelConvexHaul(Model model, int gridX, int gridY) {        try {            Point[] points = Utilities.getModelScreenPoints(this.getBot(), gridX, gridY, model);            if (points == null || points.length <= 2) return null; //can't do much with a line.            int[][] data = reflectClean(points);            int[] x_cluster = new int[data.length], y_cluster = new int[data.length];            for (int i = 0; i < data.length; i++) {                x_cluster[i] = data[i][0];                y_cluster[i] = data[i][1];            }            PointSeries data_destination = new PointSeries();            reflectHaul(x_cluster, y_cluster, data.length, data_destination);            data_destination.filter(0); //empty element slots.            return data_destination;        } catch (Exception ignored) {} //Utility errors.        return null;    }    public int[][] reflectClean(Point[] points) {        HashSet<Point> nodes = new HashSet<Point>(Arrays.asList(points)); //cheaper then clear.        int[][] data_matrix = new int[nodes.size()][2];        Iterator<Point> data = nodes.iterator();        Point cur;        for (int i = 0; i < nodes.size(); i++) {            cur = data.next();            data_matrix[i][0] = cur.x;            data_matrix[i][1] = cur.y;        }        return data_matrix;    }    public static class PointSeries {        private int[] x_points;        private int[] y_points;        private int num_points = 0;        public PointSeries(int initialCapacity) {            this.x_points = new int[initialCapacity];            this.y_points = new int[initialCapacity];        }        public PointSeries() {            this(10);        }        public void filter(int invalid) {            int valid_size = 0;            for (int i = 0; i < num_points; i++)                if (x_points[i] != invalid && y_points[i] != invalid) valid_size++;            int[] x_dest = new int[valid_size], y_dest = new int[valid_size];            int x, y;            for (int i = 0; i < num_points; i++) {                if ((x = x_points[i]) != invalid && (y = y_points[i]) != invalid) {                    x_dest[i] = x;                    y_dest[i] = y;                }            }            x_points = x_dest;            y_points = y_dest;            num_points = valid_size;        }        private void expand(int newCapacity) {            x_points = Arrays.copyOf(x_points, newCapacity);            y_points = Arrays.copyOf(y_points, newCapacity);        }        public void addPoint(int x, int y) {            if (num_points + 1 > x_points.length)                expand(((num_points * 3) / 2) + 1);            x_points[num_points] = x;            y_points[num_points] = y;            num_points++;        }    }    public boolean small(int[] xPoints, int[] yPoints, int current, int smallest, int i) {        int xa, ya, xb, yb, val;        xa = xPoints[smallest] - xPoints[current];        xb = xPoints[i] - xPoints[current];        ya = yPoints[smallest] - yPoints[current];        yb = yPoints[i] - yPoints[current];        val = xa * yb - xb * ya;        if (val > 0)            return true;        else if (val < 0)            return false;        else {            if (xa * xb + ya * yb < 0)                return false;            else {                if (xa * xa + ya * ya > xb * xb + yb * yb)                    return true;                else                    return false;            }        }    }    public void reflectHaul(            int[] x_cluster, int[] y_cluster, int numPoints, PointSeries destination) {        int min = 0, smallest;        for (int i = 1; i < numPoints; i++) {            if (y_cluster[i] == y_cluster[min]) {                if (x_cluster[i] < x_cluster[min])                    min = i;            } else if (y_cluster[i] < y_cluster[min])                min = i;        }        int current = min;        do {            destination.addPoint(x_cluster[current], y_cluster[current]);            smallest = 0;            if (smallest == current)                smallest = 1;            for (int i = 0; i < numPoints; i++) {                if ((current == i) || (smallest == i))                    continue;                if (small(x_cluster, y_cluster, current, smallest, i))                    smallest = i;            }            current = smallest;        } while (current != min);    }}

 

 

Have fun!

Edited April 14, 201312 yr by Brainfree

I c wat u did thar... haulgorithm. Hueuheuheue