phillip/ingress-intel-total-conversion
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

applyed codingstyle

Browse Source
This commit is contained in:
boombuler 2013-02-23 16:18:02 +01:00
parent 8d419c3c95
commit c36afe506e
1 changed files with 210 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

422
plugins/max-links.user.js
View File

@ -12,242 +12,240 @@
// The algorithm is taken from https://github.com/ironwallaby/delaunay // The algorithm is taken from https://github.com/ironwallaby/delaunay
function wrapper() { function wrapper() {
// ensure plugin framework is there, even if iitc is not yet loaded // ensure plugin framework is there, even if iitc is not yet loaded
if(typeof window.plugin !== 'function') if(typeof window.plugin !== 'function')
window.plugin = function() {}; window.plugin = function() {};
// PLUGIN START //////////////////////////////////////////////////////// // PLUGIN START ////////////////////////////////////////////////////////
// use own namespace for plugin // use own namespace for plugin
window.plugin.portalfolding = function() {}; window.plugin.portalfolding = function() {};
var MAX_LINK_COLOR = '#FF0000'; var MAX_LINK_COLOR = '#FF0000';
var Triangle = function (a, b, c) { var Triangle = function (a, b, c) {
this.a = a this.a = a;
this.b = b this.b = b;
this.c = c this.c = c;
var A = b.x - a.x, var A = b.x - a.x,
B = b.y - a.y, B = b.y - a.y,
C = c.x - a.x, C = c.x - a.x,
D = c.y - a.y, D = c.y - a.y,
E = A * (a.x + b.x) + B * (a.y + b.y), E = A * (a.x + b.x) + B * (a.y + b.y),
F = C * (a.x + c.x) + D * (a.y + c.y), F = C * (a.x + c.x) + D * (a.y + c.y),
G = 2 * (A * (c.y - b.y) - B * (c.x - b.x)), G = 2 * (A * (c.y - b.y) - B * (c.x - b.x)),
minx, miny, dx, dy minx, miny, dx, dy
/* If the points of the triangle are collinear, then just find the
* extremes and use the midpoint as the center of the circumcircle. */
if(Math.abs(G) < 0.000001) {
minx = Math.min(a.x, b.x, c.x)
miny = Math.min(a.y, b.y, c.y)
dx = (Math.max(a.x, b.x, c.x) - minx) * 0.5
dy = (Math.max(a.y, b.y, c.y) - miny) * 0.5
this.x = minx + dx /* If the points of the triangle are collinear, then just find the
this.y = miny + dy * extremes and use the midpoint as the center of the circumcircle. */
this.r = dx * dx + dy * dy if(Math.abs(G) < 0.000001) {
} minx = Math.min(a.x, b.x, c.x)
miny = Math.min(a.y, b.y, c.y)
dx = (Math.max(a.x, b.x, c.x) - minx) * 0.5
dy = (Math.max(a.y, b.y, c.y) - miny) * 0.5
else { this.x = minx + dx
this.x = (D*E - B*F) / G this.y = miny + dy
this.y = (A*F - C*E) / G this.r = dx * dx + dy * dy
dx = this.x - a.x } else {
dy = this.y - a.y this.x = (D*E - B*F) / G
this.r = dx * dx + dy * dy this.y = (A*F - C*E) / G
} dx = this.x - a.x
} dy = this.y - a.y
this.r = dx * dx + dy * dy
Triangle.prototype.draw = function(layer, divX, divY) {
var drawLine = function(src, dest) {
var poly = L.polyline([[(src.y + divY)/1E6, (src.x + divX)/1E6],
[(dest.y + divY)/1E6, (dest.x + divX)/1E6]], {
color: MAX_LINK_COLOR,
opacity: 1,
weight:2,
clickable: false,
smoothFactor: 10
});
poly.addTo(layer);
};
drawLine(this.a, this.b);
drawLine(this.b, this.c);
drawLine(this.c, this.a);
}
var dedup = function (edges) {
var j = edges.length,
a, b, i, m, n
outer: while(j) {
b = edges[--j]
a = edges[--j]
i = j
while(i) {
n = edges[--i]
m = edges[--i]
if((a === m && b === n) || (a === n && b === m)) {
edges.splice(j, 2)
edges.splice(i, 2)
j -= 2
continue outer
}
}
}
} }
}
Triangle.prototype.draw = function(layer, divX, divY) {
var drawLine = function(src, dest) {
var poly = L.polyline([[(src.y + divY)/1E6, (src.x + divX)/1E6],
[(dest.y + divY)/1E6, (dest.x + divX)/1E6]], {
color: MAX_LINK_COLOR,
opacity: 1,
weight:2,
clickable: false,
smoothFactor: 10
});
poly.addTo(layer);
};
drawLine(this.a, this.b);
drawLine(this.b, this.c);
drawLine(this.c, this.a);
}
var triangulate = function (vertices) { var dedup = function (edges) {
/* Bail if there aren't enough vertices to form any triangles. */ var j = edges.length, a, b, i, m, n;
if(vertices.length < 3)
return [] outer: while(j) {
b = edges[--j];
/* Ensure the vertex array is in order of descending X coordinate a = edges[--j];
* (which is needed to ensure a subquadratic runtime), and then find i = j;
* the bounding box around the points. */ while(i) {
vertices.sort(function (a, b) { return b.x - a.x }); n = edges[--i];
m = edges[--i];
var i = vertices.length - 1, if((a === m && b === n) || (a === n && b === m)) {
xmin = vertices[i].x, edges.splice(j, 2);
xmax = vertices[0].x, edges.splice(i, 2);
ymin = vertices[i].y, j -= 2;
ymax = ymin continue outer;
while(i--) {
if(vertices[i].y < ymin) ymin = vertices[i].y
if(vertices[i].y > ymax) ymax = vertices[i].y
} }
/* Find a supertriangle, which is a triangle that surrounds all the
* vertices. This is used like something of a sentinel value to remove
* cases in the main algorithm, and is removed before we return any
* results.
*
* Once found, put it in the "open" list. (The "open" list is for
* triangles who may still need to be considered; the "closed" list is
* for triangles which do not.) */
var dx = xmax - xmin,
dy = ymax - ymin,
dmax = (dx > dy) ? dx : dy,
xmid = (xmax + xmin) * 0.5,
ymid = (ymax + ymin) * 0.5,
open = [
new Triangle(
{x: xmid - 20 * dmax, y: ymid - dmax, __sentinel: true},
{x: xmid , y: ymid + 20 * dmax, __sentinel: true},
{x: xmid + 20 * dmax, y: ymid - dmax, __sentinel: true}
)
],
closed = [],
edges = [],
j, a, b
/* Incrementally add each vertex to the mesh. */
i = vertices.length
while(i--) {
/* For each open triangle, check to see if the current point is
* inside it's circumcircle. If it is, remove the triangle and add
* it's edges to an edge list. */
edges.length = 0
j = open.length
while(j--) {
/* If this point is to the right of this triangle's circumcircle,
* then this triangle should never get checked again. Remove it
* from the open list, add it to the closed list, and skip. */
dx = vertices[i].x - open[j].x
if(dx > 0 && dx * dx > open[j].r) {
closed.push(open[j])
open.splice(j, 1)
continue
}
/* If not, skip this triangle. */
dy = vertices[i].y - open[j].y
if(dx * dx + dy * dy > open[j].r)
continue
/* Remove the triangle and add it's edges to the edge list. */
edges.push(
open[j].a, open[j].b,
open[j].b, open[j].c,
open[j].c, open[j].a
)
open.splice(j, 1)
}
/* Remove any doubled edges. */
dedup(edges)
/* Add a new triangle for each edge. */
j = edges.length
while(j) {
b = edges[--j]
a = edges[--j]
open.push(new Triangle(a, b, vertices[i]))
}
}
/* Copy any remaining open triangles to the closed list, and then
* remove any triangles that share a vertex with the supertriangle. */
Array.prototype.push.apply(closed, open)
i = closed.length
while(i--)
if(closed[i].a.__sentinel ||
closed[i].b.__sentinel ||
closed[i].c.__sentinel)
closed.splice(i, 1)
/* Yay, we're done! */
return closed
} }
}
}
var triangulate = function (vertices) {
/* Bail if there aren't enough vertices to form any triangles. */
if(vertices.length < 3)
return []
/* Ensure the vertex array is in order of descending X coordinate
* (which is needed to ensure a subquadratic runtime), and then find
* the bounding box around the points. */
vertices.sort(function (a, b) { return b.x - a.x });
var i = vertices.length - 1,
xmin = vertices[i].x,
xmax = vertices[0].x,
ymin = vertices[i].y,
ymax = ymin;
while(i--) {
if(vertices[i].y < ymin)
ymin = vertices[i].y;
if(vertices[i].y > ymax)
ymax = vertices[i].y;
}
/* Find a supertriangle, which is a triangle that surrounds all the
* vertices. This is used like something of a sentinel value to remove
* cases in the main algorithm, and is removed before we return any
* results.
*
* Once found, put it in the "open" list. (The "open" list is for
* triangles who may still need to be considered; the "closed" list is
* for triangles which do not.) */
var dx = xmax - xmin,
dy = ymax - ymin,
dmax = (dx > dy) ? dx : dy,
xmid = (xmax + xmin) * 0.5,
ymid = (ymax + ymin) * 0.5,
open = [
new Triangle(
{x: xmid - 20 * dmax, y: ymid - dmax, __sentinel: true},
{x: xmid , y: ymid + 20 * dmax, __sentinel: true},
{x: xmid + 20 * dmax, y: ymid - dmax, __sentinel: true}
)
],
closed = [],
edges = [],
j, a, b;
/* Incrementally add each vertex to the mesh. */
i = vertices.length;
while(i--) {
/* For each open triangle, check to see if the current point is
* inside it's circumcircle. If it is, remove the triangle and add
* it's edges to an edge list. */
edges.length = 0;
j = open.length;
while(j--) {
/* If this point is to the right of this triangle's circumcircle,
* then this triangle should never get checked again. Remove it
* from the open list, add it to the closed list, and skip. */
dx = vertices[i].x - open[j].x;
if(dx > 0 && dx * dx > open[j].r) {
closed.push(open[j]);
open.splice(j, 1);
continue;
}
/* If not, skip this triangle. */
dy = vertices[i].y - open[j].y;
if(dx * dx + dy * dy > open[j].r)
continue;
/* Remove the triangle and add it's edges to the edge list. */
edges.push(
open[j].a, open[j].b,
open[j].b, open[j].c,
open[j].c, open[j].a
);
open.splice(j, 1);
}
/* Remove any doubled edges. */
dedup(edges);
/* Add a new triangle for each edge. */
j = edges.length;
while(j) {
b = edges[--j];
a = edges[--j];
open.push(new Triangle(a, b, vertices[i]));
}
}
/* Copy any remaining open triangles to the closed list, and then
* remove any triangles that share a vertex with the supertriangle. */
Array.prototype.push.apply(closed, open);
i = closed.length;
while(i--)
if(closed[i].a.__sentinel || closed[i].b.__sentinel || closed[i].c.__sentinel)
closed.splice(i, 1);
/* Yay, we're done! */
return closed;
}
var layer = null; var layer = null;
window.plugin.portalfolding.toggle = function() { window.plugin.portalfolding.toggle = function() {
if (layer) { if (layer) {
// toggle off // toggle off
window.map.removeLayer(layer); window.map.removeLayer(layer);
layer = null; layer = null;
return; return;
} }
var locations = []; var locations = [];
var minX = 0; var minX = 0;
var minY = 0; var minY = 0;
for (var key in window.portals) { for (var key in window.portals) {
var loc = window.portals[key].options.details.locationE6; var loc = window.portals[key].options.details.locationE6;
var nloc = { x: loc.lngE6, y: loc.latE6 }; var nloc = { x: loc.lngE6, y: loc.latE6 };
if (nloc.x < minX) minX = nloc.x; if (nloc.x < minX)
if (nloc.y < minX) minX = nloc.y; minX = nloc.x;
locations.push(nloc); if (nloc.y < minX)
} minX = nloc.y;
locations.push(nloc);
}
var i = locations.length; var i = locations.length;
while(i) { while(i) {
var nloc = locations[--i]; var nloc = locations[--i];
nloc.x += Math.abs(minX); nloc.x += Math.abs(minX);
nloc.y += Math.abs(minY); nloc.y += Math.abs(minY);
} }
layer = L.layerGroup([]) layer = L.layerGroup([])
var triangles = triangulate(locations); var triangles = triangulate(locations);
i = triangles.length; i = triangles.length;
while(i) { while(i) {
var triangle = triangles[--i]; var triangle = triangles[--i];
triangle.draw(layer, minX, minY) triangle.draw(layer, minX, minY)
} }
window.map.addLayer(layer); window.map.addLayer(layer);
return layer; return layer;
} }
var setup = function() { var setup = function() {
$('#toolbox').append('<a onclick="window.plugin.portalfolding.toggle()">toggle MaxLinks</a> '); $('#toolbox').append('<a onclick="window.plugin.portalfolding.toggle()">toggle MaxLinks</a> ');
} }
// PLUGIN END ////////////////////////////////////////////////////////// // PLUGIN END //////////////////////////////////////////////////////////