public static GeneralPath createArrowLine(double x0, double y0, double x1, double y1) {
float theta = (float) Math.atan((double) (y1 - y0) / (double) (x1 - x0));
float len = (float) Math.sqrt(Math.pow((x1 - x0), 2) + Math.pow((y1 - y0), 2));
float side = (x1 < x0) ? -1 : 1;
// Ideally, we should use a fixed distance from the end point,
// rather than try and calculate a percentage, as that mucks it up
// for shorter lengths...The easiest way would be to "draw" a
// circle around the point (x1,y1) and then compute the
// line-circle intersection point. I'm too lazy to do the math
// right now, though...
GeneralPath gp = new GeneralPath();
gp.reset();
gp.moveTo((float) x0, (float) y0);
gp.lineTo((float) (x0 + ((x1 - x0) * 0.9725f)), (float) (y0 + ((y1 - y0) * 0.9725f)));
gp.moveTo((float) x1, (float) y1);
gp.lineTo(
(float) (x1 - side * ALEN * (float) Math.cos(theta + AANG)),
(float) (y1 - side * ALEN * (float) Math.sin(theta + AANG)));
gp.quadTo(
(float) (x0 + ((x1 - x0) * 0.9725f)),
(float) (y0 + ((y1 - y0) * 0.9725f)),
(float) (x1 - side * ALEN * Math.cos(theta - AANG)),
(float) (y1 - side * ALEN * Math.sin(theta - AANG)));
gp.closePath();
return gp;
}
@Override
public void paint(Graphics2D graphics, Dimension dimensions) {
final Color SHADOW_COLOR = new Color(0.0f, 0.0f, 0.0f, 0.65f);
graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
graphics.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
// graphics.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
// RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
// graphics.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
// RenderingHints.VALUE_COLOR_RENDER_QUALITY);
graphics.setRenderingHint(
RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
// graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
// RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
final int imageWidth = (int) dimensions.getWidth();
final int imageHeight = (int) dimensions.getHeight();
final GeneralPath pointerShape;
pointerShape = new GeneralPath();
pointerShape.setWindingRule(Path2D.WIND_EVEN_ODD);
pointerShape.moveTo(0.5 * imageWidth, 0.16822429906542055 * imageHeight);
pointerShape.lineTo(0.48598130841121495 * imageWidth, 0.5 * imageHeight);
pointerShape.lineTo(0.5 * imageWidth, 0.5046728971962616 * imageHeight);
pointerShape.lineTo(0.5093457943925234 * imageWidth, 0.5 * imageHeight);
pointerShape.lineTo(0.5 * imageWidth, 0.16822429906542055 * imageHeight);
pointerShape.closePath();
graphics.setColor(SHADOW_COLOR);
graphics.fill(pointerShape);
graphics.dispose();
}
public java.awt.geom.GeneralPath appendPath(java.awt.geom.GeneralPath path) {
double cot = cos(theta);
double sit = sin(theta);
double cost, sint;
if (direct) {
// Counter-clockwise circle
for (double t = .1; t < PI * 2; t += .1) {
cost = cos(t);
sint = sin(t);
path.lineTo(
(float) (xc + r * cost * cot - r * sint * sit),
(float) (yc + r * cost * sit + r * sint * cot));
}
} else {
// Clockwise circle
for (double t = .1; t < PI * 2; t += .1) {
cost = cos(t);
sint = sin(t);
path.lineTo(
(float) (xc + r * cost * cot + r * sint * sit),
(float) (yc + r * cost * sit - r * sint * cot));
}
}
// line to first point
path.lineTo((float) (xc + r * cot), (float) (yc + r * sit));
return path;
}
/**
* Creates a region surrounding a line segment by 'widening' the line segment. A typical use for
* this method is the creation of a 'clickable' region for a line that is displayed on-screen.
*
* @param line the line (<code>null</code> not permitted).
* @param width the width of the region.
* @return A region that surrounds the line.
*/
public static Shape createLineRegion(final Line2D line, final float width) {
final GeneralPath result = new GeneralPath();
final float x1 = (float) line.getX1();
final float x2 = (float) line.getX2();
final float y1 = (float) line.getY1();
final float y2 = (float) line.getY2();
if ((x2 - x1) != 0.0) {
final double theta = Math.atan((y2 - y1) / (x2 - x1));
final float dx = (float) Math.sin(theta) * width;
final float dy = (float) Math.cos(theta) * width;
result.moveTo(x1 - dx, y1 + dy);
result.lineTo(x1 + dx, y1 - dy);
result.lineTo(x2 + dx, y2 - dy);
result.lineTo(x2 - dx, y2 + dy);
result.closePath();
} else {
// special case, vertical line
result.moveTo(x1 - width / 2.0f, y1);
result.lineTo(x1 + width / 2.0f, y1);
result.lineTo(x2 + width / 2.0f, y2);
result.lineTo(x2 - width / 2.0f, y2);
result.closePath();
}
return result;
}
/**
* Draws the needle.
*
* @param g2 the graphics device.
* @param plotArea the plot area.
* @param rotate the rotation point.
* @param angle the angle.
*/
@Override
protected void drawNeedle(Graphics2D g2, Rectangle2D plotArea, Point2D rotate, double angle) {
Area shape;
GeneralPath pointer = new GeneralPath();
int minY = (int) (plotArea.getMinY());
// int maxX = (int) (plotArea.getMaxX());
int maxY = (int) (plotArea.getMaxY());
int midX = (int) (plotArea.getMinX() + (plotArea.getWidth() / 2));
// int midY = (int) (plotArea.getMinY() + (plotArea.getHeight() / 2));
int lenX = (int) (plotArea.getWidth() / 10);
if (lenX < 2) {
lenX = 2;
}
pointer.moveTo(midX - lenX, maxY - lenX);
pointer.lineTo(midX + lenX, maxY - lenX);
pointer.lineTo(midX, minY + lenX);
pointer.closePath();
lenX = 4 * lenX;
Ellipse2D circle = new Ellipse2D.Double(midX - lenX / 2, plotArea.getMaxY() - lenX, lenX, lenX);
shape = new Area(circle);
shape.add(new Area(pointer));
if ((rotate != null) && (angle != 0)) {
/// we have rotation
getTransform().setToRotation(angle, rotate.getX(), rotate.getY());
shape.transform(getTransform());
}
defaultDisplay(g2, shape);
}
@Override
public void paint(Graphics2D graphics) {
ScrollBar scrollBar = (ScrollBar) getComponent();
int width = getWidth();
int height = getHeight();
graphics.setPaint(scrollButtonImageColor);
graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
GeneralPath arrow = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
if (scrollBar.getOrientation() == Orientation.HORIZONTAL) {
arrow.moveTo(0, 0);
arrow.lineTo(width + 0.5f, height / 2.0f);
arrow.lineTo(0, height);
} else {
arrow.moveTo(0, 0);
arrow.lineTo(width / 2.0f, height + 0.5f);
arrow.lineTo(width, 0);
}
arrow.closePath();
// TODO Use Graphics#fillPolygon() as optimization?
graphics.fill(arrow);
}
public void render(int w, int h, Graphics2D g2) {
g2.translate(w * .2, h * .2);
GeneralPath p = new GeneralPath(GeneralPath.WIND_NON_ZERO);
p.moveTo(0.0f, 0.0f);
p.lineTo(w * .5f, 0.0f);
p.lineTo(w * .5f, h * .2f);
p.lineTo(0.0f, h * .2f);
p.closePath();
p.moveTo(w * .05f, h * .05f);
p.lineTo(w * .55f, h * .05f);
p.lineTo(w * .55f, h * .25f);
p.lineTo(w * .05f, h * .25f);
p.closePath();
g2.setColor(LIGHT_GRAY);
g2.fill(p);
g2.setColor(BLACK);
g2.draw(p);
g2.drawString("NON_ZERO rule", 0, -5);
g2.translate(0.0f, h * .45);
p.setWindingRule(GeneralPath.WIND_EVEN_ODD);
g2.setColor(LIGHT_GRAY);
g2.fill(p);
g2.setColor(BLACK);
g2.draw(p);
g2.drawString("EVEN_ODD rule", 0, -5);
}
/**
* Draws the outline for the plot.
*
* @param g2 the graphics device.
* @param plot the plot.
* @param dataArea the area inside the axes.
*/
@Override
public void drawOutline(Graphics2D g2, CategoryPlot plot, Rectangle2D dataArea) {
float x0 = (float) dataArea.getX();
float x1 = x0 + (float) Math.abs(this.xOffset);
float x3 = (float) dataArea.getMaxX();
float x2 = x3 - (float) Math.abs(this.xOffset);
float y0 = (float) dataArea.getMaxY();
float y1 = y0 - (float) Math.abs(this.yOffset);
float y3 = (float) dataArea.getMinY();
float y2 = y3 + (float) Math.abs(this.yOffset);
GeneralPath clip = new GeneralPath();
clip.moveTo(x0, y0);
clip.lineTo(x0, y2);
clip.lineTo(x1, y3);
clip.lineTo(x3, y3);
clip.lineTo(x3, y1);
clip.lineTo(x2, y0);
clip.closePath();
// put an outline around the data area...
Stroke outlineStroke = plot.getOutlineStroke();
Paint outlinePaint = plot.getOutlinePaint();
if ((outlineStroke != null) && (outlinePaint != null)) {
g2.setStroke(outlineStroke);
g2.setPaint(outlinePaint);
g2.draw(clip);
}
}
public GeneralPath createOutline() {
GeneralPath outline = new GeneralPath();
int nLos = 100;
int nLas = 100;
boolean first = true;
for (int lo = 0; lo <= nLos; lo++) {
float x = (lo - nLos / 2) * (360.0f / nLos);
float y = -90;
if (first) outline.moveTo(x, y);
else outline.lineTo(x, y);
first = false;
}
for (int la = 0; la <= nLos; la++) {
float x = 180;
float y = (la - nLas / 2) * (180.0f / nLas);
outline.lineTo(x, y);
}
for (int lo = nLos; lo >= 0; lo--) {
float x = (lo - nLos / 2) * (360.0f / nLos);
float y = 90;
outline.lineTo(x, y);
}
for (int la = nLas; la >= 0; la--) {
float x = -180;
float y = (la - nLas / 2) * (180.0f / nLas);
outline.lineTo(x, y);
}
return outline;
}
public GeneralPath createLines() {
GeneralPath lines = new GeneralPath();
int pad = 0;
int nLos = 24;
int nLas = 100;
for (int lo = 0; lo <= nLos; lo++) {
boolean first = true;
for (int la = pad; la <= nLas - pad; la++) {
float x = (lo - nLos / 2) * (360.0f / nLos);
float y = (la - nLas / 2) * (180.0f / nLas);
if (first) lines.moveTo(x, y);
else lines.lineTo(x, y);
first = false;
}
}
nLos = 100;
nLas = 12;
for (int la = 0; la <= nLas; la++) {
boolean first = true;
for (int lo = pad; lo <= nLos - pad; lo++) {
float x = (lo - nLos / 2) * (360.0f / nLos);
float y = (la - nLas / 2) * (180.0f / nLas);
if (first) lines.moveTo(x, y);
else lines.lineTo(x, y);
first = false;
}
}
return lines;
}
public GeneralPath getBezieredPoly(Polygon pts) {
GeneralPath p = new GeneralPath();
if (pts.npoints > 0) {
p.moveTo(pts.xpoints[0], pts.ypoints[0]);
if (pts.npoints >= 4) {
int counter = 1;
for (int i = 1; i + 2 < pts.npoints; i += 3) {
p.curveTo(
pts.xpoints[i],
pts.ypoints[i],
pts.xpoints[i + 1],
pts.ypoints[i + 1],
pts.xpoints[i + 2],
pts.ypoints[i + 2]);
counter += 3;
}
while (counter < pts.npoints) {
p.lineTo(pts.xpoints[counter], pts.ypoints[counter]);
counter++;
}
} else {
for (int i = 1; i < pts.npoints; i++) {
p.lineTo(pts.xpoints[i], pts.ypoints[i]);
}
}
}
return p;
}
static {
GeneralPath p = new GeneralPath(new Rectangle2D.Float(-7, -4, 14, 8));
p.moveTo(-6.5f, -3.5f);
p.lineTo(0, 1);
p.lineTo(6.5f, -3.5f);
SHAPE = p;
}
/**
* Returns the outline of in-ribbon gallery.
*
* @param startX Start X of the in-ribbon gallery.
* @param endX End X of the in-ribbon gallery.
* @param topY Top Y of the in-ribbon gallery.
* @param bottomY Bottom Y of the in-ribbon gallery.
* @param radius Corner radius.
* @return The outline of in-ribbon gallery.
*/
public static GeneralPath getRibbonGalleryOutline(
int startX, int endX, int topY, int bottomY, float radius) {
int height = bottomY - topY;
GeneralPath result = new GeneralPath();
float radius3 = (float) (radius / (1.5 * Math.pow(height, 0.5)));
// start in the top left corner at the end of the curve
result.moveTo(startX + radius, topY);
// move to the top right corner and curve down
result.lineTo(endX - radius - 1, topY);
result.quadTo(endX - radius3 - 1, topY + radius3, endX - 1, topY + radius);
// move to the bottom right corner and curve left
result.lineTo(endX - 1, bottomY - radius - 1);
result.quadTo(endX - radius3 - 1, bottomY - 1 - radius3, endX - radius - 1, bottomY - 1);
// move to the bottom left corner and curve up
result.lineTo(startX + radius, bottomY - 1);
result.quadTo(startX + radius3, bottomY - 1 - radius3, startX, bottomY - radius - 1);
// move to the top left corner and curve right
result.lineTo(startX, topY + radius);
result.quadTo(startX + radius3, topY + radius3, startX + radius, topY);
return result;
}
/**
* Constructs a new renderer.
*
* <p>To specify the type of renderer, use one of the constants: SHAPES, LINES, SHAPES_AND_LINES,
* AREA or AREA_AND_SHAPES.
*
* @param type the type of renderer.
* @param toolTipGenerator the tool tip generator to use (<code>null</code> permitted).
* @param urlGenerator the URL generator (<code>null</code> permitted).
*/
public XYAreaRenderer(
int type, XYToolTipGenerator toolTipGenerator, XYURLGenerator urlGenerator) {
super();
setBaseToolTipGenerator(toolTipGenerator);
setURLGenerator(urlGenerator);
if (type == SHAPES) {
this.plotShapes = true;
}
if (type == LINES) {
this.plotLines = true;
}
if (type == SHAPES_AND_LINES) {
this.plotShapes = true;
this.plotLines = true;
}
if (type == AREA) {
this.plotArea = true;
}
if (type == AREA_AND_SHAPES) {
this.plotArea = true;
this.plotShapes = true;
}
this.showOutline = false;
GeneralPath area = new GeneralPath();
area.moveTo(0.0f, -4.0f);
area.lineTo(3.0f, -2.0f);
area.lineTo(4.0f, 4.0f);
area.lineTo(-4.0f, 4.0f);
area.lineTo(-3.0f, -2.0f);
area.closePath();
this.legendArea = area;
}
// public static Shape getInteriorShapeAsFirstPartTextField(Rectangle bounds) {
// int x = bounds.x;
// int y = bounds.y;
// int w = bounds.width;
// int h = bounds.height;
// int roundCorner = h;
//
// int x1 = x + w, x2 = x + roundCorner, x3 = x, x4 = x, x5 = x, x6 = x, x7 = x +
// roundCorner, x8 = x1;
// int y1 = y + h, y2 = y1, y3 = y1, y4 = y + h - roundCorner, y5 = y + roundCorner, y6 =
// y, y7 = y6, y8 = y6;
// GeneralPath path = new GeneralPath();
// path.moveTo(x1, y1);
// path.lineTo(x2, y2);
// path.curveTo(x2, y2, x3, y3, x4, y4);
// path.lineTo(x5, y5);
// path.curveTo(x5, y5, x6, y6, x7, y7);
// path.lineTo(x8, y8);
// return path;
// }
public static Shape getInteriorShapeAsLastPart(Rectangle bounds) {
int x = bounds.x;
int y = bounds.y;
int w = bounds.width;
int h = bounds.height;
int roundCorner = h / 2;
int x1 = x, x2 = x + w - roundCorner, x3 = x + w, x4 = x3, x5 = x3, x6 = x3, x7 = x2, x8 = x1;
int y1 = y,
y2 = y1,
y3 = 1,
y4 = y + roundCorner,
y5 = y + h - roundCorner,
y6 = y + h,
y7 = y6,
y8 = y6;
GeneralPath path = new GeneralPath();
path.moveTo(x1, y1);
path.lineTo(x2, y2);
path.curveTo(x2, y2, x3, y3, x4, y4);
path.lineTo(x5, y5);
path.curveTo(x5, y5, x6, y6, x7, y7);
path.lineTo(x8, y8);
return path;
}
public void drawTo(Graphics g, Line line) {
if (!calc.tileOnMap(t1) || !calc.tileOnMap(t2)) return;
if (calc.tileOnMap(line.getTile1()) && calc.tileOnMap(line.getTile2())) {
Point p1 = calc.tileToMinimap(t1);
Point p2 = calc.tileToMinimap(t2);
Point p3 = calc.tileToMinimap(line.getTile2());
Point p4 = calc.tileToMinimap(line.getTile1());
GeneralPath path = new GeneralPath();
path.moveTo(p1.x, p1.y);
path.lineTo(p2.x, p2.y);
path.lineTo(p3.x, p3.y);
path.lineTo(p4.x, p4.y);
path.closePath();
g.setColor(POLY_FILL);
((Graphics2D) g).fill(path);
((Graphics2D) g).draw(path);
}
Point last = null, p;
g.setColor(Color.ORANGE);
for (RSTile t : pathList) {
if (calc.tileOnMap(t)) {
p = calc.tileToMinimap(t);
g.fillOval(p.x - 2, p.y - 2, 5, 5);
if (last != null) g.drawLine(p.x, p.y, last.x, last.y);
last = p;
} else last = null;
}
}
void draw(GeneralPath path, Graphics2D g2d) {
g2d.translate(47, 30);
path.moveTo(33, 0);
path.lineTo(0, 33);
path.lineTo(0, 34);
path.lineTo(33, 67);
path.closePath();
}
/**
* Creates a triangle shape that points downwards.
*
* @param s the size factor (equal to half the height of the triangle).
* @return A triangle shape.
*/
public static Shape createDownTriangle(final float s) {
final GeneralPath p0 = new GeneralPath();
p0.moveTo(0.0f, s);
p0.lineTo(s, -s);
p0.lineTo(-s, -s);
p0.closePath();
return p0;
}
public void quad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {
GeneralPath gp = new GeneralPath();
gp.moveTo(x1, y1);
gp.lineTo(x2, y2);
gp.lineTo(x3, y3);
gp.lineTo(x4, y4);
gp.closePath();
drawShape(gp);
}
{
path.moveTo(0, -10);
path.lineTo(0, -2);
path.lineTo(-7, -4);
path.lineTo(0, 10);
path.lineTo(7, -4);
path.lineTo(0, -2);
path.closePath();
}
{
myShape.moveTo(0, 5);
myShape.lineTo(-5, 3.5);
myShape.lineTo(-5, -5);
myShape.lineTo(5, -5);
myShape.lineTo(5, 3.5);
myShape.lineTo(0, 5);
myShape.closePath();
}
/**
* Creates a diamond shape.
*
* @param s the size factor (equal to half the height of the diamond).
* @return A diamond shape.
*/
public static Shape createDiamond(final float s) {
final GeneralPath p0 = new GeneralPath();
p0.moveTo(0.0f, -s);
p0.lineTo(s, 0.0f);
p0.lineTo(0.0f, s);
p0.lineTo(-s, 0.0f);
p0.closePath();
return p0;
}
/** Constructor for objects of class CoffeeCup */
public CoffeeCup(double x, double y, double width, double height) {
// Specify the upper left corner, and the
// width and height of the original points used to
// plot the *hard-coded* coffee cup
final double ORIG_ULX = 100.0;
final double ORIG_ULY = 100.0;
final double ORIG_HEIGHT = 300.0;
final double ORIG_WIDTH = 400.0;
GeneralPath leftSide = new GeneralPath();
// left side of cup
leftSide.moveTo(200, 400);
leftSide.lineTo(160, 360);
leftSide.lineTo(130, 300);
leftSide.lineTo(100, 200);
leftSide.lineTo(100, 100);
GeneralPath topAndBottom = new GeneralPath();
topAndBottom.moveTo(100, 100);
topAndBottom.lineTo(500, 100); // top of cup
topAndBottom.moveTo(200, 400);
topAndBottom.lineTo(400, 400); // bottom of cup
Shape rightSide = ShapeTransforms.horizontallyFlippedCopyOf(leftSide);
// after flipping around the upper left hand corner of the
// bounding box, we move this over to the right by 400 pixels
rightSide = ShapeTransforms.translatedCopyOf(rightSide, 400.0, 0.0);
// now we put the whole thing together ino a single path.
GeneralPath wholeCup = new GeneralPath();
wholeCup.append(topAndBottom, false);
wholeCup.append(leftSide, false);
wholeCup.append(rightSide, false);
// translate to the origin by subtracting the original upper left x and y
// then translate to (x,y) by adding x and y
Shape s = ShapeTransforms.translatedCopyOf(wholeCup, -ORIG_ULX + x, -ORIG_ULY + y);
// scale to correct height and width
s = ShapeTransforms.scaledCopyOf(s, width / ORIG_WIDTH, height / ORIG_HEIGHT);
// Use the GeneralPath constructor that takes a shape and returns
// it as a general path to set our instance variable cup
this.set(new GeneralPath(s));
}
void draw(GeneralPath path, Graphics2D g2d) {
g2d.translate(31, 47);
path.moveTo(0, 33);
path.lineTo(33, 0);
path.lineTo(34, 0);
path.lineTo(67, 33);
path.closePath();
}
/**
* 刻度尺
*
* @param 十字左上角坐标
* @param 单位像素
* @return
*/
public static Shape rule(Point2D point, double pix_cm) {
double x = point.getX();
double y = point.getY();
GeneralPath path = new GeneralPath();
path.moveTo(x, y);
path.lineTo(x, y + pix_cm / 5);
path.lineTo(x + pix_cm, y + pix_cm / 5);
path.lineTo(x + pix_cm, y);
return path;
}
private Shape createTabShape(int x, int y, int w, int h) {
GeneralPath shape = new GeneralPath();
shape.moveTo(x, y + h);
shape.lineTo(x, y + OFFSET);
shape.quadTo(x, y + OFFSET, x + OFFSET, y);
shape.lineTo(x + w - OFFSET, y);
shape.quadTo(x + w - OFFSET, y, x + w, y + OFFSET);
shape.lineTo(x + w, y + h);
shape.closePath();
return shape;
}
public Shape createStrokedShape(Shape shape) {
GeneralPath result = new GeneralPath();
PathIterator it = new FlatteningPathIterator(shape.getPathIterator(null), FLATNESS);
float points[] = new float[6];
float moveX = 0, moveY = 0;
float lastX = 0, lastY = 0;
float thisX = 0, thisY = 0;
int type = 0;
float next = 0;
int phase = 0;
while (!it.isDone()) {
type = it.currentSegment(points);
switch (type) {
case PathIterator.SEG_MOVETO:
moveX = lastX = points[0];
moveY = lastY = points[1];
result.moveTo(moveX, moveY);
next = wavelength / 2;
break;
case PathIterator.SEG_CLOSE:
points[0] = moveX;
points[1] = moveY;
// Fall into....
case PathIterator.SEG_LINETO:
thisX = points[0];
thisY = points[1];
float dx = thisX - lastX;
float dy = thisY - lastY;
float distance = (float) Math.sqrt(dx * dx + dy * dy);
if (distance >= next) {
float r = 1.0f / distance;
while (distance >= next) {
float x = lastX + next * dx * r;
float y = lastY + next * dy * r;
if ((phase & 1) == 0) result.lineTo(x + amplitude * dy * r, y - amplitude * dx * r);
else result.lineTo(x - amplitude * dy * r, y + amplitude * dx * r);
next += wavelength;
phase++;
}
}
next -= distance;
lastX = thisX;
lastY = thisY;
if (type == PathIterator.SEG_CLOSE) result.closePath();
break;
}
it.next();
}
return stroke.createStrokedShape(result);
}
/**
* ************************************************************************* The method which
* testing, if the triangle contains the point
*
* @param P - point which will be tested
* @return boolean true - the triangle contains the point false - the triangle doesn't contains
* point
*/
public boolean contains(PointDT P) {
GeneralPath triangle = new GeneralPath();
triangle.moveTo((float) A.x, (float) A.y);
triangle.lineTo((float) B.x, (float) B.y);
triangle.lineTo((float) C.x, (float) C.y);
triangle.lineTo((float) A.x, (float) A.y);
triangle.closePath();
// System.out.println("Je uvnitr + " +triangle.contains(P.x, P.y));
return triangle.contains(P.x, P.y);
}
private static GeneralPath createAreaShape() {
GeneralPath areaShape = new GeneralPath();
areaShape.moveTo(0, 0);
areaShape.lineTo(0, -5);
areaShape.lineTo(5, -10);
areaShape.lineTo(10, -5);
areaShape.lineTo(15, -7);
areaShape.lineTo(15, 0);
areaShape.closePath();
return areaShape;
}
public static void createShapeBevel(
Graphics2D g2,
Shape theShape,
double flatness,
int numBands,
float bevelSize,
float light[]) {
// draw bands from inside of shape to outside (important)
for (int i = numBands - 1; i >= 0; i--) {
// get the path around the block area, flattening any curves
// 0.2 is flattening tolerance, big == faster, small == smoother
BevelIterator bi = new BevelIterator(theShape, flatness);
// cos and sin of angle between surface normal and screen plane
float theCos = 1f - ((float) i + 0.5f) / numBands; // center of band
float theSin = (float) Math.sqrt(1 - theCos * theCos);
float from = 0; // draw strips from outer edge,
float to = 1f / numBands * (i + 1) * bevelSize; // to this distance
// the overlap makes sure there is no tiny space between the bands
g2.setStroke(new BasicStroke(to - from));
float[] p = {0, 0};
float norm[] = {0, 0, 0};
float grayAlpha[] = {0, 0}; // receives gray and alpha
while (!bi.isDone()) {
// count++;
bi.nextSegment();
norm[0] = bi.perpVec[0] * theCos;
norm[1] = bi.perpVec[1] * theCos;
norm[2] = theSin;
getLightingOverlay(norm, light, grayAlpha);
g2.setColor(new Color(grayAlpha[0], grayAlpha[0], grayAlpha[0], grayAlpha[1]));
g2.setComposite(AlphaComposite.Src);
GeneralPath gp = new GeneralPath();
bi.insetPoint2(from, p);
gp.moveTo(p[0], p[1]);
bi.insetPoint3(from, p);
gp.lineTo(p[0], p[1]);
bi.insetPoint3(to, p);
gp.lineTo(p[0], p[1]);
bi.insetPoint2(to, p);
gp.lineTo(p[0], p[1]);
gp.closePath();
g2.fill(gp);
}
}
}
