content: package collegeapplication.common;
  
  import java.awt.image.*;
  import java.awt.geom.RoundRectangle2D;
  import javax.swing.*;
  import java.awt.*;
  
  /*
   * Title : ImageUtil.java
   * Created by : Ajaysinh Rathod
   * Purpose  : All the functions related to image like..
   * 			->Image to bufferedimage
   * 			->Resizing Bufferdimage
   * 			->Converting square shape image to round shape
   * Mail : ajaysinhrathod1290@gmail.com
   * Reference : https://stackoverflow.com/
   */
  public class ImageUtil {
  
      public static BufferedImage toBufferedImage(Image image)
      {
          if (image instanceof BufferedImage)
          return (BufferedImage)image;
  
          // This code ensures that all the pixels in the image are loaded
          image = new ImageIcon(image).getImage();
  
          // Determine if the image has transparent pixels
          boolean hasAlpha = hasAlpha(image);
  
          // Create a buffered image with a format that's compatible with the screen
          BufferedImage bimage = null;
  
          GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
  
          try {
              // Determine the type of transparency of the new buffered image
              int transparency = Transparency.OPAQUE;
  
              if (hasAlpha == true)
                  transparency = Transparency.BITMASK;
  
              // Create the buffered image
              GraphicsDevice gs = ge.getDefaultScreenDevice();
              GraphicsConfiguration gc = gs.getDefaultConfiguration();
  
              bimage = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null), transparency);
          } catch (HeadlessException e) { } //No screen
  
          if (bimage == null) {
              // Create a buffered image using the default color model
              int type = BufferedImage.TYPE_INT_RGB;
  
              if (hasAlpha == true) {type = BufferedImage.TYPE_INT_ARGB;}
                  bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
          }
  
          // Copy image to buffered image
          Graphics g = bimage.createGraphics();
  
          // Paint the image onto the buffered image
          g.drawImage(image, 0, 0, null);
          g.dispose();
  
          return bimage;
      }
  
  
      public static boolean hasAlpha(Image image) 
      {
          // If buffered image, the color model is readily available
          if (image instanceof BufferedImage)
              return ((BufferedImage)image).getColorModel().hasAlpha();
  
          // Use a pixel grabber to retrieve the image's color model;
          // grabbing a single pixel is usually sufficient
          PixelGrabber pg = new PixelGrabber(image, 0, 0, 1, 1, false);
          try {
              pg.grabPixels();
          } catch (InterruptedException e) { }
  
          // Get the image's color model
          return pg.getColorModel().hasAlpha();
      }
      public static BufferedImage resizeImage(final Image image, int width, int height) {
  		
  	       final BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
  	       final Graphics2D graphics2D = bufferedImage.createGraphics();
  	       graphics2D.setComposite(AlphaComposite.Src);
  	       //below three lines are for RenderingHints for better image quality at cost of higher processing time
  	       graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR);
  	       graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING,RenderingHints.VALUE_RENDER_QUALITY);
  	       graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
  	       graphics2D.drawImage(image, 0, 0, width, height, null);
  	       graphics2D.dispose();
  	       return bufferedImage;
  	   }
  
  	public static BufferedImage makeRoundedCorner(BufferedImage image, int cornerRadius) {
  	    int w = image.getWidth();
  	    int h = image.getHeight();
  	    BufferedImage output = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
  
  	    Graphics2D g2 = output.createGraphics();
  	    // This is what we want, but it only does hard-clipping, i.e. aliasing
  	    // g2.setClip(new RoundRectangle2D ...)
  
  	    // so instead fake soft-clipping by first drawing the desired clip shape
  	    // in fully opaque white with antialiasing enabled...
  	    g2.setComposite(AlphaComposite.Src);
  	    g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  	    g2.setColor(Color.WHITE);
  	    g2.fill(new RoundRectangle2D.Float(0, 0, w, h, cornerRadius, cornerRadius));
  
  	    // ... then compositing the image on top,
  	    // using the white shape from above as alpha source
  	    g2.setComposite(AlphaComposite.SrcAtop);
  	    g2.drawImage(image, 0, 0, null);
  
  	    g2.dispose();
  
  	    return output;
  	}
  	 
  }
  
     
      
    