Comment ajouter une fonction de filigrane de texte et de filigrane d'image en Java

Ajouter un filigrane

L'objectif principal de l'ajout de filigranes sur les images est de protéger les droits d'auteur de l'image afin d'empêcher des personnes non autorisées d'utiliser ou de diffuser l'image. L'ajout de filigranes aux images est une technique courante de traitement d'image. Vous pouvez utiliser la classe Graphics2D fournie avec Java JDK pour dessiner des filigranes. Vous pouvez ajouter des filigranes d’image ou des filigranes de texte.

La plate-forme Java fournit une bibliothèque de classes API Java 2D pour implémenter le dessin d'images 2D. Le logiciel prend en charge plusieurs formats de gestion d'images, de polices et de couleurs et est doté de nombreuses fonctionnalités avancées telles que la fusion alpha, le tampon de profondeur, etc.

Introduction à l'API Java 2D

1. Créez un objet pour dessiner des graphiques

Utilisez la classe Graphics2D pour créer un objet pour dessiner des graphiques. Davantage de fonctions de dessin peuvent être obtenues en étendant l'objet Graphics2D, une sous-classe de la classe Graphics.

// 创建一个大小为 800x600 像素的空白图像
BufferedImage image = new BufferedImage(800, 600, BufferedImage.TYPE_INT_ARGB);
// 递给 Graphics2D 对象以进行绘制操作
Graphics2D g2d = image.createGraphics();

2. Dessiner des graphiques de base

L'API Java 2D prend en charge le dessin de divers graphiques 2D de base, tels que des segments de ligne, des rectangles, des ellipses, des arcs, etc.

// 绘制一条线段
g2d.drawLine(100, 100, 200, 200);
// 绘制一个矩形
g2d.drawRect(300, 100, 100, 50);
// 绘制一个椭圆
g2d.drawOval(500, 100, 100, 150);
// 绘制一个弧形
g2d.drawArc(100, 300, 100, 100, 0, 90);

3. Dessiner du texte

Vous pouvez utiliser le Méthode drawString() de l'objet Graphics2D pour dessiner du texte de chaîne sur l'image

// 将字符串 "Hello, Java 2D!" 绘制在坐标 (200, 400) 处
g2d.drawString("Hello, Java 2D!", 200, 400);

4. Dessiner des images

Prend en charge le chargement et le dessin d'images dans divers formats, tels que JPEG, PNG, GIF, etc. Vous pouvez également utiliser la classe ImageIO pour charger un fichier image et le dessiner sur l'image à l'aide de la méthode drawImage() de l'objet Graphics2D.

// 从指定的文件路径加载一张图片，并将其绘制在图像的左上角
BufferedImage image = ImageIO.read(new File("image.jpg"));
g2d.drawImage(image, 0, 0, null);

5. Définir les propriétés du dessin

Vous pouvez utiliser la méthode set de l'objet Graphics2D pour définir diverses propriétés de dessin, telles que la couleur, la police, la largeur des lignes, etc.

// 设置绘制颜色为红色
g2d.setColor(Color.RED);
// 设置字体为 Arial，大小为 24
g2d.setFont(new Font("Arial", Font.PLAIN, 24));
// 设置线宽为 3 像素
g2d.setStroke(new BasicStroke(3));

Dessiner un filigrane de texte

Ajouter un filigrane de texte à l'image Les étapes sont les suivantes :

• Utilisez la classe ImageIO pour charger l'image qui doit être filigranée

• Créez un objet image personnalisé de BufferedImage. et utilisez l'objet Graphics2D Dessinez l'image originale sur l'objet

• Créez un objet police et définissez la police, la couleur, la transparence et d'autres propriétés

• Utilisez la méthode drawString() de l'objet Graphics2D pour dessiner la chaîne où le filigrane doit être ajouté

• Utilisez la classe ImageIO pour enregistrer l'image modifiée dans le répertoire spécifié

    public static void addWatermark(File input, File out, String text, int fontSize) {
        // 读取原图片
        BufferedImage image = null;
        try {
            image = ImageIO.read(input);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 获取图片的宽度和高度
        int width = image.getWidth();
        int height = image.getHeight();
        // 创建一个图片缓存对象
        BufferedImage newImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        // 获取图片的画笔
        Graphics2D g = newImage.createGraphics();
        // 将原图片绘制到缓存图片上
        g.drawImage(image, 0, 0, width, height, null);
        // 创建字体对象
        Font font = new Font("微软雅黑", Font.BOLD, fontSize);
        // 创建字体渲染上下文
        FontRenderContext frc = new FontRenderContext(null, true, true);
        // 计算字符串的宽度和高度
        Rectangle2D bounds = font.getStringBounds(text, frc);
        // 字符宽度
        int strWidth = (int) bounds.getWidth();
        // 字符高度
        int strHeight = (int) bounds.getHeight();
        // 设置水印的字体样式
        g.setFont(font);
        // 设置水印的颜色
        g.setColor(Color.red);
        // 设置水印的位置 根据需要再自行调整宽度、高度
        g.drawString(text, width - strWidth - 10, height - strHeight + 15);
        // 释放图形上下文使用的系统资源
        g.dispose();
        // 保存带水印的图片
        try {
            ImageIO.write(newImage, "png", out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        File input = new File("D://test.png");
        File out = new File("D://watermark.png");
        // 水印文本内容,中文转Unicode
        String text = "\u6dfb\u52a0\u6c34\u5370";
        addWatermark(input, out, text, 20);
    }

Dessinez un filigrane d'image

Ajoutez un filigrane d'image à l'image Les étapes sont les suivantes :

• Utilisez la classe ImageIO pour charger les images qui doivent être filigranées

• Créez un objet image personnalisé de BufferedImage et utilisez l'objet Graphics2D pour dessiner l'image originale sur l'objet

• Utilisez la classe ImageIO pour charger le image de filigrane et définissez des propriétés telles que la transparence

• Dessinez l'image de filigrane et publiez les ressources associées

• Utilisez la classe ImageIO pour enregistrer l'image modifiée dans le répertoire spécifié

    public static void addWatermark(File input, File out, File watermarkImage) {
        // 读取添加水印的图片
        BufferedImage image = null;
        try {
            image = ImageIO.read(input);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 获取图片的宽度和高度
        int width = image.getWidth();
        int height = image.getHeight();
        // 创建一个图片缓存对象
        BufferedImage newImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        // 获取图片的画笔
        Graphics2D g = newImage.createGraphics();
        // 将原图片绘制到缓存图片上
        g.drawImage(image, 0, 0, width, height, null);
        // 读取水印图片
        BufferedImage watermark = null;
        try {
            watermark = ImageIO.read(watermarkImage);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 获取水印图片的宽度和高度
        int wmWidth = watermark.getWidth();
        int wmHeight = watermark.getHeight();
        // 设置水印图片的透明度
        g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, 0.5f));
        // 绘制水印图片
        g.drawImage(watermark, width - wmWidth - 10, height - wmHeight - 10, wmWidth, wmHeight, null);
        // 释放图形上下文使用的系统资源
        g.dispose();
        // 保存带水印的图片
        try {
            ImageIO.write(newImage, "png", out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        File input = new File("D://test.png");
        File out = new File("D://watermark.png");
        File watermarkImage = new File("D://watermarkImage .png");
        addWatermark(input, out, watermarkImage);
    }

Ajouter un filigrane de texte dans une boucle

rrreerrree

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!