/** Draws the edge structure of the tree */
public void drawEdges(Graphics2D gg) {
gg.setPaint(Color.black);
Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
// For each vertex...
while (nodeList.hasMoreElements()) {
// Get its edge list...
TreeVertex vertex = (TreeVertex) nodeList.nextElement();
Enumeration edges = vertex.getEdgeList().elements();
// For each edge in the list...
while (edges.hasMoreElements()) {
TreeEdge edge = (TreeEdge) edges.nextElement();
// If we have several vertices on layer 0, only draw
// edges for layers below that
if (!(argument.isMultiRoots() && vertex.getLayer() == 0)) {
// If the edge has been selected with the mouse,
// use a thick line
if (edge.isSelected()) {
gg.setStroke(selectStroke);
}
gg.draw(edge.getShape(this));
// If we used a thick line, reset the stroke to normal
// line for next edge.
if (edge.isSelected()) {
gg.setStroke(solidStroke);
}
TreeVertex edgeSource = edge.getDestVertex();
}
}
}
}
// From: http://forum.java.sun.com/thread.jspa?threadID=378460&tstart=135
void drawArrow(
Graphics2D g2d,
int xCenter,
int yCenter,
int x,
int y,
float stroke,
BasicStroke drawStroke) {
double aDir = Math.atan2(xCenter - x, yCenter - y);
// Line can be dashed.
g2d.setStroke(drawStroke);
g2d.drawLine(x, y, xCenter, yCenter);
// make the arrow head solid even if dash pattern has been specified
g2d.setStroke(lineStroke);
Polygon tmpPoly = new Polygon();
int i1 = 12 + (int) (stroke * 2);
// make the arrow head the same size regardless of the length length
int i2 = 6 + (int) stroke;
tmpPoly.addPoint(x, y);
tmpPoly.addPoint(x + xCor(i1, aDir + .5), y + yCor(i1, aDir + .5));
tmpPoly.addPoint(x + xCor(i2, aDir), y + yCor(i2, aDir));
tmpPoly.addPoint(x + xCor(i1, aDir - .5), y + yCor(i1, aDir - .5));
tmpPoly.addPoint(x, y); // arrow tip
g2d.drawPolygon(tmpPoly);
// Remove this line to leave arrow head unpainted:
g2d.fillPolygon(tmpPoly);
}
public void paint(Graphics g) {
super.paint(g);
if (_focus && g instanceof Graphics2D) {
Stroke old = ((Graphics2D) g).getStroke();
((Graphics2D) g).setStroke(_dashed);
g.drawRect(0, 0, getWidth() - 1, getHeight() - 1);
((Graphics2D) g).setStroke(old);
}
}
/**
* Draws the edge.
*
* @param graphics the graphics context
*/
public void draw(Graphics2D graphics) {
updateContactPoints();
Color oldColor = graphics.getColor();
Stroke oldStroke = graphics.getStroke();
graphics.setColor(getBorderColor());
graphics.setStroke(getLineStyle());
graphics.draw(getPath());
graphics.setStroke(oldStroke);
graphics.setColor(oldColor);
}
/** paint the canvas into a image file of given width and height */
public void writeToImage(String s, int w, int h) {
String ext;
File f;
try {
ext = s.substring(s.lastIndexOf(".") + 1);
f = new File(s);
} catch (Exception e) {
System.out.println(e);
return;
}
if (!ext.equals("jpg") && !ext.equals("png")) {
System.out.println("Cannot write to file: Illegal extension " + ext);
return;
}
boolean opq = true;
if (theOpaque != null) opq = theOpaque;
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setBackground(Color.white);
g2.setPaint(Color.black);
g2.setStroke(new BasicStroke(1));
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
doBuffer(g2, true, new Rectangle(0, 0, w, h));
try {
ImageIO.write(image, ext, f);
} catch (Exception e) {
System.out.println(e);
}
}
/** This method is invoked before the rendered image of the figure is composited. */
public void drawFigure(Graphics2D g) {
AffineTransform savedTransform = null;
if (get(TRANSFORM) != null) {
savedTransform = g.getTransform();
g.transform(get(TRANSFORM));
}
if (get(FILL_STYLE) != ODGConstants.FillStyle.NONE) {
Paint paint = ODGAttributeKeys.getFillPaint(this);
if (paint != null) {
g.setPaint(paint);
drawFill(g);
}
}
if (get(STROKE_STYLE) != ODGConstants.StrokeStyle.NONE) {
Paint paint = ODGAttributeKeys.getStrokePaint(this);
if (paint != null) {
g.setPaint(paint);
g.setStroke(ODGAttributeKeys.getStroke(this));
drawStroke(g);
}
}
if (get(TRANSFORM) != null) {
g.setTransform(savedTransform);
}
}
void drawLine(Graphics g, DrawObject L) {
if (L == null) {
return;
}
if ((sequencingOn) && (L.sequenceNum != currentSequenceNumDisplay)) {
return;
}
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(L.drawStroke);
int x1 = (int) ((L.x - minX) / (maxX - minX) * (D.width - 2 * inset));
int y1 = (int) ((L.y - minY) / (maxY - minY) * (D.height - 2.0 * inset));
int x2 = (int) ((L.x2 - minX) / (maxX - minX) * (D.width - 2 * inset));
int y2 = (int) ((L.y2 - minY) / (maxY - minY) * (D.height - 2.0 * inset));
if (L.isArrow) {
drawArrow(
(Graphics2D) g,
inset + x1,
D.height - y1 - inset,
inset + x2,
D.height - y2 - inset,
1.0f,
L.drawStroke);
} else {
g.drawLine(inset + x1, D.height - y1 - inset, inset + x2, D.height - y2 - inset);
}
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D gfx = (Graphics2D) g;
gfx.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// Clear screen
gfx.setColor(Constants.BACKGROUND_COLOR);
gfx.fillRect(0, 0, getWidth(), getHeight());
// Render next frame
grid.draw(gfx);
// Trace path line
if (tracing) {
gfx.setColor(Constants.PATH_COLOR);
gfx.setStroke(new BasicStroke(2));
for (int i = 1; i < pathLine.size(); i++) {
Coordinate p = pathLine.get(i - 1);
Coordinate n = pathLine.get(i);
gfx.drawLine(
(Constants.TILESIZE + Constants.MARGIN) * p.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * p.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.x
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN,
(Constants.TILESIZE + Constants.MARGIN) * n.y
+ (Constants.TILESIZE / 2)
+ Constants.MARGIN);
}
}
}
/**
* Draws this without refreshing steps.
*
* @param panel the drawing panel requesting the drawing
* @param _g the graphics context on which to draw
*/
public void drawMe(DrawingPanel panel, Graphics _g) {
// position and show inspector if requested during loading
if (inspectorX != Integer.MIN_VALUE
&& trackerPanel != null
&& trackerPanel.getTFrame() != null) {
positionInspector();
Runnable runner =
new Runnable() {
public void run() {
showInspector = false;
inspector.setVisible(true);
}
};
if (showInspector) SwingUtilities.invokeLater(runner);
}
if (isVisible() && isTraceVisible()) {
// draw trace only if fixed coords & (non-worldview or no ref frame)
TrackerPanel tPanel = (TrackerPanel) panel;
ImageCoordSystem coords = tPanel.getCoords(); // get active coords
boolean isRefFrame = coords instanceof ReferenceFrame;
if (isRefFrame) {
coords = ((ReferenceFrame) coords).getCoords();
}
boolean fixed = coords.isFixedAngle() && coords.isFixedOrigin() && coords.isFixedScale();
if (fixed && (!(tPanel instanceof WorldTView) || !isRefFrame)) {
trace.reset();
for (int i = 0; i < traceX.length; i++) {
if (Double.isNaN(traceX[i])) continue;
tracePt.setLocation(traceX[i], traceY[i]);
java.awt.Point p = tracePt.getScreenPosition(tPanel);
if (trace.getCurrentPoint() == null) trace.moveTo((float) p.getX(), (float) p.getY());
else trace.lineTo((float) p.getX(), (float) p.getY());
}
Graphics2D g2 = (Graphics2D) _g;
Color color = g2.getColor();
Stroke stroke = g2.getStroke();
g2.setColor(getFootprint().getColor());
g2.setStroke(traceStroke);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
g2.draw(trace);
// restore original color and stroke
g2.setColor(color);
g2.setStroke(stroke);
}
}
super.draw(panel, _g);
}
public BufferedImage filter(BufferedImage src, BufferedImage dst) {
if (dst == null) dst = createCompatibleDestImage(src, null);
int width = src.getWidth();
int height = src.getHeight();
int numScratches = (int) (density * width * height / 100);
ArrayList<Line2D> lines = new ArrayList<Line2D>();
{
float l = length * width;
Random random = new Random(seed);
Graphics2D g = dst.createGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(new Color(color));
g.setStroke(new BasicStroke(this.width));
for (int i = 0; i < numScratches; i++) {
float x = width * random.nextFloat();
float y = height * random.nextFloat();
float a = angle + ImageMath.TWO_PI * (angleVariation * (random.nextFloat() - 0.5f));
float s = (float) Math.sin(a) * l;
float c = (float) Math.cos(a) * l;
float x1 = x - c;
float y1 = y - s;
float x2 = x + c;
float y2 = y + s;
g.drawLine((int) x1, (int) y1, (int) x2, (int) y2);
lines.add(new Line2D.Float(x1, y1, x2, y2));
}
g.dispose();
}
if (false) {
// int[] inPixels = getRGB( src, 0, 0, width, height, null );
int[] inPixels = new int[width * height];
int index = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float sx = x, sy = y;
for (int i = 0; i < numScratches; i++) {
Line2D.Float l = (Line2D.Float) lines.get(i);
float dot = (l.x2 - l.x1) * (sx - l.x1) + (l.y2 - l.y1) * (sy - l.y1);
if (dot > 0) inPixels[index] |= (1 << i);
}
index++;
}
}
Colormap colormap = new LinearColormap();
index = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float f = (float) (inPixels[index] & 0x7fffffff) / 0x7fffffff;
inPixels[index] = colormap.getColor(f);
index++;
}
}
setRGB(dst, 0, 0, width, height, inPixels);
}
return dst;
}
/** PaintComponent to draw everything. */
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
setBackground(Color.WHITE);
// If using images, use cool dragon background
if (useImages) g.drawImage(background, 0, 0, 310, 300, null);
// Use light gray to not overpower the background image
g.setColor(Color.LIGHT_GRAY);
for (int y = 1; y < ROWS; ++y)
g.fillRoundRect(0, cellSize * y - 4, (cellSize * COLS) - 1, 8, 8, 8);
for (int x = 1; x < COLS; ++x)
g.fillRoundRect(cellSize * x - 4, 0, 8, (cellSize * ROWS) - 1, 8, 8);
// Use graphics2d for when not using the images
Graphics2D g2d = (Graphics2D) g;
g2d.setStroke(new BasicStroke(4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
for (int y = 0; y < ROWS; ++y) {
for (int x = 0; x < COLS; ++x) {
int x1 = x * cellSize + 16;
int y1 = y * cellSize + 16;
if (board[y][x] == Symbol.X) {
// use image if set to true, otherwise use g2d
// for thicker, better looking X's and O's
if (useImages) g.drawImage(imageX, x1, y1, 75, 75, null);
else {
g2d.setColor(PURPLE);
int x2 = (x + 1) * cellSize - 16;
int y2 = (y + 1) * cellSize - 16;
g2d.drawLine(x1, y1, x2, y2);
g2d.drawLine(x2, y1, x1, y2);
}
} else if (board[y][x] == Symbol.O) {
if (useImages) g.drawImage(imageO, x1, y1, 75, 75, null);
else {
g2d.setColor(Color.BLUE);
g2d.drawOval(x1, y1, 70, 70);
}
}
} // end for
}
// Set status bar based on gamestate. If CONTINUE, show whose turn it is
if (gameStatus == GameStatus.CONTINUE) {
statusBar.setForeground(Color.BLACK);
if (currentPlayer == Symbol.X) statusBar.setText("X's Turn");
else statusBar.setText("O's Turn");
} else if (gameStatus == GameStatus.DRAW) {
statusBar.setForeground(Color.RED);
statusBar.setText("Draw! Click to play again!");
} else if (gameStatus == GameStatus.X_WIN) {
statusBar.setForeground(Color.RED);
statusBar.setText("X has won! Click to play again!");
} else if (gameStatus == GameStatus.O_WIN) {
statusBar.setForeground(Color.RED);
statusBar.setText("O has won! Click to play again!");
}
}
public void paint(Graphics g) {
super.paint(g);
Graphics2D g2 = (Graphics2D) g;
int size =
Math.min(
MAX_SIZE,
Math.min(
getWidth() - imagePadding.left - imagePadding.right,
getHeight() - imagePadding.top - imagePadding.bottom));
g2.translate(getWidth() / 2 - size / 2, getHeight() / 2 - size / 2);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Shape shape;
if (mode == ColorPicker.SAT || mode == ColorPicker.BRI) {
shape = new Ellipse2D.Float(0, 0, size, size);
} else {
Rectangle r = new Rectangle(0, 0, size, size);
shape = r;
}
if (hasFocus()) {
PaintUtils.paintFocus(g2, shape, 5);
}
if (!(shape instanceof Rectangle)) {
// paint a circular shadow
g2.translate(2, 2);
g2.setColor(new Color(0, 0, 0, 20));
g2.fill(new Ellipse2D.Float(-2, -2, size + 4, size + 4));
g2.setColor(new Color(0, 0, 0, 40));
g2.fill(new Ellipse2D.Float(-1, -1, size + 2, size + 2));
g2.setColor(new Color(0, 0, 0, 80));
g2.fill(new Ellipse2D.Float(0, 0, size, size));
g2.translate(-2, -2);
}
g2.drawImage(image, 0, 0, size, size, 0, 0, size, size, null);
if (shape instanceof Rectangle) {
Rectangle r = (Rectangle) shape;
PaintUtils.drawBevel(g2, r);
} else {
g2.setColor(new Color(0, 0, 0, 120));
g2.draw(shape);
}
g2.setColor(Color.white);
g2.setStroke(new BasicStroke(1));
g2.draw(new Ellipse2D.Float(point.x - 3, point.y - 3, 6, 6));
g2.setColor(Color.black);
g2.draw(new Ellipse2D.Float(point.x - 4, point.y - 4, 8, 8));
g.translate(-imagePadding.left, -imagePadding.top);
}
void drawAllROIs(Graphics g) {
RoiManager rm = RoiManager.getInstance();
if (rm == null) {
rm = Interpreter.getBatchModeRoiManager();
if (rm != null && rm.getList().getItemCount() == 0) rm = null;
}
if (rm == null) {
// if (showAllList!=null)
// overlay = showAllList;
showAllROIs = false;
repaint();
return;
}
initGraphics(g, null, showAllColor);
Hashtable rois = rm.getROIs();
java.awt.List list = rm.getList();
boolean drawLabels = rm.getDrawLabels();
currentRoi = null;
int n = list.getItemCount();
if (IJ.debugMode) IJ.log("paint: drawing " + n + " \"Show All\" ROIs");
if (labelRects == null || labelRects.length != n) labelRects = new Rectangle[n];
if (!drawLabels) showAllList = new Overlay();
else showAllList = null;
if (imp == null) return;
int currentImage = imp.getCurrentSlice();
int channel = 0, slice = 0, frame = 0;
boolean hyperstack = imp.isHyperStack();
if (hyperstack) {
channel = imp.getChannel();
slice = imp.getSlice();
frame = imp.getFrame();
}
drawNames = Prefs.useNamesAsLabels;
for (int i = 0; i < n; i++) {
String label = list.getItem(i);
Roi roi = (Roi) rois.get(label);
if (roi == null) continue;
if (showAllList != null) showAllList.add(roi);
if (i < 200 && drawLabels && roi == imp.getRoi()) currentRoi = roi;
if (Prefs.showAllSliceOnly && imp.getStackSize() > 1) {
if (hyperstack && roi.getPosition() == 0) {
int c = roi.getCPosition();
int z = roi.getZPosition();
int t = roi.getTPosition();
if ((c == 0 || c == channel) && (z == 0 || z == slice) && (t == 0 || t == frame))
drawRoi(g, roi, drawLabels ? i : -1);
} else {
int position = roi.getPosition();
if (position == 0) position = getSliceNumber(roi.getName());
if (position == 0 || position == currentImage) drawRoi(g, roi, drawLabels ? i : -1);
}
} else drawRoi(g, roi, drawLabels ? i : -1);
}
((Graphics2D) g).setStroke(Roi.onePixelWide);
drawNames = false;
}
public void paintComponent(Graphics g) {
setSize(xSize, ySize);
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
if (PedigreeExplorer.thickLines) {
// turn this off so they don't look blurry when exported
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
} else {
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
}
g2.setColor(Color.black);
if (PedigreeExplorer.thickLines) {
g2.setStroke(new BasicStroke(2));
} else {
g2.setStroke(new BasicStroke(1));
}
if (sex == male) {
if (PedigreeExplorer.thickLines) {
g2.drawRect(1, 1, symbolSize - 2, symbolSize - 2);
} else {
g2.drawRect(0, 0, symbolSize, symbolSize);
}
if (affection == affected) {
g2.fillRect(0, 0, symbolSize, symbolSize);
}
}
if (sex == female) {
if (PedigreeExplorer.thickLines) {
g2.drawArc(1, 1, symbolSize - 2, symbolSize - 2, 0, 360);
} else {
g2.drawArc(0, 0, symbolSize, symbolSize, 0, 360);
}
if (affection == affected) {
g2.fillArc(0, 0, symbolSize, symbolSize, 0, 360);
}
}
}
/** Draw vertices on top of the edge structure */
public void drawNodes(Graphics2D gg) {
Enumeration nodeList = argument.getBreadthFirstTraversal().elements();
// Run through the traversal and draw each vertex
// using an Ellipse2D
// The draw point has been determined previously in
// calcNodeCoords()
while (nodeList.hasMoreElements()) {
TreeVertex vertex = (TreeVertex) nodeList.nextElement();
// Don't draw virtual nodes
if (vertex.isVirtual()) continue;
// If tree is incomplete and we're on the top layer, skip it
if (argument.isMultiRoots() && vertex.getLayer() == 0) continue;
Point corner = vertex.getDrawPoint();
Shape node = new Ellipse2D.Float(corner.x, corner.y, NODE_DIAM, NODE_DIAM);
vertex.setShape(node, this);
// Fill the interior of the node with vertex's fillPaint
gg.setPaint(vertex.fillPaint);
gg.fill(node);
// Draw the outline with vertex's outlinePaint; bold if selected
gg.setPaint(vertex.outlinePaint);
if (vertex.isSelected()) {
gg.setStroke(selectStroke);
} else {
gg.setStroke(solidStroke);
}
gg.draw(node);
// Draw the short label on top of the vertex
gg.setPaint(vertex.textPaint);
String shortLabelString = new String(vertex.getShortLabel());
if (shortLabelString.length() == 1) {
gg.setFont(labelFont1);
gg.drawString(shortLabelString, corner.x + NODE_DIAM / 4, corner.y + 3 * NODE_DIAM / 4);
} else if (shortLabelString.length() == 2) {
gg.setFont(labelFont2);
gg.drawString(shortLabelString, corner.x + NODE_DIAM / 5, corner.y + 3 * NODE_DIAM / 4);
}
}
}
public void paint(Graphics g) {
System.out.println("paint");
Graphics2D g2d = (Graphics2D) g;
Point1 p1, p2;
n = paintInfo.size();
if (toolFlag == 2) g2d.clearRect(0, 0, getSize().width - 100, getSize().height - 100); // 清除
for (int i = 0; i < n - 1; i++) {
p1 = (Point1) paintInfo.elementAt(i);
p2 = (Point1) paintInfo.elementAt(i + 1);
size = new BasicStroke(p1.boarder, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
g2d.setColor(p1.col);
g2d.setStroke(size);
if (p1.tool == p2.tool) {
switch (p1.tool) {
case 0: // 画笔
Line2D line1 = new Line2D.Double(p1.x, p1.y, p2.x, p2.y);
g2d.draw(line1);
break;
case 1: // 橡皮
g.clearRect(p1.x, p1.y, p1.boarder, p1.boarder);
break;
case 3: // 画直线
Line2D line2 = new Line2D.Double(p1.x, p1.y, p2.x, p2.y);
g2d.draw(line2);
break;
case 4: // 画圆
Ellipse2D ellipse =
new Ellipse2D.Double(p1.x, p1.y, Math.abs(p2.x - p1.x), Math.abs(p2.y - p1.y));
g2d.draw(ellipse);
break;
case 5: // 画矩形
Rectangle2D rect =
new Rectangle2D.Double(p1.x, p1.y, Math.abs(p2.x - p1.x), Math.abs(p2.y - p1.y));
g2d.draw(rect);
break;
case 6: // 截断，跳过
i = i + 1;
break;
default:
} // end switch
} // end if
} // end for
}
private synchronized void doBuffer(Graphics2D g2, boolean opq, Rectangle rt) {
origTransform = g2.getTransform();
if (opq && rt != null) g2.clearRect(rt.x, rt.y, rt.width, rt.height);
g2.setPaint(origPaint);
g2.setFont(origFont);
g2.setStroke(origStroke);
if (inBuffer) { // System.out.println("upps");
for (int i = 0; i < a1x.size(); i++) doPaint(g2, a1x.get(i), a2x.get(i));
origTransform = null;
return;
}
for (int i = 0; i < a1.size(); i++) doPaint(g2, a1.get(i), a2.get(i));
origTransform = null;
}
/**
* Code to paint the specific shape
*
* @param w2v 2D affine transform
* @param g graphics context
*/
public void paintShape(Graphics2D g, AffineTransform w2v) {
double x = startPoint.getX();
double y = startPoint.getY();
double xEnd = endPoint.getX();
double yEnd = endPoint.getY();
g.setStroke(new BasicStroke(this.getThickness(), BasicStroke.CAP_ROUND, BasicStroke.CAP_ROUND));
Point2D v0 = w2v.transform(new Point2D.Double(x, y), null);
int ix = (int) v0.getX();
int iy = (int) v0.getY();
Point2D v1 = w2v.transform(new Point2D.Double(xEnd, yEnd), null);
g.drawLine(ix, iy, (int) v1.getX(), (int) v1.getY());
}
/**
* paintComponent schreibt alle Laendernamen an die entsprechende Stelle der Landkarte
* (Hintergrundgrafik) und zeichnet die Laendergrenzen auf der Landkarte nach.
*
* @param g Zeichenflaeche der Landkarte
*/
public void paintComponent(Graphics g) {
Shape shape;
Graphics2D g2d = (Graphics2D) g;
g2d.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
Font myFont = new Font("Times New Roman", Font.BOLD, 12);
g2d.setFont(myFont);
g2d.setStroke(new BasicStroke(2.0f));
Territory territory;
Color color;
ListIterator territories = worldMap.getTerritories().listIterator();
while (territories.hasNext()) {
territory = (Territory) territories.next();
if (territory.getOwner() != null) {
color = territory.getOwner().getPlayerColor();
} else {
color = Color.WHITE;
}
g2d.setColor(color);
g2d.drawString(
territory.getName(),
(int) territory.getMidpoint().getX() - 15,
(int) territory.getMidpoint().getY() - 10);
g2d.drawString(
new Integer(territory.getArmySize()).toString(),
(int) territory.getMidpoint().getX(),
(int) territory.getMidpoint().getY());
}
if (territoryBattle.size() != 0) {
for (int j = 0; j < territoryBattle.size(); j++) {
g2d.setColor(territoryBattle.get(j).getOwner().getPlayerColor());
// g2d.fillPolygon(territoryTmp.getFrontiers()); Sieht bei unseren Grenzen nicht huebsch
// aus
g2d.drawPolygon(territoryBattle.get(j).getFrontiers());
}
}
repaint();
}
private void drawArrow(Graphics2D g, double fx, double fy, double tx, double ty) {
double d = Point2D.distance(fx, fy, tx, ty);
if (d == 0) return;
double t = arrow_size / d;
double cx0 = tx + 2 * t * (fx - tx);
double cy0 = ty + 2 * t * (fy - ty);
double cx1 = cx0 + t * (fy - ty);
double cy1 = cy0 - t * (fx - tx);
double cx2 = cx0 - t * (fy - ty);
double cy2 = cy0 + t * (fx - tx);
g.setStroke(arrow_stroke);
Line2D.Double l2 = new Line2D.Double(cx1, cy1, tx, ty);
g.draw(l2);
l2.setLine(cx2, cy2, tx, ty);
g.draw(l2);
}
void drawOvalOrRectangle(Graphics g, DrawObject R, boolean isRect) {
if (R == null) {
return;
}
if ((sequencingOn) && (R.sequenceNum != currentSequenceNumDisplay)) {
return;
}
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(R.drawStroke);
int x1 = (int) ((R.x - minX) / (maxX - minX) * (D.width - 2 * inset));
int y1 = (int) ((R.y - minY) / (maxY - minY) * (D.height - 2.0 * inset));
double x = R.x + R.width;
double y = R.y - R.height;
int x2 = (int) ((x - minX) / (maxX - minX) * (D.width - 2 * inset));
int y2 = (int) ((y - minY) / (maxY - minY) * (D.height - 2.0 * inset));
if (isRect) {
g.drawRect(inset + x1, D.height - y1 - inset, x2 - x1, y1 - y2);
} else {
g.drawOval(inset + x1, D.height - y1 - inset, x2 - x1, y1 - y2);
}
}
void drawZoomIndicator(Graphics g) {
int x1 = 10;
int y1 = 10;
double aspectRatio = (double) imageHeight / imageWidth;
int w1 = 64;
if (aspectRatio > 1.0) w1 = (int) (w1 / aspectRatio);
int h1 = (int) (w1 * aspectRatio);
if (w1 < 4) w1 = 4;
if (h1 < 4) h1 = 4;
int w2 = (int) (w1 * ((double) srcRect.width / imageWidth));
int h2 = (int) (h1 * ((double) srcRect.height / imageHeight));
if (w2 < 1) w2 = 1;
if (h2 < 1) h2 = 1;
int x2 = (int) (w1 * ((double) srcRect.x / imageWidth));
int y2 = (int) (h1 * ((double) srcRect.y / imageHeight));
if (zoomIndicatorColor == null) zoomIndicatorColor = new Color(128, 128, 255);
g.setColor(zoomIndicatorColor);
((Graphics2D) g).setStroke(Roi.onePixelWide);
g.drawRect(x1, y1, w1, h1);
if (w2 * h2 <= 200 || w2 < 10 || h2 < 10) g.fillRect(x1 + x2, y1 + y2, w2, h2);
else g.drawRect(x1 + x2, y1 + y2, w2, h2);
}
public void alpaCut(Graphics g, double alfa, int val) {
Graphics2D g2d = (Graphics2D) g;
double Xawal = X_AXIS_FIRST_X_COORD;
double Yawal = Y_AXIS_SECOND_Y_COORD;
Point2D.Double point = new Point2D.Double(Xawal, Yawal);
int xLength = (X_AXIS_SECOND_X_COORD - X_AXIS_FIRST_X_COORD) / xCoordNumbers;
int yLength = (Y_AXIS_SECOND_Y_COORD - Y_AXIS_FIRST_Y_COORD) / yCoordNumbers;
// g2d.setStroke(new BasicStroke(3));
Stroke dashed =
new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[] {9}, 0);
g2d.setStroke(dashed);
g2d.setColor(Color.black);
g2d.draw(
new Line2D.Double(
X_AXIS_FIRST_X_COORD,
Y_AXIS_SECOND_Y_COORD - ((alfa * 10) * yLength),
X_AXIS_FIRST_X_COORD + (xCoordNumbers * xLength) - 3,
Y_AXIS_SECOND_Y_COORD - ((alfa * 10) * yLength)));
// double BA, BB;
double BB, BA;
BB = sig[val] * 2 - (sig[val] + (std[val] * Math.sqrt(Math.log(1 / alfa))));
BA = sig[val] + (std[val] * Math.sqrt(Math.log(1 / alfa)));
// System.out.println(BB+"\n"+BA);
System.out.println("Batas Atas Gambar " + (val + 1) + " = " + BA);
System.out.println("Batas Bawah Gambar " + (val + 1) + " = " + BB);
g2d.draw(
new Line2D.Double(
X_AXIS_FIRST_X_COORD + (BA * xLength) - 3,
Y_AXIS_SECOND_Y_COORD,
X_AXIS_FIRST_X_COORD + (BA * xLength) - 3,
Y_AXIS_SECOND_Y_COORD - ((alfa * 10) * yLength)));
g2d.draw(
new Line2D.Double(
X_AXIS_FIRST_X_COORD + (BB * xLength) - 3,
Y_AXIS_SECOND_Y_COORD,
X_AXIS_FIRST_X_COORD + (BB * xLength) - 3,
Y_AXIS_SECOND_Y_COORD - ((alfa * 10) * yLength)));
}
private synchronized void toBuffer(int s, Object a) {
a1.add(s);
a2.add(a);
if (s == clear) {
clearBuffer();
}
if (s == opaque) theOpaque = (Boolean) a;
if (s == setBackground) theBackground = (Color) a;
if (inBuffer) return;
if (isSetter(s)) return;
Graphics g = getGraphics();
if (g == null) return;
Graphics2D g2 = (Graphics2D) g;
g2.setPaint(origPaint);
g2.setFont(origFont);
g2.setStroke(origStroke);
for (int i = 0; i < a1.size() - 1; i++) {
int s1 = a1.get(i);
Object s2 = a2.get(i);
if (isSetter(s1)) doPaint(g2, s1, s2);
}
doPaint((Graphics2D) g, s, a);
}
public void draw(Graphics2D g) {
if (AttributeKeys.FILL_COLOR.get(this) != null) {
g.setColor(AttributeKeys.FILL_COLOR.get(this));
drawFill(g);
}
if (STROKE_COLOR.get(this) != null && STROKE_WIDTH.get(this) > 0d) {
g.setStroke(AttributeKeys.getStroke(this));
g.setColor(STROKE_COLOR.get(this));
drawStroke(g);
}
if (TEXT_COLOR.get(this) != null) {
if (TEXT_SHADOW_COLOR.get(this) != null && TEXT_SHADOW_OFFSET.get(this) != null) {
Dimension2DDouble d = TEXT_SHADOW_OFFSET.get(this);
g.translate(d.width, d.height);
g.setColor(TEXT_SHADOW_COLOR.get(this));
drawText(g);
g.translate(-d.width, -d.height);
}
g.setColor(TEXT_COLOR.get(this));
drawText(g);
}
}
void drawScribbles(Graphics g) {
if ((scribbles == null) || (scribbles.size() == 0)) {
return;
}
DrawObject L = (DrawObject) scribbles.get(0);
int scribbleCounter = L.scribbleNum;
g.setColor(scribbleColor);
((Graphics2D) g).setStroke(new BasicStroke(2f));
int prevX = L.scribbleX;
int prevY = L.scribbleY;
for (int i = 1; i < scribbles.size(); i++) {
L = (DrawObject) scribbles.get(i);
if (L.scribbleNum == scribbleCounter) {
// Keep drawing.
g.drawLine(prevX, prevY, L.scribbleX, L.scribbleY);
prevX = L.scribbleX;
prevY = L.scribbleY;
} else {
scribbleCounter = L.scribbleNum;
prevX = L.scribbleX;
prevY = L.scribbleY;
}
}
}
void drawOverlay(Graphics g) {
if (imp != null && imp.getHideOverlay()) return;
Color labelColor = overlay.getLabelColor();
if (labelColor == null) labelColor = Color.white;
initGraphics(g, labelColor, Roi.getColor());
int n = overlay.size();
if (IJ.debugMode) IJ.log("paint: drawing " + n + " ROI display list");
int currentImage = imp != null ? imp.getCurrentSlice() : -1;
if (imp.getStackSize() == 1) currentImage = -1;
int channel = 0, slice = 0, frame = 0;
boolean hyperstack = imp.isHyperStack();
if (hyperstack) {
channel = imp.getChannel();
slice = imp.getSlice();
frame = imp.getFrame();
}
drawNames = overlay.getDrawNames();
boolean drawLabels = drawNames || overlay.getDrawLabels();
for (int i = 0; i < n; i++) {
if (overlay == null) break;
Roi roi = overlay.get(i);
if (hyperstack && roi.getPosition() == 0) {
int c = roi.getCPosition();
int z = roi.getZPosition();
int t = roi.getTPosition();
if ((c == 0 || c == channel) && (z == 0 || z == slice) && (t == 0 || t == frame))
drawRoi(g, roi, drawLabels ? i + LIST_OFFSET : -1);
} else {
int position = roi.getPosition();
if (position == 0 || position == currentImage)
drawRoi(g, roi, drawLabels ? i + LIST_OFFSET : -1);
}
}
((Graphics2D) g).setStroke(Roi.onePixelWide);
drawNames = false;
}
public void paintProbe(Graphics2D g2, int x1, int y1, int x2, int y2, double tmin, double tmax) {
g2.setStroke(stroke);
g2.setColor(color);
int ppx = -1, ppy = -1;
for (int i = 0; i < values.size(); i++) {
Double v = values.get(i);
if (v != null && tmax - tmin > 0.0) {
double frac = (v - tmin) / (tmax - tmin);
int pixY = y2 - (int) Math.round(frac * (y2 - y1));
int pixX = x1 + (int) Math.floor((double) (i + 1) / (double) (values.size() + 2));
if (ppx != -1) {
g2.drawLine(ppx, ppy, pixX, pixY);
}
ppx = pixX;
ppy = pixY;
} else {
ppx = ppy = -1;
}
}
}
private void drawLinks(Graphics2D g, GraphObject go) {
double x0 = graph_locations.get(go);
for (GraphLink gl : go.getLinks()) {
GraphObject got = gl.getToObject();
double x1 = graph_locations.get(got);
double y0 = getTimeY(gl.getTime());
double x3, x4;
if (x0 < x1) {
x3 = x0 + active_width / 2;
x4 = x1 - active_width / 2;
} else {
x3 = x0 - active_width / 2;
x4 = x1 + active_width / 2;
}
Stroke sk = type_strokes.get(gl.getType());
Color c = getThreadBlockColor(gl.getThread());
g.setColor(c);
g.setStroke(sk);
Line2D ln = new Line2D.Double(x3, y0, x4, y0);
g.draw(ln);
drawArrow(g, x3, y0, x4, y0);
}
}
// 画出坦克的函数
public void drawTank(int x, int y, Graphics g, int direction, int type) {
// 判断坦克类型，是敌人的还是我方的坦克，改变坦克的颜色区分
float lineWidth = 3.0f; // 设置线条为粗线
switch (type) {
case 0:
g.setColor(Color.YELLOW);
break;
case 1:
g.setColor(Color.red);
break;
}
switch (direction) {
case 0:
// 1.画出左边履带
g.fill3DRect(x, y, 5, 30, true);
// 2.画出右边履带
g.fill3DRect(x + 20, y, 5, 30, true);
// 3.画出中间机身
g.fill3DRect(x + 5, y + 5, 15, 20, false);
// 4.画出中间圆形
g.fillOval(x + 5, y + 7, 12, 12);
// 5.画出炮筒
((Graphics2D) g).setStroke(new BasicStroke(lineWidth)); // 设置线条为粗线
g.drawLine(x + 11, y - 5, x + 11, y + 17);
break;
case 1:
// 1.画出左边履带
g.fill3DRect(x, y, 30, 5, true);
// 2.画出右边履带
g.fill3DRect(x, y + 20, 30, 5, true);
// 3.画出中间机身
g.fill3DRect(x + 5, y + 5, 20, 15, false);
// 4.画出中间圆形
g.fillOval(x + 7, y + 5, 12, 12);
// 5.画出炮筒
((Graphics2D) g).setStroke(new BasicStroke(lineWidth)); // 设置线条为粗线
g.drawLine(x + 17, y + 11, x + 32, y + 11);
break;
case 2:
// 1.画出左边履带
g.fill3DRect(x, y, 5, 30, true);
// 2.画出右边履带
g.fill3DRect(x + 20, y, 5, 30, true);
// 3.画出中间机身
g.fill3DRect(x + 5, y + 5, 15, 20, false);
// 4.画出中间圆形
g.fillOval(x + 5, y + 7, 12, 12);
// 5.画出炮筒
((Graphics2D) g).setStroke(new BasicStroke(lineWidth)); // 设置线条为粗线
g.drawLine(x + 11, y + 17, x + 11, y + 32);
break;
case 3:
// 1.画出左边履带
g.fill3DRect(x, y, 30, 5, true);
// 2.画出右边履带
g.fill3DRect(x, y + 20, 30, 5, true);
// 3.画出中间机身
g.fill3DRect(x + 5, y + 5, 20, 15, false);
// 4.画出中间圆形
g.fillOval(x + 7, y + 5, 12, 12);
// 5.画出炮筒
((Graphics2D) g).setStroke(new BasicStroke(lineWidth)); // 设置线条为粗线
g.drawLine(x + 17, y + 11, x - 5, y + 11);
break;
}
}
