private void makeShape(
double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
shape.moveTo(x1 + x, y1 + y);
shape.lineTo(x2 + x, y2 + y);
shape.lineTo(x3 + x, y3 + y);
shape.lineTo(x4 + x, y4 + y);
shape.closePath();
}
private Shape createShape(double x, double y) {
Path2D.Double path = new Path2D.Double();
path.moveTo(x - 2, y);
path.lineTo(x + 2, y);
path.moveTo(x, y - 2);
path.lineTo(x, y + 2);
return path;
}
public void calculatePath() {
path = new Path2D.Double();
path.moveTo(xpoints[0], ypoints[0]);
for (int i = 1; i < npoints; i++) path.lineTo(xpoints[i], ypoints[i]);
bounds = path.getBounds2D();
}
/**
* Loads an individual polygon from the polygon file.
*
* @param bufferedReader The reader connected to the polygon file placed at the first record of a
* polygon section.
* @return An area representing the section polygon.
*/
private Area loadSectionPolygon(BufferedReader bufferedReader) throws IOException {
Path2D.Double polygonPath;
double[] beginPoint = null;
// Create a new path to represent this polygon.
polygonPath = new Path2D.Double();
while (true) {
String sectionLine;
double[] coordinates;
// Read until a non-empty line is obtained.
do {
sectionLine = bufferedReader.readLine();
// It is invalid for the file to end without a section "END" record.
if (sectionLine == null) {
throw new OsmosisRuntimeException(
"File terminated prematurely without a section END record.");
}
// Remove any whitespace.
sectionLine = sectionLine.trim();
} while (sectionLine.length() == 0);
// Stop reading when the section END record is reached.
if ("END".equals(sectionLine)) {
break;
}
// Parse the line into its coordinates.
coordinates = parseCoordinates(sectionLine);
// Add the current point to the path.
if (beginPoint != null) {
polygonPath.lineTo(coordinates[0], coordinates[1]);
} else {
polygonPath.moveTo(coordinates[0], coordinates[1]);
beginPoint = coordinates;
}
}
// If we received data, draw another line from the final point back to the beginning point.
if (beginPoint != null) {
polygonPath.moveTo(beginPoint[0], beginPoint[1]);
}
// Convert the path into an area and return.
return new Area(polygonPath);
}
@Override
public void paint(Graphics2D g, IGizmo gizmo) {
int orientation = gizmo.getOrientation();
int x = gizmo.getX(), y = gizmo.getY();
Flipper flipper = (Flipper) gizmo;
Path2D.Double path = new Path2D.Double();
path.moveTo(x, y + 0.25);
path.lineTo(x, y + 1.75);
path.curveTo(x, y + 2, x + 0.5, y + 2, x + 0.5, y + 1.75);
path.lineTo(x + 0.5, y + 0.25);
path.curveTo(x + 0.5, y, x, y, x, y + 0.25);
if (flipper.getAngle() != 0)
path.transform(AffineTransform.getRotateInstance(flipper.getAngle(), x + 0.25, y + 0.25));
if (orientation != 0)
path.transform(AffineTransform.getRotateInstance(Math.PI / 2 * orientation, x + 1, y + 1));
g.setColor(Color.ORANGE);
g.fill(path);
g.setColor(Color.ORANGE.darker());
g.draw(path);
}
@Override
public void paint(Graphics2D g, double xOffset, double yOffset, int markerSize) {
g.setStroke(stroke);
double halfSize = (double) markerSize / 2;
// Make a triangle
Path2D.Double path = new Path2D.Double();
path.moveTo(xOffset - halfSize, yOffset - halfSize + markerSize - 1);
path.lineTo(xOffset - halfSize + markerSize, yOffset - halfSize + markerSize - 1);
path.lineTo(xOffset, yOffset - halfSize - 1);
path.closePath();
g.fill(path);
}
@Test
public void testGetPointAt() {
Path2D.Double path = new Path2D.Double();
path.moveTo(10, 10);
path.lineTo(20, 10);
path.lineTo(20, 20);
Double pointAt = ShapeHelper.getPointAt(path, 30);
System.out.println("PT: " + pointAt.getX() + ";" + pointAt.getY());
assertEquals(pointAt.getX(), 20.0, 0.00001);
assertEquals(pointAt.getY(), 30.0, 0.00001);
path = new Path2D.Double();
}
@Override
public void paint(Graphics2D g, double xOffset, double yOffset) {
g.setStroke(stroke);
// Make a diamond
double diamondHalfSize = Marker.HALF_SIZE * 1.3;
Path2D.Double path = new Path2D.Double();
path.moveTo(xOffset - diamondHalfSize, yOffset);
path.lineTo(xOffset, yOffset - diamondHalfSize);
path.lineTo(xOffset + diamondHalfSize, yOffset);
path.lineTo(xOffset, yOffset + diamondHalfSize);
path.closePath();
g.fill(path);
}
private Path2D.Double makeStar(int r1, int r2, int vc) {
int or = Math.max(r1, r2);
int ir = Math.min(r1, r2);
double agl = 0d;
double add = 2 * Math.PI / (vc * 2);
Path2D.Double p = new Path2D.Double();
p.moveTo(or * 1, or * 0);
for (int i = 0; i < vc * 2 - 1; i++) {
agl += add;
int r = i % 2 == 0 ? ir : or;
p.lineTo(r * Math.cos(agl), r * Math.sin(agl));
}
p.closePath();
AffineTransform at = AffineTransform.getRotateInstance(-Math.PI / 2, or, 0);
return new Path2D.Double(p, at);
}
@Override
public void addToPath(java.awt.geom.Path2D.Double path, XDGFShape parent) {
if (getDel()) return;
path.lineTo(getX() * parent.getWidth(), getY() * parent.getHeight());
}
private void setPath() {
path.reset();
int n = points.length;
for (int j = 0; j <= numberOfInterpolationPoints; j++) {
double t = (double) j / numberOfInterpolationPoints; // [0 <= t <= 1.0]
double x = 0;
double y = 0;
for (int k = 0; k < n; k++) {
x += B(n - 1, k, t) * points[k].x;
y += B(n - 1, k, t) * points[k].y;
}
if (j > 0) {
path.lineTo(x, y);
} else {
path.moveTo(x, y);
}
} // end for
} // end setPath
protected void updatePath(double x, double y) {
if (path == null) {
path = new Path2D.Double(Path2D.WIND_EVEN_ODD);
path.moveTo(x, y);
bounds = new Rectangle2D.Double(x, y, 0, 0);
} else {
path.lineTo(x, y);
double _xmax = bounds.getMaxX();
double _ymax = bounds.getMaxY();
double _xmin = bounds.getMinX();
double _ymin = bounds.getMinY();
if (x < _xmin) _xmin = x;
else if (x > _xmax) _xmax = x;
if (y < _ymin) _ymin = y;
else if (y > _ymax) _ymax = y;
bounds = new Rectangle2D.Double(_xmin, _ymin, _xmax - _xmin, _ymax - _ymin);
}
}
private void paintScaledTriangle(
Graphics g, double x, double y, double size, int direction, boolean isEnabled) {
size = Math.max(size, 2);
Path2D.Double path = new Path2D.Double();
path.moveTo(-size, size / 2);
path.lineTo(size, size / 2);
path.lineTo(0, -size / 2);
path.closePath();
AffineTransform affineTransform = new AffineTransform();
affineTransform.rotate(Math.PI * (direction - 1) / 4);
path.transform(affineTransform);
Graphics2D g2d = (Graphics2D) g;
double tx = x + size / 2;
double ty = y + size / 2;
g2d.translate(tx, ty);
Color oldColor = g.getColor();
if (!isEnabled) {
g2d.translate(1, 0);
g2d.setColor(highlight);
g2d.fill(path);
g2d.translate(-1, 0);
}
g2d.setColor(isEnabled ? darkShadow : shadow);
g2d.fill(path);
g2d.translate(-tx, -ty);
g2d.setColor(oldColor);
}
private Path2D.Double getPath() {
double width = getWidth() - 1;
double height = getHeight();
Path2D.Double path = new Path2D.Double();
path.moveTo(0.0, arcwidth);
path.curveTo(0.0, 0.0, arcwidth, 0.0, arcwidth, 0.0);
path.lineTo(width - arcwidth, 0.0);
path.curveTo(width, 0.0, width, arcwidth, width, arcwidth);
path.lineTo(width, height);
// path.curveTo(width, height, width - arcwidth, height, width - arcwidth, height);
path.lineTo(0.0, height);
// path.curveTo(0.0, height, 0.0, height - arcwidth, 0, height - arcwidth);
path.closePath();
return path;
}
/** Test of splitLine method, of class ShapeHelper. */
@Test
public void testSplitLine_Shape_double() {
System.out.println("splitLine");
Path2D.Double line = new Path2D.Double() {};
line.moveTo(0, 0);
line.lineTo(10, 10);
line.lineTo(0, 20);
line.lineTo(10, 30);
line.lineTo(0, 40);
double coords[] = new double[6];
List<Shape> result1 = ShapeHelper.splitLine(line, 28.28);
for (Shape shp : result1) {
PathIterator it = shp.getPathIterator(null);
System.out.println("Shape: ");
while (!it.isDone()) {
it.currentSegment(coords);
System.out.println("(" + coords[0] + ";" + " " + coords[1] + ")");
it.next();
}
}
;
result1 = ShapeHelper.splitLine(line, 35.0);
for (Shape shp : result1) {
PathIterator it = shp.getPathIterator(null);
System.out.println("Shape: ");
while (!it.isDone()) {
it.currentSegment(coords);
System.out.println("(" + coords[0] + ";" + " " + coords[1] + ")");
it.next();
}
}
result1 = ShapeHelper.splitLine(line, 70.0);
for (Shape shp : result1) {
PathIterator it = shp.getPathIterator(null);
System.out.println("Shape: ");
while (!it.isDone()) {
it.currentSegment(coords);
System.out.println("(" + coords[0] + ";" + " " + coords[1] + ")");
it.next();
}
}
}
public GamesListbox(List<GamesListbox.GameStruct> gamesArrayList) {
listboxWidth = currTheme.getListboxWidth();
listboxHeight = currTheme.getListboxHeight();
shapedListbox = currTheme.getListboxPath();
shapedListbox.transform(
AffineTransform.getTranslateInstance(
-currTheme.getListboxLeft(), -currTheme.getListboxTop()));
this.setLocation(currTheme.getListboxLeft(), currTheme.getListboxTop());
this.setSize(listboxWidth, listboxHeight);
this.setOpaque(false);
// No question of removing borders of around JList because it does not have any(!?)
// unless present in a scroll pane.
alGamesInfo = gamesArrayList;
if (alGamesInfo.size() == 1) {
bNoGameInstalled = true;
alGamesInfo.add(new GameStruct("", "Install Hint", InstallHintMonogram()));
}
alGamesInfo.add(new GameStruct("", "Bottom Filler", alGamesInfo.get(0).getLogo()));
noOfGames = alGamesInfo.size();
setSelectedGameIndex(1); // Position is important!
}
/**
* Tests if the interior of this <code>Polygon</code> intersects the interior of a specified set
* of rectangular coordinates.
*
* @param x the x coordinate of the specified rectangular shape's top-left corner
* @param y the y coordinate of the specified rectangular shape's top-left corner
* @param w the width of the specified rectangular shape
* @param h the height of the specified rectangular shape
* @return <code>true</code> if the interior of this <code>Polygon</code> and the interior of the
* specified set of rectangular coordinates intersect each other; <code>false</code>
* otherwise.
*/
@Override
public boolean intersects(double x, double y, double w, double h) {
if ((path == null) || !bounds.intersects(x, y, w, h)) return false;
return path.intersects(x, y, w, h);
}
void createBubbles() {
if (clusters == null) return;
synchronized (this.bigGridCompute) {
String sm = ((StringPropertyType) (this.getProperty("Smaller").getValue())).stringValue();
String[] smaller = sm.split(",");
ArrayList<String> nodes = graph.getNodes();
int minx = 999999999;
int miny = 999999999;
int maxx = -999999999;
int maxy = -999999999;
for (int i = 0; i < nodes.size(); i++) {
int x = drawer.getX(i);
int y = drawer.getY(i);
if (x < minx) minx = x;
if (x > maxx) maxx = x;
if (y < miny) miny = y;
if (y > maxy) maxy = y;
}
minx = minx - 500;
maxx = maxx + 500;
miny = miny - 100;
maxy = maxy + 100;
bigGrid = new BufferedImage(maxx - minx, maxy - miny, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = bigGrid.createGraphics();
bigGridSX = minx;
bigGridSY = miny;
for (int j = 0; j < clusterTypes.size(); j++) {
int ct = 0;
for (int i = 0; i < nodes.size(); i++) if (clusterTypes.get(j).equals(clusters[i])) ct++;
Rectangle2D.Double[] points = new Rectangle2D.Double[nodes.size()];
int[] s1 = new int[ct];
int[] s2 = new int[nodes.size() - ct];
ct = 0;
int ct2 = 0;
for (int i = 0; i < nodes.size(); i++) {
Rectangle2D r = this.getPointBounds(i);
points[i] =
new Rectangle2D.Double(
this.getNodeX(i) - r.getWidth() / 2,
this.getNodeY(i) - r.getHeight() / 2,
r.getWidth(),
r.getHeight());
if (!clusterTypes.get(j).equals(clusters[i])) {
s2[ct2] = i;
ct2++;
} else {
s1[ct] = i;
ct++;
}
}
int[][] sets = new int[2][];
sets[0] = s1;
sets[1] = s2;
BubbleSets bs = new BubbleSets(points, sets);
int r = ((IntegerPropertyType) this.getProperty("BubbleR1").getValue()).intValue();
boolean b = false;
for (int k = 0; k < smaller.length; k++)
if (smaller[k].equals(clusterTypes.get(j))) b = true;
if (b) r = r / 2;
bs.computeContour(
((IntegerPropertyType) this.getProperty("BubbleCellSize").getValue()).intValue(),
r,
this.getNodeSize(0) / 5,
0);
double contThresh =
((DoublePropertyType) this.getProperty("BubbleThresh").getValue()).doubleValue();
// Point2D.Double[][] lin = Util.marchingSquares(bs.grid, bs.cellSize, new
// Point2D.Double(bs.minX, bs.minY), contThresh);
Color c = this.getColor(s1[0]);
double re1 = (c.getRed() + 20 - 105. / 255. * 230.) / (150. / 255.);
double gr1 = (c.getGreen() + 20 - 105. / 255. * 230.) / (150. / 255.);
double bl1 = (c.getBlue() + 20 - 105. / 255. * 230.) / (150. / 255.);
if (re1 < 0) re1 = 0;
if (re1 > 255) re1 = 255;
if (gr1 < 0) gr1 = 0;
if (gr1 > 255) gr1 = 255;
if (bl1 < 0) bl1 = 0;
if (bl1 > 255) bl1 = 255;
c = new Color((int) re1, (int) gr1, (int) bl1, 150);
Color c2 = new Color((int) re1, (int) gr1, (int) bl1, 140);
Color c3 = new Color((int) re1, (int) gr1, (int) bl1, 130);
// Color c3 = new Color((int)(0.2*c.getRed()),
// (int)(0.2*c.getGreen()),(int)(0.2*c.getBlue()), 50);
g.setColor(c);
for (int i = 0; bs.grid != null && i < bs.grid.length; i++) {
for (int k = 0; k < bs.grid[i].length; k++) {
double degd = bs.grid[i][k];
if (degd < 0) degd = 0;
if (degd > 1) degd = 1;
if (degd > contThresh) {
if (degd > contThresh * 1.5) g.setColor(c);
else if (degd > contThresh * 1.25) g.setColor(c2);
else g.setColor(c3);
g.fillRect(
(int) (bs.minX + i * bs.cellSize - bigGridSX),
(int) (bs.minY + k * bs.cellSize - bigGridSY),
(int) bs.cellSize,
(int) bs.cellSize);
}
}
}
Point2D.Double[][] lin =
Util.marchingSquares(
bs.grid, bs.cellSize, new Point2D.Double(bs.minX, bs.minY), contThresh);
int lum = (c.getRed() + c.getGreen() + c.getBlue()) / 3;
lum = (int) (0.3 * lum);
int minc = Math.min(c.getRed(), Math.min(c.getGreen(), c.getBlue()));
int maxc = Math.max(c.getRed(), Math.max(c.getGreen(), c.getBlue()));
double re = lum + (200 - lum) * (c.getRed() - minc) / ((double) maxc - minc);
double gr = lum + (200 - lum) * (c.getGreen() - minc) / ((double) maxc - minc);
double bl = lum + (200 - lum) * (c.getBlue() - minc) / ((double) maxc - minc);
Color c4 = new Color((int) re, (int) gr, (int) bl, 75);
g.setColor(c4);
g.setStroke(new BasicStroke(4));
Path2D.Double path = new Path2D.Double();
for (int i = 0; i < lin.length; i++) {
if (lin[i].length > 0)
path.moveTo((int) lin[i][0].x - bigGridSX, (int) lin[i][0].y - bigGridSY);
for (int k = 1; k < lin[i].length; k++) {
Point2D.Double p1 = lin[i][k - 1];
Point2D.Double p2 = lin[i][k];
// g.drawLine((int)lin[i][k-1].x - bigGridSX, (int)lin[i][k-1].y - bigGridSY,
// (int)lin[i][k].x - bigGridSX, (int)lin[i][k].y- bigGridSY);
path.lineTo((int) lin[i][k].x - bigGridSX, (int) lin[i][k].y - bigGridSY);
}
path.closePath();
}
g.draw(path);
}
}
}
@Override
public void render(Graphics2D g) {
// TODO Auto-generated method stub
if (((IntegerPropertyType) this.getProperty("Bubble").getValue()).intValue() > 0) {
Rectangle2D.Double[] points = new Rectangle2D.Double[this.getNumberOfNodes()];
for (int i = 0; i < this.getNumberOfNodes(); i++) {
Rectangle2D r = this.getPointBounds(i);
// points[i] = new Rectangle2D.Double(this.getNodeX(i) - this.getNodeSize(i)/2,
// this.getNodeY(i) - this.getNodeSize(i)/2, this.getNodeSize(i), this.getNodeSize(i));
points[i] =
new Rectangle2D.Double(
this.getNodeX(i) - r.getWidth() / 2,
this.getNodeY(i) - r.getHeight() / 2,
r.getWidth(),
r.getHeight());
}
// this.setAspect(PointAspectType.RECT_NO_LABEL);
int[] s1 = this.getSelectedNodes();
int[] s2 = new int[this.getNumberOfNodes() - s1.length];
for (int i = 0, c = 0; i < this.getNumberOfNodes(); i++) {
boolean found = false;
for (int j = 0; j < s1.length; j++)
if (s1[j] == i) {
found = true;
break;
}
;
if (!found) {
s2[c] = i;
c++;
}
}
int[][] sets = new int[2][];
sets[0] = s1;
sets[1] = s2;
this.bubbleSets = new BubbleSets(points, sets);
bubbleSets.computeContour(10, 100, this.getNodeSize(0) / 2, 0);
}
if (bigGrid != null) {
g.drawImage(bigGrid, bigGridSX, bigGridSY, null);
}
if (bubbleSets != null) {
bubbleSets.computeContour(
((IntegerPropertyType) this.getProperty("BubbleCellSize").getValue()).intValue(),
((IntegerPropertyType) this.getProperty("BubbleR1").getValue()).intValue(),
this.getNodeSize(0) / 5,
0);
/* for (int i=0; bubbleSets.paths != null && i<bubbleSets.paths.size(); i++)
{
for (int j=1; j<bubbleSets.paths.get(i).size(); j++)
{
Point2D.Double p1 = bubbleSets.paths.get(i).get(j-1);
Point2D.Double p2 = bubbleSets.paths.get(i).get(j);
g.drawLine((int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y);
}
}*/
// the grid
double contThresh =
((DoublePropertyType) this.getProperty("BubbleThresh").getValue()).doubleValue();
/*for (int i=0; bubbleSets.grid != null && i<bubbleSets.grid.length; i++)
{
for (int j=0; j<bubbleSets.grid[i].length; j++)
{
int cx = (int)bubbleSets.centroid.x;
int cy = (int)bubbleSets.centroid.y;
double degd = bubbleSets.grid[i][j];
if (degd < 0) degd = 0; if (degd > 1) degd = 1;
if (degd > contThresh) degd = 0.5;
int deg = (int)(255* degd);
if (deg < 0) deg = 0;
if (deg == 0)
continue;
g.setColor(new Color(255-deg, 255, 255-deg, 100));
g.fillRect((int)(bubbleSets.minX + i*bubbleSets.cellSize),(int)( bubbleSets.minY + j*bubbleSets.cellSize),(int)bubbleSets.cellSize, (int)bubbleSets.cellSize);
}
}*/
Point2D.Double[][] lin =
Util.marchingSquares(
bubbleSets.grid,
bubbleSets.cellSize,
new Point2D.Double(bubbleSets.minX, bubbleSets.minY),
contThresh);
g.setColor(Color.green);
g.setStroke(new BasicStroke(2));
Path2D.Double path = new Path2D.Double();
for (int i = 0; i < lin.length; i++) {
if (lin[i].length > 0) path.moveTo((int) lin[i][0].x, (int) lin[i][0].y);
for (int j = 1; j < lin[i].length; j++) path.lineTo((int) lin[i][j].x, (int) lin[i][j].y);
path.closePath();
}
// path.closePath();
g.fill(path);
if (lin.length > 1) g.setColor(Color.red);
else g.setColor(Color.black);
Color[] cs = {
Color.red, Color.blue, Color.orange, Color.black, Color.cyan, Color.MAGENTA, Color.pink
};
for (int i = 0; i < lin.length; i++) {
g.setColor(cs[i]);
for (int j = 1; j < lin[i].length; j++)
g.drawLine(
(int) lin[i][j - 1].x, (int) lin[i][j - 1].y, (int) lin[i][j].x, (int) lin[i][j].y);
}
// g.draw(path);
}
super.render(g);
}
@Override
public PathIterator getPathIterator(AffineTransform at) {
return shape.getPathIterator(at);
}
@Override
public boolean contains(double x, double y) {
return shape.contains(x, y);
}
@Override
public Rectangle2D getBounds2D() {
return shape.getBounds2D();
}
@Override
public boolean contains(int x, int y) {
return shapedListbox.contains(x, y);
}
@Override
public boolean contains(double x, double y, double w, double h) {
return shape.contains(x, y, w, h);
}
/**
* Returns an iterator object that iterates along the boundary of this <code>Polygon</code> and
* provides access to the geometry of the outline of this <code>Polygon</code>. An optional {@link
* AffineTransform} can be specified so that the coordinates returned in the iteration are
* transformed accordingly.
*
* @param at an optional <code>AffineTransform</code> to be applied to the coordinates as they are
* returned in the iteration, or <code>null</code> if untransformed coordinates are desired
* @return a {@link PathIterator} object that provides access to the geometry of this <code>
* Polygon</code>.
*/
@Override
public PathIterator getPathIterator(AffineTransform at) {
if (path == null) return new Path2D.Double().getPathIterator(at);
return path.getPathIterator(at);
}
@Override
public boolean intersects(double x, double y, double w, double h) {
return shape.intersects(x, y, w, h);
}