¿Cómo puedo filtrar una imagen en Java?

Question

¿Cómo puedo crear una marca de agua sobre una imagen usando Java? Necesito que el texto ingresado por el usuario se agregue a una posición proporcionada sobre una imagen. Cualquier código de muestra/sugerencias ayudará.

Answer 1

Usted puede echar un vistazo a la sección de "Trazado de la marca de agua" de http://web.archive.org/web/20080324030029/http://blog.codebeach.com/2008/02/watermarking-images-in-java-servlet.html

O puede usar la biblioteca GIF4J http://www.gif4j.com/java-gif4j-pro-gif-image-watermark.htm#gifimagewatermarkapply

Answer 2

Yo solía para mis proyectos IM4Java library - imagemagick envoltura para java. Por ejemplo marcas de agua ver http://www.imagemagick.org/Usage/annotating/

Answer 3

En Thumbnailator, se puede añadir una leyenda de texto para una imagen existente mediante el filtro de imagen Caption:

// Image to add a text caption to. 
BufferedImage originalImage = ...; 

// Set up the caption properties 
String caption = "Hello World"; 
Font font = new Font("Monospaced", Font.PLAIN, 14); 
Color c = Color.black; 
Position position = Positions.CENTER; 
int insetPixels = 0; 

// Apply caption to the image 
Caption filter = new Caption(caption, font, c, position, insetPixels); 
BufferedImage captionedImage = filter.apply(originalImage); 

En el código anterior, el texto Hello World se dibujará o n centrada en el originalImage con una fuente Monospaced, con un color de primer plano negro, en 14 pt.

Alternativamente, si una imagen de marca de agua se ha de aplicar a una imagen existente, se puede utilizar el filtro de imagen Watermark:

BufferedImage originalImage = ...; 
BufferedImage watermarkImage = ...; 

Watermark filter = new Watermark(Positions.CENTER, watermarkImage, 0.5f); 
BufferedImage watermarkedImage = filter.apply(originalImage); 

El código anterior superponer la watermarkImage en la parte superior de la originalImage, centrado con una opacidad del 50%

Thumbnailator se ejecutará en el antiguo Java SE simple - no es necesario instalar ninguna biblioteca de terceros. (Sin embargo, se requiere el uso del tiempo de ejecución Sun Java).

Descripción completa: Soy el desarrollador de Thumbnailator.

Answer 4

utilizar este código, funciona .. aquí, se utiliza una imagen como marca de agua, es el lugar en la posición 10,10

import java.awt.Graphics; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 
import javax.imageio.ImageIO; 

public class WatermarkImage { 

    public static void addWatermark(String localImagePath) { 

    try { 
     BufferedImage image = ImageIO.read(new File(localImagePath)); 
     BufferedImage overlay = ImageIO.read(new File(".\\data\\watermark\\watermark.png")); 

     // create the new image, canvas size is the max. of both image sizes 
     int w = Math.max(image.getWidth(), overlay.getWidth()); 
     int h = Math.max(image.getHeight(), overlay.getHeight()); 
     BufferedImage combined = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); 

     // paint both images, preserving the alpha channels 
     Graphics g = combined.getGraphics(); 
     g.drawImage(image, 0, 0, null); 
     g.drawImage(overlay, 10, 0, null); 

     ImageIO.write(combined, "PNG", new File(localImagePath)); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    } 
} 

Answer 5

Primera intall Imagemagick en C: \ carpeta Imagemagick en las ventanas utilizando

http://www.imagemagick.org/download/binaries/ImageMagick-6.8.8-7-Q16-x86-dll.exe

mientras que la instalación añadir C: \ ImageMagick; en AMBIENTE variable PATH

y utilizar a continuación el código

package UploadServlet; 

    import java.io.*; 
    import java.util.*; 

    import javax.servlet.ServletConfig; 
    import javax.servlet.ServletException; 
    import javax.servlet.http.HttpServlet; 
    import javax.servlet.http.HttpServletRequest; 
    import javax.servlet.http.HttpServletResponse; 

    import org.apache.commons.fileupload.FileItem; 
    import org.apache.commons.fileupload.FileUploadException; 
    import org.apache.commons.fileupload.disk.DiskFileItemFactory;   
    import org.apache.commons.fileupload.servlet.ServletFileUpload; 
    import org.apache.commons.io.output.*; 

    /** 
    * Servlet implementation class UploadServlet 
    */ 
    public class UploadServlet extends HttpServlet { 
private static final long serialVersionUID = 1L; 

/** 
* @see HttpServlet#HttpServlet() 
*/ 
private boolean isMultipart; 
private String filePath; 
private int maxFileSize = 50 * 1024; 
private int maxMemSize = 4 * 1024; 
private File file ; 

public UploadServlet() { 
    super(); 
    // TODO Auto-generated constructor stub 
} 

public void init(){ 
    // Get the file location where it would be stored. 
    filePath = getServletContext().getInitParameter("file-upload"); 
} 
/** 
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) 
*/ 
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
    // TODO Auto-generated method stub 
    throw new ServletException("GET method used with " + 
       getClass().getName()+": POST method required."); 
} 

/** 
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) 
*/ 
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
    // TODO Auto-generated method stub 
    // Check that we have a file upload request 
     isMultipart = ServletFileUpload.isMultipartContent(request); 
     response.setContentType("text/html"); 
     java.io.PrintWriter out = response.getWriter(); 
     if(!isMultipart){ 
     out.println("<html>"); 
     out.println("<head>"); 
     out.println("<title>Servlet upload</title>"); 
     out.println("</head>"); 
     out.println("<body>"); 
     out.println("<p>No file uploaded</p>"); 
     out.println("</body>"); 
     out.println("</html>"); 
     return; 
     } 
     DiskFileItemFactory factory = new DiskFileItemFactory(); 
     // maximum size that will be stored in memory 
     factory.setSizeThreshold(maxMemSize); 
     // Location to save data that is larger than maxMemSize. 
     factory.setRepository(new File("c:\\temp")); 

     // Create a new file upload handler 
     ServletFileUpload upload = new ServletFileUpload(factory); 
     // maximum file size to be uploaded. 
     upload.setSizeMax(maxFileSize); 

     try{ 
     // Parse the request to get file items. 
     List fileItems = upload.parseRequest(request); 

     // Process the uploaded file items 
     Iterator i = fileItems.iterator(); 

     out.println("<html>"); 
     out.println("<head>"); 
     out.println("<title>Servlet upload</title>"); 
     out.println("</head>"); 
     out.println("<body>"); 
     out.println("<h3>Watermark :</h3>"); 
     out.println("Select a file to upload: <br />"); 
     out.println("<form action=\"UploadServlet\" method=\"post\" enctype=\"multipart/form-data\">"); 
     out.println("<input type=\"file\" name=\"file\" size=\"50\" /><br/>"); 
     out.println("<input type=\"submit\" value=\"Upload File\" />"); 
     out.println("</form><br/>"); 
     while (i.hasNext()) 
     { 
     FileItem fi = (FileItem)i.next(); 
     if (!fi.isFormField()) 
     { 
      // Get the uploaded file parameters 
      String fieldName = fi.getFieldName(); 
      String fileName = fi.getName(); 
      //System.out.println("Filename:" + fileName); 
      String contentType = fi.getContentType(); 
      boolean isInMemory = fi.isInMemory(); 
      long sizeInBytes = fi.getSize(); 
      // get application path 
      String webAppPath = getServletContext().getRealPath("/"); 
      //System.out.println("Web Application Path :" + webAppPath); 

      // Write the file 

      file = new File(webAppPath + "ImageTest.jpeg") ; 

      fi.write(file) ; 


      out.println("<br/><h3>Uploaded File :</h3><img src=\"ImageTest.jpeg\" height='300px' width='300px' />"); 

      String command = ""; 
      command = "convert.exe -draw \"gravity south fill black text 0,0 'Watermark' \" \"" + webAppPath + "ImageTest.jpeg \" \""+ webAppPath +"imageTest_result.jpg \""; 
      ProcessBuilder pb = new ProcessBuilder("cmd.exe", "/c", command); 
      Process p = pb.start(); 
      try { 
       Thread.sleep(1000); 
      } catch(InterruptedException ex) { 
       Thread.currentThread().interrupt(); 
      } 
      out.println("<br/><h3>Watermarked File :</h3><img src=\"imageTest_result.jpg\" height='300px' width='300px' />"); 

     } 

     } 
     out.println("</body>"); 
     out.println("</html>"); 
    }catch(Exception ex) { 
     System.out.println(ex); 
     out.println("<br/><font color='red'><b>"+ex.getMessage()+"</b></font><br/>"); 
    } 
} 

}

Answer 6

que tenía una necesidad similar recientemente y encontré este post bastante útil: http://www.codeyouneed.com/java-watermark-image/

El método de marca de agua no utiliza ImgScalr de cambiar el tamaño de la marca de agua cuando sea necesario y permite colocar texto en la parte inferior/superior de la imagen + la imagen de la marca de agua.

Para elegir la correcta colocación se utiliza un ENUM sencilla

public enum PlacementPosition { 
    TOPLEFT, TOPCENTER, TOPRIGHT, MIDDLELEFT, MIDDLECENTER, MIDDLERIGHT, BOTTOMLEFT, BOTTOMCENTER, BOTTOMRIGHT 
} 

Y toda la lógica de este sistema es en este método:

/** 
* Generate a watermarked image. 
* 
* @param originalImage 
* @param watermarkImage 
* @param position 
* @param watermarkSizeMaxPercentage 
* @return image with watermark 
* @throws IOException 
*/ 
public static BufferedImage watermark(BufferedImage originalImage, 
     BufferedImage watermarkImage, PlacementPosition position, 
     double watermarkSizeMaxPercentage) throws IOException { 

    int imageWidth = originalImage.getWidth(); 
    int imageHeight = originalImage.getHeight(); 

    int watermarkWidth = getWatermarkWidth(originalImage, watermarkImage, 
      watermarkSizeMaxPercentage); 
    int watermarkHeight = getWatermarkHeight(originalImage, watermarkImage, 
      watermarkSizeMaxPercentage); 

    // We create a new image because we want to keep the originalImage 
    // object intact and not modify it. 
    BufferedImage bufferedImage = new BufferedImage(imageWidth, 
      imageHeight, BufferedImage.TYPE_INT_RGB); 
    Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics(); 
    g2d.drawImage(originalImage, 0, 0, null); 
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
      RenderingHints.VALUE_ANTIALIAS_ON); 

    int x = 0; 
    int y = 0; 
    if (position != null) { 
     switch (position) { 
     case TOPLEFT: 
      x = 0; 
      y = 0; 
      break; 
     case TOPCENTER: 
      x = (imageWidth/2) - (watermarkWidth/2); 
      y = 0; 
      break; 
     case TOPRIGHT: 
      x = imageWidth - watermarkWidth; 
      y = 0; 
      break; 

     case MIDDLELEFT: 
      x = 0; 
      y = (imageHeight/2) - (watermarkHeight/2); 
      break; 
     case MIDDLECENTER: 
      x = (imageWidth/2) - (watermarkWidth/2); 
      y = (imageHeight/2) - (watermarkHeight/2); 
      break; 
     case MIDDLERIGHT: 
      x = imageWidth - watermarkWidth; 
      y = (imageHeight/2) - (watermarkHeight/2); 
      break; 

     case BOTTOMLEFT: 
      x = 0; 
      y = imageHeight - watermarkHeight; 
      break; 
     case BOTTOMCENTER: 
      x = (imageWidth/2) - (watermarkWidth/2); 
      y = imageHeight - watermarkHeight; 
      break; 
     case BOTTOMRIGHT: 
      x = imageWidth - watermarkWidth; 
      y = imageHeight - watermarkHeight; 
      break; 

     default: 
      break; 
     } 
    } 

    g2d.drawImage(Scalr.resize(watermarkImage, Method.ULTRA_QUALITY, 
      watermarkWidth, watermarkHeight), x, y, null); 

    return bufferedImage; 

} 

y los métodos correspondientes para calcular el tamaño de la marca de agua es:

/** 
* 
* @param originalImage 
* @param watermarkImage 
* @param maxPercentage 
* @return 
*/ 
private static Pair<Double, Double> calculateWatermarkDimensions(
     BufferedImage originalImage, BufferedImage watermarkImage, 
     double maxPercentage) { 

    double imageWidth = originalImage.getWidth(); 
    double imageHeight = originalImage.getHeight(); 

    double maxWatermarkWidth = imageWidth/100.0 * maxPercentage; 
    double maxWatermarkHeight = imageHeight/100.0 * maxPercentage; 

    double watermarkWidth = watermarkImage.getWidth(); 
    double watermarkHeight = watermarkImage.getHeight(); 

    if (watermarkWidth > maxWatermarkWidth) { 
     double aspectRatio = watermarkWidth/watermarkHeight; 
     watermarkWidth = maxWatermarkWidth; 
     watermarkHeight = watermarkWidth/aspectRatio; 
    } 

    if (watermarkHeight > maxWatermarkHeight) { 
     double aspectRatio = watermarkWidth/watermarkHeight; 
     watermarkHeight = maxWatermarkHeight; 
     watermarkWidth = watermarkHeight/aspectRatio; 
    } 

    return Pair.of(watermarkWidth, watermarkHeight); 
} 

/** 
* 
* @param originalImage 
* @param watermarkImage 
* @param maxPercentage 
* @return 
*/ 
public static int getWatermarkWidth(BufferedImage originalImage, 
     BufferedImage watermarkImage, double maxPercentage) { 

    return calculateWatermarkDimensions(originalImage, watermarkImage, 
      maxPercentage).getLeft().intValue(); 

} 

/** 
* 
* @param originalImage 
* @param watermarkImage 
* @param maxPercentage 
* @return 
*/ 
public static int getWatermarkHeight(BufferedImage originalImage, 
     BufferedImage watermarkImage, double maxPercentage) { 

    return calculateWatermarkDimensions(originalImage, watermarkImage, 
      maxPercentage).getRight().intValue(); 

} 

De nuevo, todos los créditos a http://www.codeyouneed.com/java-watermark-image/ para una buena muestra.

Answer 7

A continuación se muestra el código para añadir marcas de agua en cualquier imagen

import java.awt.Font; 
import java.awt.Graphics; 
import java.awt.image.BufferedImage; 
import java.io.File; 
import java.io.IOException; 

import javax.imageio.ImageIO; 
import javax.swing.ImageIcon; 

public class WatermarkImage { 

    public static void main(String[] args) { 

     File origFile = new File("C:/OrignalImage.jpg"); 
     ImageIcon icon = new ImageIcon(origFile.getPath()); 

     // create BufferedImage object of same width and height as of original image 
     BufferedImage bufferedImage = new BufferedImage(icon.getIconWidth(), 
        icon.getIconHeight(), BufferedImage.TYPE_INT_RGB); 

     // create graphics object and add original image to it 
     Graphics graphics = bufferedImage.getGraphics(); 
     graphics.drawImage(icon.getImage(), 0, 0, null); 

     // set font for the watermark text 
     graphics.setFont(new Font("Arial", Font.BOLD, 30)); 

     //unicode characters for (c) is \u00a9 
     String watermark = "\u00a9 JavaXp.com"; 

     // add the watermark text 
     graphics.drawString(watermark, 0, icon.getIconHeight()/2); 
     graphics.dispose(); 

     File newFile = new File("C:/WatermarkedImage.jpg"); 
     try { 
       ImageIO.write(bufferedImage, "jpg", newFile); 
     } catch (IOException e) { 
       e.printStackTrace(); 
     } 

     System.out.println(newFile.getPath() + " created successfully!"); 

    } 

}