public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
currentX = leftMargin;
currentY = topMargin;
// Draw the links
for (int i = 0; i < linkLines.length; i++) {
if (weights[i].isActive()) {
g2.setPaint(weights[i].getColor());
g2.draw(linkLines[i]);
}
}
g2.setPaint(Color.black);
// Draw the input neurons
g2.drawString("Inputs", (float) currentX, (float) currentY);
currentY += titleSpace;
for (int i = 0; i < genome.getInputs(); i++) {
g2.drawImage(inputNeuron, (int) currentX, (int) currentY, null);
currentY += space;
}
// Draw the hidden Neurons
currentX += space;
currentY = topMargin;
g2.drawString("Hidden Layers", (float) currentX, (float) currentY);
for (int i = 0; i < genome.getHiddenLayers(); i++) {
currentY = topMargin + titleSpace;
for (int j = 0; j < genome.getNeuronsInHiddenLayer(); j++) {
g2.drawImage(hiddenNeuron, (int) currentX, (int) currentY, null);
currentY += space;
}
currentX += space;
}
// Draw the output neurons
currentY = topMargin;
g2.drawString("Outputs", (float) currentX, (float) currentY);
currentY += titleSpace;
for (int i = 0; i < genome.getOutputs(); i++) {
g2.drawImage(outputNeuron, (int) currentX, (int) currentY, null);
currentY += space;
}
// Draw the links
for (int i = 0; i < linkLines.length; i++) {
if (weights[i].isActive()) {
g2.setPaint(weights[i].getColor());
g2.draw(linkLines[i]);
}
}
}
protected void drawImageMosaic(Graphics2D g2) {
// Break the image up into tiles. Draw each
// tile with its own transparency, allowing
// the background to show through to varying
// degrees.
int side = 36;
int width = mImage.getWidth();
int height = mImage.getHeight();
for (int y = 0; y < height; y += side) {
for (int x = 0; x < width; x += side) {
// Calculate an appropriate transparency value.
float xBias = (float) x / (float) width;
float yBias = (float) y / (float) height;
float alpha = 1.0f - Math.abs(xBias - yBias);
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
// Draw the subimage.
int w = Math.min(side, width - x);
int h = Math.min(side, height - y);
BufferedImage tile = mImage.getSubimage(x, y, w, h);
g2.drawImage(tile, x, y, null);
}
}
// Reset the composite.
g2.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
}
/**
* Render the View to the given graphic context. This implementation render the interior first,
* then the outline.
*/
public void paint(Graphics2D g, Rectangle2D a) {
if (!a.intersects(getBounds())) return;
if (image != null) { // paint bitmap
g.drawImage(image, text2ModelTr, null);
// debug:
g.setPaint(Color.red);
g.draw(this.bounds);
super.paint(g, a); // possibly paint framebox if non-null
} else { // paint textlayout
super.paint(g, a); // possibly paint framebox if non-null
AffineTransform oldAT = g.getTransform();
// paint text in black
g.setPaint(Color.black);
// from now on, we work in Y-direct (<0) coordinates to avoid inextricable problems with font
// being mirrored...
g.transform(text2ModelTr); // also include rotation
textLayout.draw(g, 0.0f, 0.0f);
// [pending] ajouter un cadre si areDimensionsComputed (wysiwyg du pauvre)
// get back to previous transform
g.setTransform(oldAT);
if (DEBUG) {
g.setPaint(Color.red);
g.draw(bounds);
}
}
}
public BufferedImage createCrystalCase(Image cover) {
BufferedImage crystal =
new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_ARGB);
Graphics2D g2 = crystal.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
int width = cover.getWidth(null);
int height = cover.getHeight(null);
float scale;
if (width > height) {
scale = (float) IMAGE_WIDTH / (float) width;
} else {
scale = (float) IMAGE_HEIGHT / (float) height;
}
int scaledWidth = (int) ((float) width * scale);
int scaledHeight = (int) ((float) height * scale);
int x = (IMAGE_WIDTH - scaledWidth) / 2;
int y = (IMAGE_HEIGHT - scaledHeight) / 2;
g2.drawImage(cover, x, y, scaledWidth, scaledHeight, null);
g2.dispose();
return crystal;
}
/**
* Draw method
*
* @param g2 Graphics element
* @param select Selected node
*/
public void draw(Graphics2D g2, boolean select) {
Point pinit = new Point(centre.x - 25, centre.y - 25);
Point pfin = new Point(centre.x + 25, centre.y + 25);
figure =
new RoundRectangle2D.Float(
pinit.x, pinit.y, Math.abs(pfin.x - pinit.x), Math.abs(pfin.y - pinit.y), 20, 20);
g2.setColor(Color.black);
if (select) {
Stroke s = g2.getStroke();
g2.setStroke(
new BasicStroke(
5, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[] {1, 1}, 0));
g2.draw(figure);
g2.setStroke(s);
} else {
g2.draw(figure);
}
g2.drawImage(image, centre.x - 25, centre.y - 25, 50, 50, pd);
g2.setFont(new Font("Courier", Font.BOLD + Font.ITALIC, 12));
FontMetrics metrics = g2.getFontMetrics();
int width = metrics.stringWidth(dsc.getName());
int height = metrics.getHeight();
g2.drawString(dsc.getName(), centre.x - width / 2, centre.y + 40);
}
private BufferedImage createReflection(BufferedImage item, int itemWidth, int itemHeight) {
BufferedImage buffer =
new BufferedImage(itemWidth, itemHeight << 1, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = buffer.createGraphics();
g.drawImage(item, null, null);
g.translate(0, itemHeight << 1);
AffineTransform reflectTransform = AffineTransform.getScaleInstance(1.0, -1.0);
g.drawImage(item, reflectTransform, null);
g.translate(0, -(itemHeight << 1));
g.dispose();
return buffer;
}
////////////////////////////////////////////////////////////////////////////
// Paint
//
public synchronized void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
// Graphics2D buffGraphics2 = (Graphics2D) buffGraphics;
// g2.drawImage(bImage, 3, 3, getWidth() - 3, getHeight() - 3,
// 0, 0, iWidth, iHeight, null);
g2.drawImage(bImage, 0, 0, iWidth, iHeight, null);
g2.drawString(String.valueOf(System.currentTimeMillis()), 10, 10);
}
private void applyAlphaMask(
BufferedImage buffer, BufferedImage alphaMask, int itemWidth, int itemHeight) {
Graphics2D g2 = buffer.createGraphics();
g2.setComposite(AlphaComposite.DstOut);
g2.drawImage(alphaMask, null, 0, itemHeight);
g2.dispose();
}
public void paint(Graphics gOld) {
if (image == null || xsize != getSize().width || ysize != getSize().height) {
xsize = getSize().width;
ysize = getSize().height;
image = createImage(xsize, ysize);
g = (Graphics2D) image.getGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
// fill background
g.setColor(Color.cyan);
g.fillRect(0, 0, xsize, ysize);
int x[] = {getX(0), getX(getWidth2()), getX(getWidth2()), getX(0), getX(0)};
int y[] = {getY(0), getY(0), getY(getHeight2()), getY(getHeight2()), getY(0)};
// fill border
g.setColor(Color.black);
g.fillPolygon(x, y, 4);
// draw border
g.setColor(Color.red);
g.drawPolyline(x, y, 5);
if (animateFirstTime) {
gOld.drawImage(image, 0, 0, null);
return;
}
if (gameOver) return;
g.drawImage(outerSpaceImage, getX(0), getY(0), getWidth2(), getHeight2(), this);
for (int index = 0; index < missile.length; index++) {
if (missile[index].active) {
g.setColor(Color.red);
drawCircle(getX(missile[index].xPos), getYNormal(missile[index].yPos), 90, .3, 1.5);
}
}
if (rocketRight) {
drawRocket(rocketImage, getX(rocketXPos), getYNormal(rocketYPos), 0.0, 2.0, 2.0);
} else {
drawRocket(rocketImage, getX(rocketXPos), getYNormal(rocketYPos), 0.0, -2.0, 2.0);
}
for (int index = 0; index < numStars; index++) {
g.setColor(Color.yellow);
if (starActive[index])
drawCircle(getX(starXPos[index]), getYNormal(starYPos[index]), 0, 1.5, 1.5);
}
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("Score: " + score, 10, 45);
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("HighScore: " + highScore, 300, 45);
g.setColor(Color.magenta);
g.setFont(new Font("Impact", Font.BOLD, 15));
g.drawString("Lives: " + rocketLife, 150, 45);
if (rocketLife == 0) {
g.setColor(Color.red);
g.setFont(new Font("Impact", Font.BOLD, 60));
g.drawString("GAME OVER", getX(getWidth2() / 6), getYNormal(getHeight2() / 2));
}
gOld.drawImage(image, 0, 0, null);
}
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);
}
/**
* Method to load the buffered image with the passed image
*
* @param image the image to use
*/
public void load(Image image) {
// get a graphics context to use to draw on the buffered image
Graphics2D graphics2d = bufferedImage.createGraphics();
// draw the image on the buffered image starting at 0,0
graphics2d.drawImage(image, 0, 0, null);
// show the new image
show();
}
public void paint(Graphics g) {
synchronized (this) {
Graphics2D g2d = (Graphics2D) g;
if (img != null) {
int imgw = img.getWidth();
int imgh = img.getHeight();
g2d.setComposite(AlphaComposite.Src);
g2d.drawImage(img, null, 0, 0);
}
}
}
public static BufferedImage cropImage(BufferedImage bi, int x, int y, int w, int h) {
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w, h);
g2.drawImage(bi, -x, -y, null); // this);
g2.dispose();
return image;
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y).
*
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
offscreen.drawImage(
image, (int) Math.round(xs - ws / 2.0), (int) Math.round(ys - hs / 2.0), null);
draw();
}
private void drawAWP(Graphics g, int x, int y) {
if (System.currentTimeMillis() < shotTime + TAWP.SHOOT_TIME) {
// System.out.println(true);
double multi = 1.0 * (System.currentTimeMillis() - shotTime) / TAWP.SHOOT_TIME;
g.setColor(new Color(255, 255, 255, 255 - (int) (multi * 256)));
g.fillRect(0, 0, Wuigi.screenWidth, Wuigi.screenHeight);
}
if (numBullets <= 0) return;
BufferedImage img = TAWP.IMAGE.getBuffer();
AffineTransform xform = new AffineTransform();
// g2d.setPaint(new TexturePaint(figureOutDrawImage(),
// new Rectangle2D.Float(0, 0, 32, 32)));
// g2d.drawImage(figureOutDrawImage(),0,0,null);
xform.setToIdentity();
xform.translate(x - 5, y);
double diffY = y + height / 2 - ScreenManager.mouse.y;
double diffX = ScreenManager.mouse.x - x - width / 2;
double angle;
if (diffY > 0 && diffX > 0) {
angle = Math.PI / 2 - Math.atan(diffY / diffX);
} else if (diffY == 0 && diffX > 0) {
angle = Math.PI / 2;
} else if (diffY < 0 && diffX > 0) {
angle = Math.PI / 2 + Math.atan(-diffY / diffX);
} else if (diffY < 0 && diffX == 0) {
angle = Math.PI;
} else if (diffY < 0 && diffX < 0) {
angle = 3 * Math.PI / 2 - Math.atan(diffY / diffX);
} else if (diffY == 0 && diffX < 0) {
angle = 3 * Math.PI / 2;
} else if (diffY > 0 && diffX < 0) {
angle = 3 * Math.PI / 2 + Math.atan(-diffY / diffX);
} else {
angle = 0;
}
angle -= Math.PI / 2;
if (angle > Math.PI / 2 && angle < 3 * Math.PI / 2) {
xform.scale(1, -1);
xform.translate(0, -TAWP.IMAGE.getHeight());
angle = -angle;
}
// xform.scale(/*width/img.getWidth(),height/img.getHeight()*/);
xform.rotate(angle, 27, 13);
((Graphics2D) g).drawImage(img, xform, null);
ammo.setPos(x + 10, y - 20);
ammo.draw(g);
}
public static BufferedImage scaleImage(BufferedImage bi, double scale) {
int w1 = (int) (Math.round(scale * bi.getWidth()));
int h1 = (int) (Math.round(scale * bi.getHeight()));
BufferedImage image = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white);
g2.fillRect(0, 0, w1, h1);
g2.drawImage(bi, 0, 0, w1, h1, null); // this);
g2.dispose();
return image;
}
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
if (image != null && showimage) {
// TODO: add ability to scale maintaining aspect ratio fitting to size of parent
// TODO: Need to add not zoom all the way, but zoom to a box of aspect ratio 4/3
Graphics2D g2 = (Graphics2D) g;
AffineTransform tran = new AffineTransform(1f, 0f, 0f, 1f, 0, 0);
float widthscale = (float) c.getWidth() / image.getWidth();
float heightscale = (float) c.getHeight() / image.getHeight();
switch (drawmode) {
case DRAW_MODE_ASPECT:
float scale;
if (widthscale < heightscale) {
scale = widthscale;
} else {
scale = heightscale;
}
tran.scale(scale, scale);
g2.drawImage(
image,
new AffineTransformOp(tran, AffineTransformOp.TYPE_BILINEAR),
(int) (c.getWidth() - image.getWidth() * scale) / 2,
(int) (c.getHeight() - image.getHeight() * scale) / 2);
break;
case DRAW_MODE_WIDTH:
tran.scale(widthscale, widthscale);
g2.drawImage(image, tran, null);
break;
case DRAW_MODE_HEIGHT:
tran.scale(heightscale, heightscale);
g2.drawImage(image, tran, null);
break;
default:
tran.scale(widthscale, heightscale);
g2.drawImage(image, tran, null);
break;
}
}
}
public void drawRocket(
Image image, int xpos, int ypos, double rot, double xscale, double yscale) {
int width = rocketImage.getWidth(this);
int height = rocketImage.getHeight(this);
g.translate(xpos, ypos);
g.rotate(rot * Math.PI / 180.0);
g.scale(xscale, yscale);
g.drawImage(image, -width / 2, -height / 2, width, height, this);
g.scale(1.0 / xscale, 1.0 / yscale);
g.rotate(-rot * Math.PI / 180.0);
g.translate(-xpos, -ypos);
}
/* Draws the ball at its current position */
public void draw(Graphics2D g) {
double imageWidth = img.getWidth(parent);
double imageHeight = img.getHeight(parent);
// translate image such that its centred on its actual position
objectTransform.setToTranslation(
(double) pos_x - imageWidth / 2, (double) pos_y - imageHeight / 2);
// // this rotates the planet!
// objectTransform.rotate(Math.PI/800,50.0,51.0);
g.setTransform(new AffineTransform());
g.drawImage(img, objectTransform, parent);
}
public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
Dimension asz = this.getSize();
if (fullRefresh) {
g2.clearRect(0, 0, asz.width, asz.height);
fullRefresh = false;
}
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
big.setColor(Color.black);
offset.x = (int) (asz.width - iw) / 2;
offset.y = (int) (asz.height - ih) / 2;
big.drawImage(img, 0, 0, this);
big.setPaint(Color.red);
if ((rect.width > 0) && (rect.height > 0)) big.draw(rect);
if (selected == 1) shadeExt(big, 0, 0, 0, 64);
else if (selected == 2) {
shadeExt(big, 0, 0, 0, 255);
selected = 1;
}
g2.drawImage(bi, offset.x, offset.y, this);
}
public static BufferedImage rotateImage(BufferedImage bi) {
int w = bi.getWidth();
int h = bi.getHeight();
BufferedImage image = new BufferedImage(h, w, BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(
RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2.setPaint(Color.white); // getBackground());
g2.fillRect(0, 0, h, w);
g2.rotate(90 * Math.PI / 180);
g2.drawImage(bi, 0, -h, w, h, null); // this);
g2.dispose();
return image;
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y), rotated given number of degrees
*
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param degrees is the number of degrees to rotate counterclockwise
* @throws IllegalArgumentException if the image is corrupt
*/
public static void picture(double x, double y, String s, double degrees) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
int ws = image.getWidth(null);
int hs = image.getHeight(null);
if (ws < 0 || hs < 0) throw new IllegalArgumentException("image " + s + " is corrupt");
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
offscreen.drawImage(
image, (int) Math.round(xs - ws / 2.0), (int) Math.round(ys - hs / 2.0), null);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
draw();
}
public void moveLayerTwo(Graphics g) { // making it look fancy and shit
Graphics2D g2d = (Graphics2D) g;
for (Decorations i : decoList) {
if (i.isFlipped() == true) { // if its flipped then flip the image or don't
g2d.drawImage(
i.getImage(),
479,
i.getYTop(),
-i.getImage().getWidth(null),
i.getImage().getHeight(null),
null);
} else {
g.drawImage(i.getImage(), 0, i.getYTop(), this);
}
}
}
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
AffineTransform trans = new AffineTransform();
int width = getSize().width;
int height = getSize().height;
g2d.setColor(Color.BLACK);
g2d.fillRect(0, 0, width, height);
trans.setTransform(identity);
trans.scale(scale, scale);
g2d.drawImage(image, trans, this);
}
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D)g;
AffineTransform origXform = g2d.getTransform();
AffineTransform newXform = (AffineTransform)(origXform.clone());
//center of rotation is center of the panel
int xRot = this.getWidth()/2;
int yRot = this.getHeight()/2;
newXform.rotate(Math.toRadians(currentAngle), xRot, yRot);
g2d.setTransform(newXform);
//draw image centered in panel
int x = (getWidth() - image.getWidth(this))/2;
int y = (getHeight() - image.getHeight(this))/2;
g2d.drawImage(image, x, y, this);
g2d.setTransform(origXform);
}
public synchronized void paint(Graphics gin) {
Graphics2D g = (Graphics2D) gin;
if (im == null) return;
int height = getHeight();
int width = getWidth();
if (fit) {
t = new AffineTransform();
double scale = Math.min(((double) width) / im.getWidth(), ((double) height) / im.getHeight());
// we'll re-center the transform in a moment.
t.scale(scale, scale);
}
// if the image (in either X or Y) is smaller than the view port, then center
// the image with respect to that axis.
double mwidth = im.getWidth() * t.getScaleX();
double mheight = im.getHeight() * t.getScaleY();
if (mwidth < width)
t.preConcatenate(
AffineTransform.getTranslateInstance((width - mwidth) / 2.0 - t.getTranslateX(), 0));
if (mheight < height)
t.preConcatenate(
AffineTransform.getTranslateInstance(0, (height - mheight) / 2.0 - t.getTranslateY()));
// if we're allowing panning (because only a portion of the image is visible),
// don't allow translations that show less information that is possible.
Point2D topleft = t.transform(new Point2D.Double(0, 0), null);
Point2D bottomright = t.transform(new Point2D.Double(im.getWidth(), im.getHeight()), null);
if (mwidth > width) {
if (topleft.getX() > 0)
t.preConcatenate(AffineTransform.getTranslateInstance(-topleft.getX(), 0));
if (bottomright.getX() < width)
t.preConcatenate(AffineTransform.getTranslateInstance(width - bottomright.getX(), 0));
// t.translate(width-bottomright.getX(), 0);
}
if (mheight > height) {
if (topleft.getY() > 0)
t.preConcatenate(AffineTransform.getTranslateInstance(0, -topleft.getY()));
if (bottomright.getY() < height)
t.preConcatenate(AffineTransform.getTranslateInstance(0, height - bottomright.getY()));
}
g.drawImage(im, t, null);
}
/**
* Method to create a new picture by scaling the current picture by the given x and y factors
*
* @param xFactor the amount to scale in x
* @param yFactor the amount to scale in y
* @return the resulting picture
*/
public Picture scale(double xFactor, double yFactor) {
// set up the scale transform
AffineTransform scaleTransform = new AffineTransform();
scaleTransform.scale(xFactor, yFactor);
// create a new picture object that is the right size
Picture result = new Picture((int) (getWidth() * xFactor), (int) (getHeight() * yFactor));
// get the graphics 2d object to draw on the result
Graphics graphics = result.getGraphics();
Graphics2D g2 = (Graphics2D) graphics;
// draw the current image onto the result image scaled
g2.drawImage(this.getImage(), scaleTransform, null);
return result;
}
@Override
public void draw(Graphics2D g) {
double opacity = get(OPACITY);
opacity = Math.min(Math.max(0d, opacity), 1d);
if (opacity != 0d) {
if (opacity != 1d) {
Rectangle2D.Double drawingArea = getDrawingArea();
Rectangle2D clipBounds = g.getClipBounds();
if (clipBounds != null) {
Rectangle2D.intersect(drawingArea, clipBounds, drawingArea);
}
if (!drawingArea.isEmpty()) {
BufferedImage buf =
new BufferedImage(
(int) ((2 + drawingArea.width) * g.getTransform().getScaleX()),
(int) ((2 + drawingArea.height) * g.getTransform().getScaleY()),
BufferedImage.TYPE_INT_ARGB);
Graphics2D gr = buf.createGraphics();
gr.scale(g.getTransform().getScaleX(), g.getTransform().getScaleY());
gr.translate((int) -drawingArea.x, (int) -drawingArea.y);
gr.setRenderingHints(g.getRenderingHints());
drawFigure(gr);
gr.dispose();
Composite savedComposite = g.getComposite();
g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) opacity));
g.drawImage(
buf,
(int) drawingArea.x,
(int) drawingArea.y,
2 + (int) drawingArea.width,
2 + (int) drawingArea.height,
null);
g.setComposite(savedComposite);
}
} else {
drawFigure(g);
}
}
}
public void drawEnemy(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
for (Enemy i : enemyList) {
if (i.getFlip()) {
g2d.drawImage(
i.getPics().get(i.getCounter()),
i.getX() + i.getWidth(),
i.getY(),
-i.getWidth(),
i.getHeight(),
null); // flips the image if the flip is true
} else {
g.drawImage(
i.getPics().get(i.getCounter()), i.getX(), i.getY(), i.getWidth(), i.getHeight(), null);
}
i.count();
i.setDirection();
i.move();
}
}
/**
* Draw picture (gif, jpg, or png) centered on (x, y), rotated given number of degrees, rescaled
* to w-by-h.
*
* @param x the center x-coordinate of the image
* @param y the center y-coordinate of the image
* @param s the name of the image/picture, e.g., "ball.gif"
* @param w the width of the image
* @param h the height of the image
* @param degrees is the number of degrees to rotate counterclockwise
* @throws RuntimeException if the image is corrupt
*/
public static void picture(double x, double y, String s, double w, double h, double degrees) {
Image image = getImage(s);
double xs = scaleX(x);
double ys = scaleY(y);
double ws = factorX(w);
double hs = factorY(h);
if (ws < 0 || hs < 0) throw new RuntimeException("image " + s + " is corrupt");
if (ws <= 1 && hs <= 1) pixel(x, y);
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
offscreen.drawImage(
image,
(int) Math.round(xs - ws / 2.0),
(int) Math.round(ys - hs / 2.0),
(int) Math.round(ws),
(int) Math.round(hs),
null);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
draw();
}
