// EditImages.java
// To run this, first save the image sampleImage.jpg to the current directory

import java.awt.*;
import java.awt.image.*; 
import javax.imageio.*;
import java.io.*;
import javax.swing.*;

class MyGraphics {
  
  public static void main(String[] args) {
    // To run this, first save the image sampleImage.jpg to the current directory
    BufferedImage image = loadBufferedImage("sampleImage.jpg");
    Dimension dim = getImageSize(image, 1, 0);
    int imageWidth = dim.width;
    int imageHeight = dim.height;
    
    // Change all "nearly-black" pixels to blue!
    for (int x=0; x<imageWidth; x++)
      for (int y=0; y<imageHeight; y++) {
        int rgba  = image.getRGB(x,y);
        int alpha = (rgba >> 24) & 0xff;
        int red   = (rgba >> 16) & 0xff;
        int green = (rgba >>  8) & 0xff;
        int blue  = (rgba      ) & 0xff;
        if ((red < 30) && (green < 30) && (blue < 30)) {
          // we have a black pixel, switch to blue
          red = 0;
          green = 0;
          blue = 255;
          rgba = (alpha << 24) | (red << 16) | (green << 8) | (blue);
          image.setRGB(x,y,rgba);
        }
      }
    saveBufferedImage(image, "editedImage1.jpg");
    
    // Get the graphics and paint a semi-transparent oval in the middle
    Graphics g = image.getGraphics();
    g.setColor(new Color(255, 0, 0, 128)); // semi-transparent red
    g.fillOval(0, imageHeight/2-20, imageWidth, 40);
    saveBufferedImage(image, "editedImage2.jpg");
    
    // Make a new image from scratch
    int width = 400, height = 200;
    image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    g = image.getGraphics();
    g.setColor(Color.yellow);
    g.fillRect(0,0,width,height);
    // add some vertical bars
    g.setColor(Color.blue);
    for (int x=20; x<width; x+=50)
      g.fillRect(x,0,10,height);
    // and a semi-transparent message
    g.setColor(new Color(255, 0, 0, 128)); // semi-transparent red again
    g.setFont(new Font("Arial",Font.BOLD,64));
    drawCenteredString(g,"Carpe Diem",0,0,width,height);
    saveBufferedImage(image, "editedImage3.jpg");    
  }

  //////////////////////////////////////
  /// drawCenteredString Helper methods
  //////////////////////////////////////

  public static int getStringWidth(Graphics page, Font f, String s) {
    // Find the size of string s in the font of the Graphics context "page"
    FontMetrics fm   = page.getFontMetrics(f);
    java.awt.geom.Rectangle2D rect = fm.getStringBounds(s, page);
    return (int)Math.round(rect.getWidth());
  }

  public static int getStringHeight(Graphics page, Font f, String s) {
    // Find the size of string s in the font of the Graphics context "page"
    FontMetrics fm   = page.getFontMetrics(f);
    java.awt.geom.Rectangle2D rect = fm.getStringBounds(s, page);
    return (int)Math.round(rect.getHeight());
  }

  public static int getStringAscent(Graphics page, Font f, String s) {
    // Find the size of string s in the font of the Graphics context "page"
    FontMetrics fm   = page.getFontMetrics(f);
    return fm.getAscent();
  }

  public static void drawCenteredString(Graphics page, String s, int left, int top, int width, int height) {
    Font font = page.getFont();
    int textWidth  = getStringWidth(page,font,s);
    int textHeight = getStringHeight(page,font,s);
    int textAscent = getStringAscent(page,font,s);

    // Center text horizontally and vertically within provided rectangular bounds
    int textX = left + (width - textWidth)/2;
    int textY = top + (height - textHeight)/2 + textAscent;
    page.drawString(s, textX, textY);
  }
  
  //////////////////////////////////////
  /// Image Helper methods
  /////////////////////////////////////

  // Paint the given image rotated and scaled with a top-left at x,y
  public static void drawImage(Graphics page, Image image, int x, int y, double scale, double radians) {
    double imageWidth  = image.getWidth(null);
    double imageHeight = image.getHeight(null);
    Dimension newSize = getImageSize(image, scale, radians);
    java.awt.geom.AffineTransform transform = new java.awt.geom.AffineTransform();
    transform.translate(x+newSize.getWidth()/2,y+newSize.getHeight()/2); // last (not first!)
    transform.rotate(radians);
    transform.scale(scale,scale);
    transform.translate(-imageWidth/2, -imageHeight/2);  // first
    ((Graphics2D)page).drawImage(image,transform,null);
  }

  // Same as drawImage, only here we position the image by its center
  public static void drawCenteredImage(Graphics page, Image image, int cx, int cy, double scale, double radians) {
    Dimension newSize = getImageSize(image, scale, radians);
    drawImage(page, image, cx - newSize.width/2, cy - newSize.height/2, scale, radians);
  }

  // get the size of this image after it has been scaled and rotated
  public static Dimension getImageSize(Image image, double scale, double radians) {
    double imageWidth  = image.getWidth(null);
    double imageHeight = image.getHeight(null);
    java.awt.geom.AffineTransform transform = new java.awt.geom.AffineTransform();
    transform.rotate(radians);
    transform.scale(scale,scale);
    transform.translate(-imageWidth/2, -imageHeight/2);  // first
    double[] x = { 0, imageWidth, imageWidth ,     0       };
    double[] y = { 0,     0     , imageHeight, imageHeight };
    double minx=0, maxx=0, miny=0, maxy=0;
    java.awt.geom.Point2D.Double src = new java.awt.geom.Point2D.Double();
    java.awt.geom.Point2D.Double dst = new java.awt.geom.Point2D.Double();
    for (int i=0; i<4; i++) {
      src.setLocation(x[i],y[i]);
      transform.transform(src,dst);
      if (i == 0) {
        minx = maxx = dst.getX();
        miny = maxy = dst.getY();
      }
      else {
        minx = Math.min(dst.getX(),minx);
        miny = Math.min(dst.getY(),miny);
        maxx = Math.max(dst.getX(),maxx);
        maxy = Math.max(dst.getY(),maxy);
      }
    }
    return new Dimension((int)(maxx-minx), (int)(maxy-miny));
  }


  // Convert a jpg/png/etc file into an awt BufferedImage
  public static BufferedImage loadBufferedImage(String filename) {
    File file = new File(filename);
    if (!file.exists())
      throw new RuntimeException("File " + filename + " does not exist");
    try { return ImageIO.read(file); }
    catch (Exception e) { throw new RuntimeException(e); }
  }  
  
  // Verify the given the file format is one that is supported.
  public static void verifyFileFormatIsSupported(String format) {
    String[] legalFormats = ImageIO.getReaderFormatNames();
    for (String legalFormat : legalFormats)
      if (legalFormat.equals(format))
        return;
    throw new RuntimeException("Illegal format " + format + " not in " +
                               java.util.Arrays.toString(legalFormats));
  }

  // Save the BufferedImage into the given file -- the image type is determined
  // by the extension of the file (.jpg, .png, etc)
  public static void saveBufferedImage(BufferedImage image, String filename) {
    int dotIndex = filename.lastIndexOf('.');
    if (dotIndex < 0) throw new RuntimeException("file must end in .jpg, .png, etc");
    String format = filename.substring(dotIndex+1);
    verifyFileFormatIsSupported(format);
    try { ImageIO.write(image, format, new File(filename)); }
    catch (Exception e) { throw new RuntimeException(e); }
  }
}