package aaa;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.imageio.ImageIO;

import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;


public class img2 {
	public static void main(String[] args) {
		
		try {
			//获取图片
			File raw = new File("d:/img/1.jpg");
			
			
			BufferedImage bufferedImage = ImageIO.read(raw); 
			
			//旋转图片为指定角度  图片宽高不变
			BufferedImage bufferedImage2 = rotateImage(bufferedImage, 270);
			File outputfile2  = new File("d:/img/12.jpg");
			//生成旋转后的图片
			ImageIO.write(bufferedImage2,"jpg",outputfile2);
			
			
			//旋转图片为指定角度 同时旋转宽高
			BufferedImage bufferedImage3 = rotateImage2(bufferedImage, 270);
			File outputfile3  = new File("d:/img/13.jpg");
			//生成旋转后的图片
			ImageIO.write(bufferedImage3,"jpg",outputfile3);
			
			
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	
	
	/** * 旋转图片为指定角度  图片宽高不变*  
	 * @param bufferedimage * 目标图像 * 
	 * @param degree * 旋转角度 * 
	 * @return */ 
	public static BufferedImage rotateImage(final BufferedImage bufferedimage, final int degree)
	{ 
		int w= bufferedimage.getWidth(); // 得到图片宽度。 
		int h= bufferedimage.getHeight();// 得到图片高度。 
		int type= bufferedimage.getColorModel().getTransparency();// 得到图片透明度。
		BufferedImage img;// 空的图片。 
		Graphics2D graphics2d;// 空的画笔。 
		(graphics2d= (img= new BufferedImage(w, h, type)).createGraphics()).setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); 
		graphics2d.rotate(Math.toRadians(degree), w/2, h/2);// 旋转，degree是整型，度数，比如垂直90度。   •rotate(double arc,double x, double y)：图形以点(x,y)为轴点，旋转arc弧度。
		graphics2d.drawImage(bufferedimage, 0, 0, null);// 从bufferedimagecopy图片至img，0,0是img的坐标。 
		graphics2d.dispose(); 
		
		return img;// 返回复制好的图片，原图片依然没有变，没有旋转，下次还可以使用。 
	}
	
	
	/** * 旋转图片为指定角度    同时旋转宽高 *  
	 * @param bufferedimage * 目标图像 * 
	 * @param degree * 旋转角度 * 
	 * @return 
	 * */ 
	public static BufferedImage rotateImage2(final BufferedImage bufferedimage, final int degree)
	{ 
		int w= bufferedimage.getWidth(); // 得到图片宽度。 
		int h= bufferedimage.getHeight();// 得到图片高度。 
		BufferedImage img;// 空的图片。 
		
		int x = (h / 2) - (bufferedimage.getWidth() / 2);// 确定原点坐标
        int y = (w / 2) - (bufferedimage.getHeight() / 2);
		AffineTransform at = new AffineTransform();
        at.rotate(Math.toRadians(degree), h / 2, w / 2);// 旋转图象
        at.translate(x, y);
        AffineTransformOp op = new AffineTransformOp(at,
                AffineTransformOp.TYPE_BICUBIC);
        img = new BufferedImage(h, w,bufferedimage.getType());
        img = op.filter(bufferedimage, img);
		
		return img;// 返回复制好的图片，原图片依然没有变，没有旋转，下次还可以使用。 
	}
	
}
 
 

强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan
 
【前言】
 
       在做项目的时候遇到一个业务需要对图片进行旋转，于是找到一个工具类，亲测有效；在此与大家共享，需要用时可以直接用哈！
 
【实战】
 
        一、旋转工具类代码：
 
 
 
package zh.test.utils;

import java.awt.*;
import java.awt.image.BufferedImage;

/**
 * 图片旋转工具类
 */
public class RotateImage {

    /**
     * 对图片进行旋转
     *
     * @param src   被旋转图片
     * @param angel 旋转角度
     * @return 旋转后的图片
     */
    public static BufferedImage Rotate(Image src, int angel) {
        int src_width = src.getWidth(null);
        int src_height = src.getHeight(null);
        // 计算旋转后图片的尺寸
        Rectangle rect_des = CalcRotatedSize(new Rectangle(new Dimension(
                src_width, src_height)), angel);
        BufferedImage res = null;
        res = new BufferedImage(rect_des.width, rect_des.height,
                BufferedImage.TYPE_INT_RGB);
        Graphics2D g2 = res.createGraphics();
        // 进行转换
        g2.translate((rect_des.width - src_width) / 2,
                (rect_des.height - src_height) / 2);
        g2.rotate(Math.toRadians(angel), src_width / 2, src_height / 2);

        g2.drawImage(src, null, null);
        return res;
    }

    /**
     * 计算旋转后的图片
     *
     * @param src   被旋转的图片
     * @param angel 旋转角度
     * @return 旋转后的图片
     */
    public static Rectangle CalcRotatedSize(Rectangle src, int angel) {
        // 如果旋转的角度大于90度做相应的转换
        if (angel >= 90) {
            if (angel / 90 % 2 == 1) {
                int temp = src.height;
                src.height = src.width;
                src.width = temp;
            }
            angel = angel % 90;
        }

        double r = Math.sqrt(src.height * src.height + src.width * src.width) / 2;
        double len = 2 * Math.sin(Math.toRadians(angel) / 2) * r;
        double angel_alpha = (Math.PI - Math.toRadians(angel)) / 2;
        double angel_dalta_width = Math.atan((double) src.height / src.width);
        double angel_dalta_height = Math.atan((double) src.width / src.height);

        int len_dalta_width = (int) (len * Math.cos(Math.PI - angel_alpha
                - angel_dalta_width));
        int len_dalta_height = (int) (len * Math.cos(Math.PI - angel_alpha
                - angel_dalta_height));
        int des_width = src.width + len_dalta_width * 2;
        int des_height = src.height + len_dalta_height * 2;
        return new Rectangle(new Dimension(des_width, des_height));
    }
}
 
 
 
        二、调用工具类的代码：
 
 
 
package zh.test.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import zh.test.utils.RotateImage;

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

/**
 * 测试图片旋转
 */
@RestController
@RequestMapping(value = "/test")
public class TestController {

    @RequestMapping(method = RequestMethod.POST)
    public void testImgRotate(MultipartFile multipartFile) throws Exception {
        BufferedImage src = ImageIO.read(multipartFile.getInputStream());
        //顺时针旋转90度
        BufferedImage des1 = RotateImage.Rotate(src, 90);
        ImageIO.write(des1, "jpg", new File("e:/90.jpg"));
        //顺时针旋转180度
        BufferedImage des2 = RotateImage.Rotate(src, 180);
        ImageIO.write(des2, "jpg", new File("c:/180.jpg"));
        //顺时针旋转270度
        BufferedImage des3 = RotateImage.Rotate(src, 270);
        ImageIO.write(des3, "jpg", new File("c:/270.jpg"));

    }

}
 
 
 
        三、效果：
 
             1、被旋转的图片：
 
 
             2、顺时针旋转90度图片：
 
                   
 
             3、顺时针旋转180度图片：
 
  
 
             4、顺时针旋转270度图片：
 
                               
 
【总结】
 
      1、写代码要尽可能的考虑周全，对于自己怀疑可能会出错的事情千万不要抱着侥幸心理庆幸可以逃过去；60年前墨菲就为我们总结好了---墨菲定律！
 
      2、遇到问题后要学会跳出来想，不要轻易先下结论，不然很容易钻进去；要有一定思路去排查，即便你十分肯定没问题的地方也要认真去检查，有时候问题往往出在这些被我们忽略的地方。

JAVA算法：矩阵旋转（JAVA代码）
 
给定一个N*N的二维矩阵，顺时针旋转90度后，输出该矩阵。
 
例如：
 
给定矩阵：
 
1    2    3    4    
 5    6    7    8    
 9    10    11    12    
 13    14    15    16
 
顺时针旋转90度后，输出结果：
 
13    9    5    1    
 14    10    6    2    
 15    11    7    3    
 16    12    8    4
 

算法设计
 
package com.bean.algorithmexec;

public class RotateMatrix {
	
	/*
	 * 给定一个N*N的整形矩阵Matrix，把这个矩阵顺时针旋转90度，输入（打印）元素值。
	 * 例如：
	 *  1  2  3  4
	 *  5  6  7  8
	 *  9 10 11 12
	 * 13 14 15 16
	 * 输出结果为：
	 * 	13 9  5 1
	 *  14 10 6 2
	 *  15 11 7 3
	 *  16 12 8 4
	 * 
	 * 要求：额外空间复杂度为O（1）
	 * */

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//初始化一个 4*4的整形矩阵，从第一行第一列从左向右，第二行，第三行，直到第四行依次赋值 1,2,...16.
				int[][] matrixDemo=new int[4][4];
				matrixDemo=createMatrix();
				printMatrix(matrixDemo);
				
				System.out.println();
				//顺时针旋转90度打印
				rotate(matrixDemo);
				printMatrix(matrixDemo);
	}

	//顺时针旋转90度打印
	private static void rotate(int[][] matrix) {
		// TODO Auto-generated method stub
		int tR=0;
		int tC=0;
		int dR=matrix.length-1;
		int dC=matrix[0].length-1;
		while(tR<=dR) {
			rotateEdge(matrix, tR++, tC++, dR--,dC--);
		}
	}
	
	//顺时针旋转90度打印
	private static void rotateEdge(int[][] matrix, int tR, int tC, int dR, int dC) {
		// TODO Auto-generated method stub
		int times=dC-tC;  // timies就是总的组数
		int temp=0;
		for(int i=0; i!=times;i++) {
			//一次循环就是一组调整
			temp=matrix[tR][tC+i];
			matrix[tR][tC+i]=matrix[dR-i][tC];
			matrix[dR-i][tC]=matrix[dR][dC-i];
			matrix[dR][dC-i]=matrix[tR+i][dC];
			matrix[tR+i][dC]=temp;
			
		}
		
		
	}

	//生成矩阵
	private static int[][] createMatrix() {
		// TODO Auto-generated method stub
		int matrix[][]=new int[4][4];
		int k=1;
		for(int i=0;i<4;i++) {
			for(int j=0;j<4;j++) {
				matrix[i][j]=k;
				k++;
			}
		}
		
		return matrix;
	}
	
	//顺序打印矩阵元素
	private static void printMatrix(int[][] matrix) {
		for(int i=0;i<4;i++) {
			for(int j=0;j<4;j++) {
				System.out.print(matrix[i][j]+"\t");
			}
			System.out.println();
		}
		
	}
	
}
 
 

目录
 
 
前言
 
Maven依赖
 
代码
 
总结
 

前言
 
本文提供java操作图片生成旋转、翻转后的图片工具类，拿来即用。
 
 
Maven依赖
 
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1.1-jre</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>javacv-platform</artifactId>
            <version>1.5.5</version>
        </dependency>
 
 
代码
 
不废话上代码。
 
 
package ai.hy.csdn.tools;

import cn.hutool.core.util.IdUtil;
import com.google.common.base.Joiner;
import com.google.common.base.Splitter;
import org.bytedeco.javacpp.Loader;

import java.io.File;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.List;

/** @Author 剑客阿良_ALiang @Date 2021/11/18 17:40 @Description: 图片移动处理工具 */
public class ImageMoveTool {
  /**
   * 垂直翻转
   *
   * @param imagePath 图片地址
   * @param outputDir 输出目录
   * @return 图片地址
   * @throws Exception 异常
   */
  public static String vflip(String imagePath, String outputDir) throws Exception {
    List<String> paths = Splitter.on(".").splitToList(imagePath);
    String ext = paths.get(paths.size() - 1);
    if (!Arrays.asList("png", "jpg").contains(ext)) {
      throw new Exception("format error");
    }
    String resultPath =
        Joiner.on(File.separator).join(Arrays.asList(outputDir, IdUtil.simpleUUID() + "." + ext));
    String ffmpeg = Loader.load(org.bytedeco.ffmpeg.ffmpeg.class);
    ProcessBuilder builder =
        new ProcessBuilder(ffmpeg, "-i", imagePath, "-vf", "vflip", "-y", resultPath);
    builder.inheritIO().start().waitFor();
    return resultPath;
  }

  /**
   * 水平翻转
   *
   * @param imagePath 图片地址
   * @param outputDir 输出目录
   * @return 图片地址
   * @throws Exception 异常
   */
  public static String hflip(String imagePath, String outputDir) throws Exception {
    List<String> paths = Splitter.on(".").splitToList(imagePath);
    String ext = paths.get(paths.size() - 1);
    if (!Arrays.asList("png", "jpg").contains(ext)) {
      throw new Exception("format error");
    }
    String resultPath =
        Joiner.on(File.separator).join(Arrays.asList(outputDir, IdUtil.simpleUUID() + "." + ext));
    String ffmpeg = Loader.load(org.bytedeco.ffmpeg.ffmpeg.class);
    ProcessBuilder builder =
        new ProcessBuilder(ffmpeg, "-i", imagePath, "-vf", "hflip", "-y", resultPath);
    builder.inheritIO().start().waitFor();
    return resultPath;
  }

  /**
   * 旋转
   *
   * @param imagePath 图片地址
   * @param outputDir 输出目录
   * @param angle 角度
   * @return 图片地址
   * @throws Exception 异常
   */
  public static String rotate(String imagePath, String outputDir, Integer angle) throws Exception {
    List<String> paths = Splitter.on(".").splitToList(imagePath);
    String ext = paths.get(paths.size() - 1);
    if (!Arrays.asList("png", "jpg").contains(ext)) {
      throw new Exception("format error");
    }
    String resultPath =
        Joiner.on(File.separator).join(Arrays.asList(outputDir, IdUtil.simpleUUID() + "." + ext));
    String ffmpeg = Loader.load(org.bytedeco.ffmpeg.ffmpeg.class);
    ProcessBuilder builder =
        new ProcessBuilder(
            ffmpeg,
            "-i",
            imagePath,
            "-vf",
            MessageFormat.format("rotate=PI*{0}/180", String.valueOf(angle)),
            "-y",
            resultPath);
    builder.inheritIO().start().waitFor();
    return resultPath;
  }

  /**
   * 转置 type:0 逆时针旋转90度，对称翻转 type:1 顺时针旋转90度 type:2 逆时针旋转90度 type:3 顺时针旋转90度，对称翻转
   *
   * @param imagePath 图片地址
   * @param outputDir 输出目录
   * @param type 转置类型
   * @return 图片地址
   * @throws Exception 异常
   */
  public static String transpose(String imagePath, String outputDir, Integer type)
      throws Exception {
    List<String> paths = Splitter.on(".").splitToList(imagePath);
    String ext = paths.get(paths.size() - 1);
    if (!Arrays.asList("png", "jpg").contains(ext)) {
      throw new Exception("format error");
    }
    String resultPath =
        Joiner.on(File.separator).join(Arrays.asList(outputDir, IdUtil.simpleUUID() + "." + ext));
    String ffmpeg = Loader.load(org.bytedeco.ffmpeg.ffmpeg.class);
    ProcessBuilder builder =
        new ProcessBuilder(
            ffmpeg,
            "-i",
            imagePath,
            "-vf",
            MessageFormat.format("transpose={0}", String.valueOf(type)),
            "-y",
            resultPath);
    builder.inheritIO().start().waitFor();
    return resultPath;
  }

}
 
 
代码说明
 
1、vflip主要是对图片做垂直翻转，hflip对图片做水平翻转，rotate对图片做顺时针旋转（参数angle为角度，例如：90），transpose对图片有4个类型的转置（type参数为：0,1,2,3，类型如下图）。
 
 
 
2、输出路径避免重复，使用uuid作为文件名。
 
3、图片后缀校验目前只有两种，如需增加，自行添加。
 
 
验证一下
 
准备好的图片如下
 
 
 
 
验证代码
 
 
  public static void main(String[] args) throws Exception {
    System.out.println(vflip("C:/Users/huyi/Desktop/2.jpg", "C:/Users/huyi/Desktop/"));
    System.out.println(hflip("C:/Users/huyi/Desktop/2.jpg", "C:/Users/huyi/Desktop/"));
    System.out.println(rotate("C:/Users/huyi/Desktop/2.jpg", "C:/Users/huyi/Desktop/", 280));
    System.out.println(transpose("C:/Users/huyi/Desktop/2.jpg", "C:/Users/huyi/Desktop/", 2));
  }
 
 
vflip效果
 
 
 
 
hflip效果
 
 
 
 
rotate效果
 
 
 
 
transpose效果 
 
 
 
 
OK，没什么毛病。
 
 
总结
 
没什么好总结。
 
分享：
 
        人生不如意之事七八九，能与人言一二三都无，才算坎坷。——《雪中悍刀行》
 
如果本文对你有帮助的话，请不要吝啬你的赞，谢谢！