矩阵中旋转变换公式是指逆时针旋转还是顺时针 有啥不同啥意思

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了矩阵中旋转变换公式是指逆时针旋转还是顺时针 有啥不同啥意思相关的知识,希望对你有一定的参考价值。

逆时针和顺时针,都统称为旋转变换,只是部分系数不同而已。 参考技术A 表示本人数学很垃不一定能讲的很到位。你先确定图形一条始边,再将它与原点连线,单独将连成的线绕转90°就容易确定坐标了。一般来说还是先确定坐标的正负,就看图形所在象限,在根据题目要求旋转图形就可以了。

183Java8对图片做顺时针旋转90度逆时针旋转90度旋转180度水平翻转垂直翻转操作。

图片可以看作是矩阵。对图片的操作就是对矩阵的操作。下面按照不同操作分别进行讲解。

顺时针旋转90度

把原图片的最后一行,转变为新图片的第1列.
把原图片的倒数第2行,转变为新图片的第2列.
……
以此类推,进行变换。

逆时针旋转90度

把原图片第1行,转变为新图片第1列。并且旧行中第1个像素是新列中最后1个像素.
把原图片第2行,转变为新图片第2列。并且旧行中第1个像素是新列中最后1个像素.
……
以此类推,进行变换。

顺时针旋转180度

原图片第1行转变为新图片倒数第1行。并且旧行中像素的顺序,在新行倒转了过来。
原图片第2行转变为新图片倒数第2行。并且旧行中像素的顺序,在新行倒转了过来。
……
以此类推,进行变换。

水平翻转

把图片矩阵中列向量的排列顺序反过来。

垂直翻转

把图片矩阵中行向量的排列顺序反过来。

代码实现

package zhangchao.testalgorithm.changeimage;

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


/**
 * 图片变换的工具类。
 * @author zhangchao
 */
public final class ChangeImageUtils 
    

    /**
     * 把图片顺时针旋转90度
     * @param file 原来的图片文件
     * @param outputFile 新生成的图片文件
     * @param formatName 图片文件扩展名
     */
    public final static void clockwise90(final File file, final File outputFile, final String formatName) 
        try 
            // 原图片
            BufferedImage image = ImageIO.read(file);
            int width = image.getWidth();
            int height = image.getHeight();

            // 新生成的图片
            BufferedImage imageNew = new BufferedImage(height, width, image.getType());
            // 把原图顺时针旋转后,像素存入新图片。
            // 算法实现方式:
            //    把原图片的最后一行,转变为新图片的第1列.
            //    把原图片的倒数第2行,转变为新图片的第2列.
            //    ......
            // 以此类推,进行变换。代码中行数列数从0开始计算。
            int maxY = height - 1;
            for (int y = maxY; y >= 0; y--) 
                for (int x = 0; x < width; x++) 
                    int rgb = image.getRGB(x, y);
                    imageNew.setRGB(maxY - y, x, rgb);
                
            
            // 把图片输出到硬盘上。
            ImageIO.write(imageNew, formatName, outputFile);
         catch (IOException e) 
            e.printStackTrace();
        
    

    /**
     * 把图片逆时针旋转90度
     * @param file 原来的图片文件
     * @param outputFile 新生成的图片文件
     * @param formatName 图片文件扩展名
     */
    public final static void anticlockwise90(final File file, final File outputFile, final String formatName) 
        try 
            // 原图片
            BufferedImage image = ImageIO.read(file);
            int width = image.getWidth();
            int height = image.getHeight();

            // 新生成的图片
            BufferedImage imageNew = new BufferedImage(height, width, image.getType());

            // 把原图逆时针旋转后,像素存入新图片。
            // 算法实现方式:
            //    把原图片第1行,转变为新图片第1列。并且旧行中第1个像素是新列中最后1个像素.
            //    把原图片第2行,转变为新图片第2列。并且旧行中第1个像素是新列中最后1个像素.
            //    ......
            // 以此类推,进行变换。代码中行数列数从0开始计算。
            int maxX = width - 1;
            for (int y = 0; y < height; y++) 
                for (int x = 0; x < width; x++) 
                    int rgb = image.getRGB(x, y);
                    imageNew.setRGB(y, maxX - x, rgb);
                
            

            // 把图片输出到硬盘上。
            ImageIO.write(imageNew, formatName, outputFile);
         catch (IOException e) 
            e.printStackTrace();
        
    

    /**
     * 把图片顺时针旋转180度
     * @param file 原来的图片文件
     * @param outputFile 新生成的图片文件
     * @param formatName 图片文件扩展名
     */
    public final static void clockwise180(final File file, final File outputFile, final String formatName) 
        try 
            // 原图片
            BufferedImage image = ImageIO.read(file);
            int width = image.getWidth();
            int height = image.getHeight();
            // 新生成的图片
            BufferedImage imageNew = new BufferedImage(width, height, image.getType());

            // 把原图片顺时针旋转180度后,像素存入新图片。
            // 算法实现方式:
            //    原图片第1行转变为新图片倒数第1行。并且旧行中像素的顺序,在新行倒转了过来。
            //    原图片第2行转变为新图片倒数第2行。并且旧行中像素的顺序,在新行倒转了过来。
            //    ......
            // 以此类推,进行变换。代码中行数列数从0开始计算。
            int maxX = width - 1;
            int maxY = height - 1;
            for (int y = 0; y < height; y++) 
                for (int x = 0; x < width; x++) 
                    int rgb = image.getRGB(x, y);
                    imageNew.setRGB(maxX - x, maxY - y, rgb);
                
            

            // 把图片输出到硬盘上。
            ImageIO.write(imageNew, formatName, outputFile);
         catch (IOException e) 
            e.printStackTrace();
        
    

    /**
     * 把图片水平翻转
     * @param file 原来的图片文件
     * @param outputFile 新生成的图片文件
     * @param formatName 图片文件扩展名
     */
    public final static void flipHorizontally(final File file, final File outputFile, final String formatName) 
        try 
            // 原图片
            BufferedImage image = ImageIO.read(file);
            int width = image.getWidth();
            int height = image.getHeight();
            // 新生成的图片
            BufferedImage imageNew = new BufferedImage(width, height, image.getType());

            // 把原图片水平翻转后,像素存入新图片。
            // 实现方法就是把列的排列顺序反过来。
            int maxX = width - 1;
            for (int x = 0; x < width; x++) 
                for (int y = 0; y < height; y++) 
                    int rgb = image.getRGB(x, y);
                    imageNew.setRGB(maxX - x, y, rgb);
                
            

            // 把图片输出到硬盘上。
            ImageIO.write(imageNew, formatName, outputFile);
         catch (IOException e) 
            e.printStackTrace();
        
    

    /**
     * 把图片垂直翻转
     * @param file 原来的图片文件
     * @param outputFile 新生成的图片文件
     * @param formatName 图片文件扩展名
     */
    public final static void flipVertically(final File file, final File outputFile, final String formatName) 
        try 
            // 原图片
            BufferedImage image = ImageIO.read(file);
            int width = image.getWidth();
            int height = image.getHeight();
            // 新生成的图片
            BufferedImage imageNew = new BufferedImage(width, height, image.getType());

            // 把原图片垂直翻转后,像素存入新的图片。
            // 把图片看作矩阵,行与行之间的顺序做了翻转。
            int maxY = height - 1;
            for (int y = 0; y < height; y++) 
                for (int x = 0; x < width; x++) 
                    int rgb = image.getRGB(x, y);
                    imageNew.setRGB(x, maxY - y, rgb);
                
            

            // 把图片输出到硬盘上。
            ImageIO.write(imageNew, formatName, outputFile);
         catch (IOException e) 
            e.printStackTrace();
        
    
    
    public static void main(String[] args) 
    	File originFile = new File("D:\\\\testTemp\\\\changeImage\\\\origin.jpg");
    	File clockwise90File = new File("D:\\\\testTemp\\\\changeImage\\\\out_clockwise90.jpg");
    	ChangeImageUtils.clockwise90(originFile, clockwise90File, "jpg");
    	
    	File anticlockwise90File = new File("D:\\\\testTemp\\\\changeImage\\\\out_anticlockwise90.jpg");
    	ChangeImageUtils.anticlockwise90(originFile, anticlockwise90File, "jpg");
    	
    	File clockwise180File = new File("D:\\\\testTemp\\\\changeImage\\\\out_clockwise180.jpg");
    	ChangeImageUtils.clockwise180(originFile, clockwise180File, "jpg");
    	
    	File flipHorizontallyFile = new File("D:\\\\testTemp\\\\changeImage\\\\out_flipHorizontally.jpg");
    	ChangeImageUtils.flipHorizontally(originFile, flipHorizontallyFile, "jpg");
    	
    	File flipVerticallyFile = new File("D:\\\\testTemp\\\\changeImage\\\\out_flipVertically.jpg");
    	ChangeImageUtils.flipVertically(originFile, flipVerticallyFile, "jpg");
    	
    	System.out.print("main");
    



以上是关于矩阵中旋转变换公式是指逆时针旋转还是顺时针 有啥不同啥意思的主要内容,如果未能解决你的问题,请参考以下文章

将下面矩阵分别按顺时针90度,逆时针90度,和旋转180度,打印出来

Leecode-48:旋转图像(矩阵顺时针旋转90度)

向量旋转公式:

给定一个 n × n 的二维矩阵表示一个图像, 将图像顺时针旋转 90 度js实现

183Java8对图片做顺时针旋转90度逆时针旋转90度旋转180度水平翻转垂直翻转操作。

183Java8对图片做顺时针旋转90度逆时针旋转90度旋转180度水平翻转垂直翻转操作。