图像处理 傅里叶滤波

在文章的最下面有详细代码。
原图：

一、傅里叶变换。
1、介绍。

可以查看我的关于傅里叶变换的代码。

2、代码。

public static void main(String[] args) {
    //均值滤波
    String sourcePath = "G:\\xiaojie-java-test\\img\\阿卡丽.jpg";
    String targetPath = "G:\\xiaojie-java-test\\img\\滤波\\傅里叶滤波\\阿卡丽\\";
    getSpectrum(sourcePath, targetPath + "频谱图.jpg", 0, FourierUtils.Type_Filter_Low);
}

private static void getSpectrum(String sourcePath, String targetPath, int percent, int type) {
    try {
        //获取原图像对象，并获取原图像的二维数组
        BufferedImage image = ImageIO.read(new File(sourcePath));
        int[][] imgArrays = ImageUtils.getBytes(image);
        //生成新图像的二维数组
        Complex[][] complexArray = FourierUtils.getFft(imgArrays);
        int[][] spectrumArray = FourierUtils.getSpectrum(complexArray, percent, type);
        //生成新图片对象，填充像素
        BufferedImage newImage = new BufferedImage(spectrumArray.length, spectrumArray.length, BufferedImage.TYPE_BYTE_GRAY);
        ImageUtils.setInts(newImage, spectrumArray);
        //生成图片文件
        ImageIO.write(newImage, "JPEG", new File(targetPath));
        Thread.sleep(1);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
/**
 * 获取频谱值，并中心化 |F(k)|=Math.sqrt(实数的平方 + 虚数的平方)
 *
 * @param complexArray FFT之后的 complexArray[][]
 * @param percent      过滤半径的百分比
 * @param type         高频过滤、低频过滤
 */
public static int[][] getSpectrum(Complex[][] complexArray, int percent, int type) {
    int length = complexArray.length;
    //
    int[][] array = new int[length][length];
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < length; j++) {
            double real = complexArray[i][j].getReal();
            double image = complexArray[i][j].getImage();
            int a = (int) Math.sqrt(real * real + image * image);
            array[i][j] = a;
        }
    }
    return array;
}

3、结果。

二、将低频部分移到中间。
1、介绍。

将低频部分移到中间，就是将矩阵的第一象限和第三象限对调，第二象限和第四象限对调。

2、代码。

/**

• 获取频谱值，并中心化 |F(k)|=Math.sqrt(实数的平方 + 虚数的平方)
• @param complexArray FFT之后的 complexArray[][]
• @param percent 过滤半径的百分比
• @param type 高频过滤、低频过滤
  */
  public static int[][] getSpectrum(Complex[][] complexArray, int percent, int type) {
  int length = complexArray.length;
  int middle = length / 2;
  int iShift, jShift;
  int filterLength = (int) (length / 200.0 * percent);
  double centerIndex = (length - 1) / 2.0;
  //
  int[][] array = new int[length][length];
  for (int i = 0; i < length; i++) {
  for (int j = 0; j < length; j++) {
  double real = complexArray[i][j].getReal();
  double image = complexArray[i][j].getImage();
  int a = (int) Math.sqrt(real * real + image * image);
  //将矩阵分成四块，第一象限和第三象限对调，第二象限和第四象限对调
  iShift = i < middle ? i + middle : i - middle;
  jShift = j < middle ? j + middle : j - middle;
  //
  if (filterLength > NumberUtils.getDistance(iShift, jShift, centerIndex, centerIndex)) {//圆内
  array[iShift][jShift] = type == Type_Filter_High ? a : 0;
  } else {//圆外
  array[iShift][jShift] = type == Type_Filter_Low ? a : 0;
  }
  }
  }
  return array;
  }
  3、结果。

三、高频率和低频滤波。

1、介绍。

低频滤波，将频谱图中间的保留住，会使原图像变模糊。高频滤波，将频谱图中间的去除，会保留原图像的边缘。

2、主流程代码（FourierTest .java）。

package com.zxj.reptile.test.image.filter;

import com.zxj.reptile.utils.image.FourierUtils;
import com.zxj.reptile.utils.image.ImageUtils;
import com.zxj.reptile.utils.number.Complex;

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

/**

• 傅里叶滤波
  */
  public class FourierTest {
  public static void main(String[] args) {
  String sourcePath = “G:\xiaojie-java-test\img\阿卡丽.jpg”;
  String targetPath = “G:\xiaojie-java-test\img\滤波\傅里叶滤波\阿卡丽\”;

   //当type=Type_Filter_Low时，percent=0时，或者当type=Type_Filter_High时，percent=100时，IFFT之后会是原图
   getSpectrum(sourcePath, targetPath + "频谱图.jpg", 0, FourierUtils.Type_Filter_High);
  
   getSpectrum(sourcePath, targetPath + "high_1.jpg", 1, FourierUtils.Type_Filter_High);
   getSpectrum(sourcePath, targetPath + "high_2.jpg", 2, FourierUtils.Type_Filter_High);
   getSpectrum(sourcePath, targetPath + "high_3.jpg", 3, FourierUtils.Type_Filter_High);
   getSpectrum(sourcePath, targetPath + "low_10.jpg", 10, FourierUtils.Type_Filter_Low);
   getSpectrum(sourcePath, targetPath + "low_20.jpg", 20, FourierUtils.Type_Filter_Low);
   getSpectrum(sourcePath, targetPath + "low_30.jpg", 30, FourierUtils.Type_Filter_Low);
  

  }

  private static void getSpectrum(String sourcePath, String targetPath, int percent, int type) {
  try {
  //获取原图像对象，并获取原图像的二维数组
  BufferedImage image = ImageIO.read(new File(sourcePath));
  int[][] imgArrays = ImageUtils.getBytes(image);

       //频谱图
       //生成新图像的二维数组
       Complex[][] complexArray = FourierUtils.getFft(imgArrays);
       int[][] spectrumArray = FourierUtils.getSpectrum(complexArray, percent, type);
       //生成新图片对象，填充像素
       BufferedImage newImage = new BufferedImage(spectrumArray.length, spectrumArray.length, BufferedImage.TYPE_BYTE_GRAY);
       ImageUtils.setInts(newImage, spectrumArray);
       //生成图片文件
       ImageIO.write(newImage, "JPEG", new File(targetPath));
       Thread.sleep(1);
  
       //原图
       //生成新图像的二维数组
       FourierUtils.getFilter(complexArray, spectrumArray);
       int[][] newImgArrays = FourierUtils.getInverseFft(complexArray, imgArrays.length, imgArrays[0].length);
       //生成新图片对象，填充像素
       newImage = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_INT_RGB);
       ImageUtils.setIntsForGray(newImage, newImgArrays);
       //生成图片文件
       targetPath = targetPath.split("\\.")[0] + "_原图." + targetPath.split("\\.")[1];
       ImageIO.write(newImage, "JPEG", new File(targetPath));
       Thread.sleep(1);
   } catch (Exception e) {
       e.printStackTrace();
   }
  

  }
  }
  3、原图。

4、高频，半径1。

5、高频，半径2.

6、高频，半径3。

7、低频，半径10。

8、低频，半径20。

9、低频，半径30。

四、详细代码

1、ImageUtils.java。

package com.zxj.reptile.utils.image;

import java.awt.image.BufferedImage;

/**

• 要用int，不能使用byte，因为byte最大值为128
  */
  public class ImageUtils {
  //灰度处理的方法
  public static final byte Gray_Type_Min = 1;//最大值法
  public static final byte Gray_Type_Max = 2;//最小值法
  public static final byte Gray_Type_Average = 3;//平均值法
  public static final byte Gray_Type_Weight = 4;//加权法
  public static final byte Gray_Type_Red = 5;//红色值法
  public static final byte Gray_Type_Green = 6;//绿色值法
  public static final byte Gray_Type_Blue = 7;//蓝色值法
  public static final byte Gray_Type_Default = Gray_Type_Average;//默认加权法

  /**

  • 灰度化处理，彩色int[][] 转 灰度int[][]
  • @param imgArrays 图像二维数组
  • @param grayType 灰度化方法
    */
    public static int[][] getGrayImg(int[][] imgArrays, int grayType) throws Exception {
    int[][] newImgArrays = new int[imgArrays.length][imgArrays[0].length];
    for (int h = 0; h < imgArrays.length; h++)
    for (int w = 0; w < imgArrays[0].length; w++)
    newImgArrays[h][w] = getGray(getRgb(imgArrays[h][w]), grayType);
    return newImgArrays;
    }

  /**

  • 根据像素，返回r、g、b 的 int[]
  • @param pixel 像素值
    */
    private static int[] getRgb(int pixel) {
    int[] rgb = new int[3];
    rgb[0] = ((pixel >> 16) & 0xff);
    rgb[1] = ((pixel >> 8) & 0xff);
    rgb[2] = (pixel & 0xff);
    return rgb;
    }

  /**

  • 根据r、g、b 的 int[]，返回灰度值
  • @param rgb r、g、b颜色通道的值
  • @param grayType 不同灰度处理的方法
    */
    private static int getGray(int[] rgb, int grayType) throws Exception {
    if (grayType == Gray_Type_Average) {
    return ((rgb[0] + rgb[1] + rgb[2]) / 3); //rgb之和除以3
    } else if (grayType == Gray_Type_Weight) {
    return (int) (0.3 * rgb[0] + 0.59 * rgb[1] + 0.11 * rgb[2]);
    } else if (grayType == Gray_Type_Red) {
    return rgb[0];//取红色值
    } else if (grayType == Gray_Type_Green) {
    return rgb[1];//取绿色值
    } else if (grayType == Gray_Type_Blue) {
    return rgb[2];//取蓝色值
    }
    //比较三个数的大小
    int gray = rgb[0];
    for (int i = 1; i < rgb.length; i++) {
    if (grayType == Gray_Type_Min) {
    if (gray > rgb[i]) {
    gray = rgb[i];//取最小值
    }
    } else if (grayType == Gray_Type_Max) {
    if (gray < rgb[i]) {
    gray = rgb[i];//取最大值
    }
    } else {
    throw new Exception(“grayType出错”);
    }
    }
    return gray;
    }

  /**

  • 获取图像像素 int[][]
  • @param image BufferedImage图像对象
    */
    public static int[][] getInts(BufferedImage image) {
    int[][] imgArrays = new int[image.getHeight()][image.getWidth()];
    for (int i = 0; i < image.getHeight(); i++)
    for (int j = 0; j < image.getWidth(); j++)
    imgArrays[i][j] = image.getRGB(j, i);
    return imgArrays;
    }

  /**

  • 获取图像像素 int[][]
  • @param image BufferedImage图像对象
    */
    public static int[][] getBytes(BufferedImage image) throws Exception {
    return getGrayImg(getInts(image), Gray_Type_Default);
    }

  /**

  • 图像像素填充 byte[][]
  • @param image BufferedImage图像对象
  • @param imgArrays 二维像素
    */
    public static void setBytes(BufferedImage image, int[][] imgArrays) {
    for (int i = 0; i < image.getHeight(); i++)
    for (int j = 0; j < image.getWidth(); j++)
    image.setRGB(j, i, (byte) imgArrays[i][j]);
    }

  /**

  • 图像像素填充 int[][]
  • @param image BufferedImage图像对象
  • @param imgArrays 二维像素
    */
    public static void setInts(BufferedImage image, int[][] imgArrays) {
    for (int i = 0; i < image.getHeight(); i++)
    for (int j = 0; j < image.getWidth(); j++)
    image.setRGB(j, i, imgArrays[i][j]);
    }

  /**

  • 图像像素填充 将 byte[][] 变为 int[][] 进行填充
  • @param image BufferedImage图像对象
  • @param imgArrays 二维像素
    */
    public static void setIntsForGray(BufferedImage image, int[][] imgArrays) {
    for (int i = 0; i < image.getHeight(); i++)
    for (int j = 0; j < image.getWidth(); j++)
    image.setRGB(j, i, imgArrays[i][j] + (imgArrays[i][j] << 8) + (imgArrays[i][j] << 16));
    }
    }
    2、FourierUtils.java。

package com.zxj.reptile.utils.image;

import com.zxj.reptile.utils.number.Complex;
import com.zxj.reptile.utils.number.NumberUtils;

public class FourierUtils {

/**
 * 一维FFT 和 一维IFFT 处理过程
 *
 * @param complexArray      一维复数数组
 * @param eulerComplexArray 欧拉数组
 */
private static Complex[] fftProgress(Complex[] complexArray, Complex[] eulerComplexArray) {
    int length = complexArray.length;
    if (length == 2) {
        //F(0)=f(0)+f(1),F(1)=f(0)-f(1)
        return new Complex[]{
                complexArray[0].add(complexArray[1]),
                complexArray[0].sub(complexArray[1]),};
    } else if (length == 1) {
        return complexArray;
    }
    int middle = length / 2;
    //
    Complex[] a = new Complex[middle];//a(x)=f(2x)
    Complex[] b = new Complex[middle];//b(x)=f(2x+1)
    for (int i = 0; i < middle; i++) {
        a[i] = complexArray[2 * i];
        b[i] = complexArray[2 * i + 1];
    }
    //
    Complex[] complexesA = fftProgress(a, eulerComplexArray);//计算G(k)
    Complex[] complexesB = fftProgress(b, eulerComplexArray);//计算P(k)
    Complex[] resultArray = new Complex[length];//F(k)
    int multiple = eulerComplexArray.length / middle;
    for (int i = 0; i < middle; i++) {
        //e^(2Pi*k/N)
        Complex complex = eulerComplexArray[multiple * i].mul(complexesB[i]);
        //F(k)=G(k)+(e^(2Pi*k/N))*P(k)
        resultArray[i] = complexesA[i].add(complex);
        //F(k+(N/2))=G(k)+(e^(2Pi*(k+(N/2))/N))*P(k+(N/2))
        resultArray[i + middle] = complexesA[i].sub(complex);
    }
    return resultArray;
}

/**
 * 二维FFT
 *
 * @param arrays 二维数组
 */
public static Complex[][] getFft(int[][] arrays) {
    //实际的行列
    int row = arrays.length;
    int column = arrays[0].length;
    //调节过的长度
    int variableLength = (int) NumberUtils.getVariablePow(row > column ? row : column, 2);
    Complex[][] variableArray = new Complex[variableLength][variableLength];
    for (int i = 0; i < variableLength; i++)
        for (int j = 0; j < variableLength; j++)
            variableArray[i][j] = (i < row && j < column) ? new Complex(arrays[i][j]) : new Complex();
    return fftProgress(variableArray, getEulerComplex(variableLength, -1));
}

/**
 * 二维IFFT
 *
 * @param complexArrays 二维复数数组
 */
public static int[][] getInverseFft(Complex[][] complexArrays, int realRow, int realColumn) {
    int length = complexArrays.length;
    complexArrays = fftProgress(complexArrays, getEulerComplex(length, 1));
    int[][] arrays = new int[realRow][realColumn];
    for (int i = 0; i < realRow; i++)
        for (int j = 0; j < realColumn; j++)
            arrays[i][j] = (int) Math.round(complexArrays[i][j].getReal() / (length * length));
    return arrays;
}

/**
 * 二维FFT 和 二维IFFT 处理过程
 *
 * @param complexArrays     二维复数数组
 * @param eulerComplexArray 欧拉数组
 */
private static Complex[][] fftProgress(Complex[][] complexArrays, Complex[] eulerComplexArray) {
    int length = complexArrays.length;
    //对每行进行一维DFT
    for (int i = 0; i < length; i++) {
        complexArrays[i] = fftProgress(complexArrays[i], eulerComplexArray);
    }
    //倒置，即行和列互换
    complexArrays = Complex.transform(complexArrays);
    length = complexArrays.length;
    //对每行进行一维DFT，实际上是对没倒置前数组的列做一维DFT
    for (int i = 0; i < length; i++) {
        complexArrays[i] = fftProgress(complexArrays[i], eulerComplexArray);
    }
    //倒置回来
    complexArrays = Complex.transform(complexArrays);
    return complexArrays;
}

/**
 * 关于欧拉计算的数组
 *
 * @param variableLength 数组大小
 */
private static Complex[] getEulerComplex(int variableLength, int minus) {
    int middle = variableLength / 2;
    double flag = 2 * Math.PI / variableLength;//2Pi / N
    Complex[] eulerComplexArray = new Complex[middle];
    for (int i = 0; i < middle; i++) {
        eulerComplexArray[i] = Complex.euler(minus * flag * i);
    }
    return eulerComplexArray;
}

public static final int Type_Filter_High = 1;
public static final int Type_Filter_Low = 2;

/**
 * 获取频谱值，并中心化 |F(k)|=Math.sqrt(实数的平方 + 虚数的平方)
 *
 * @param complexArray FFT之后的 complexArray[][]
 * @param percent      过滤半径的百分比
 * @param type         高频过滤、低频过滤
 */
public static int[][] getSpectrum(Complex[][] complexArray, int percent, int type) {
    int length = complexArray.length;
    int middle = length / 2;
    int iShift, jShift;
    int filterLength = (int) (length / 200.0 * percent);
    double centerIndex = (length - 1) / 2.0;
    //
    int[][] array = new int[length][length];
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < length; j++) {
            double real = complexArray[i][j].getReal();
            double image = complexArray[i][j].getImage();
            int a = (int) Math.sqrt(real * real + image * image);
            //将矩阵分成四块，第一象限和第三象限对调，第二象限和第四象限对调
            iShift = i < middle ? i + middle : i - middle;
            jShift = j < middle ? j + middle : j - middle;
            //
            if (filterLength > NumberUtils.getDistance(iShift, jShift, centerIndex, centerIndex)) {//圆内
                array[iShift][jShift] = type == Type_Filter_Low ? a : 0;
            } else {//圆外
                array[iShift][jShift] = type == Type_Filter_High ? a : 0;
            }
        }
    }
    return array;
}

/**
 * 傅里叶过滤
 *
 * @param spectrumArray 频谱 int[][]
 */
public static void getFilter(Complex[][] complexArray, int[][] spectrumArray) {
    int length = spectrumArray.length;
    int middle = length / 2;
    int iShift, jShift;
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < length; j++) {
            if (spectrumArray[i][j] == 0) {
                //将矩阵分成四块，第一象限和第三象限对调，第二象限和第四象限对调
                iShift = i < middle ? i + middle : i - middle;
                jShift = j < middle ? j + middle : j - middle;
                complexArray[iShift][jShift].setImage(0);
                complexArray[iShift][jShift].setReal(0);
            }
        }
    }
}

}
3、NumberUtils.java。

package com.zxj.reptile.utils.number;

public class NumberUtils {
/**
* 返回 length = Math.sqrt( (x1-x2)^2 + (y1-y2) )
*/
public static double getDistance(double x1, double y1, double x2, double y2) {
double xDistance = x1 - x2;
double yDistance = y1 - y2;
return Math.sqrt(xDistance * xDistance + yDistance * yDistance);
}

/**
 * 将byte数组转为一个十进制整数
 *
 * @param bytes 8位的字节数组   1B=8bit
 */
public static int getTenHex(byte[] bytes) {
    int result = 0;
    for (int i = 0; i < bytes.length; i++) {
        int move = bytes.length - i - 1;
        int value = (bytes[i] & 255) << (8 * move);
        result += value;
    }
    return result;
}

/**
 * 指定小数精度的四舍五入
 *
 * @param value         值
 * @param decimalLength 精度值
 */
public static double getRound(double value, int decimalLength) {
    double flag = Math.pow(10, decimalLength);
    int a = (int) Math.round(value * flag);
    return a / flag;
}

/**
 * 返回幂，而幂大于或者等于power
 *
 * @param power 幂
 * @param base  底数
 */
public static double getVariablePow(int power, int base) {
    int variableIndex = 0;
    double index = NumberUtils.getIndex(power, base);
    if (index > (int) index) {
        variableIndex = (int) index + 1;
    } else {
        variableIndex = (int) index;
    }
    return Math.pow(base, variableIndex);
}

/**
 * 返回指数
 *
 * @param power 幂
 * @param base  底数
 * @return 返回指数
 */
public static double getIndex(int power, int base) {
    return Math.log10(power) / Math.log10(base);
}

/**
 * 返回是否为整数
 *
 * @param a 数字a
 * @return 返回数字a是否为整数
 */
public static boolean isInteger(double a) {
    return (a - (int) a == 0);
}

/**
 * 10进制，数的长度
 *
 * @param number 数
 */
public static int getNumberSize(long number) {
    return getNumberSize(number, 10);
}

/**
 * 指定进制，数的长度
 *
 * @param number 数
 * @param radix  进制
 */
public static int getNumberSize(long number, int radix) {
    if (number == 0) {
        return 1;
    }
    int size = 0;
    while (number > 0) {
        number /= radix;
        size++;
    }
    return size;
}

}
4、Complex.java。

package com.zxj.reptile.utils.number;

/**

• 复数的基本操作
  */
  public class Complex {
  private double real;//实数
  private double image;//虚数

  public Complex() {
  real = 0;
  image = 0;
  }

  public Complex(double real) {
  this.real = real;
  this.image = 0;
  }

  public Complex(double real, double image) {
  this.real = real;
  this.image = image;
  }

  //加：(a+bi)+(c+di)=(a+c)+(b+d)i
  public Complex add(Complex complex) {
  double real = complex.getReal();
  double image = complex.getImage();
  double newReal = this.real + real;
  double newImage = this.image + image;
  return new Complex(newReal, newImage);
  }

  //减：(a+bi)-(c+di)=(a-c)+(b-d)i
  public Complex sub(Complex complex) {
  double real = complex.getReal();
  double image = complex.getImage();
  double newReal = this.real - real;
  double newImage = this.image - image;
  return new Complex(newReal, newImage);
  }

  //乘：(a+bi)(c+di)=(ac-bd)+(bc+ad)i
  public Complex mul(Complex complex) {
  double real = complex.getReal();
  double image = complex.getImage();
  double newReal = this.real * real - this.image * image;
  double newImage = this.image * real + this.real * image;
  return new Complex(newReal, newImage);
  }

  //乘：a(c+di)=ac+adi
  public Complex mul(double multiplier) {
  return mul(new Complex(multiplier));
  }

  //除：(a+bi)/(c+di)=(ac+bd)/(c^2+d2) +((bc-ad)/(c^2+d2))i
  public Complex div(Complex complex) {
  double real = complex.getReal();
  double image = complex.getImage();
  double denominator = real * real + image * image;
  double newReal = (this.real * real + this.image * image) / denominator;
  double newImage = (this.image * real - this.real * image) / denominator;
  return new Complex(newReal, newImage);
  }

  public double getReal() {
  return real;
  }

  public void setReal(double real) {
  this.real = real;
  }

  public double getImage() {
  return image;
  }

  public void setImage(double image) {
  this.image = image;
  }

  @Override
  public String toString() {
  String str = “”;
  if (real != 0) {
  str += real;
  } else {
  str += “0”;
  }
  if (image < 0) {
  str += image + “i”;
  } else if (image > 0) {
  str += “+” + image + “i”;
  }
  return str;
  }

  /**

  • 欧拉公式 e^(ix)=cosx+isinx
  • @param x 相当于角度
    */
    public static Complex euler(double x) {
    double newReal = Math.cos(x);
    double newImage = Math.sin(x);
    return new Complex(newReal, newImage);
    }

  /**

  • Complex 和 Complex 比较
  • @param a 复数a
  • @param b 复数b
    */
    public static boolean equals(Complex a, Complex b) {
    return NumberUtils.getRound(a.getImage(), 4) == NumberUtils.getRound(b.getImage(), 4) &&
    NumberUtils.getRound(a.getReal(), 4) == NumberUtils.getRound(b.getReal(), 4);
    }

  /**

  • Complex[] 和 Complex[] 比较
  • @param a 复数数组a
  • @param b 复数数组b
    */
    public static boolean equals(Complex[] a, Complex[] b) {
    if (a.length != b.length) {
    return false;
    }
    for (int i = 0; i < a.length; i++) {
    if (!equals(a[i], b[i])) {
    return false;
    }
    }
    return true;
    }

  /**

  • Complex[][] 和 Complex[][] 比较
  • @param a 二维复数数组a
  • @param b 二维复数数组b
    */
    public static boolean equals(Complex[][] a, Complex[][] b) {
    if (a.length != b.length) {
    return false;
    }
    for (int i = 0; i < a.length; i++) {
    if (!equals(a[i], b[i])) {
    return false;
    }
    }
    return true;
    }

  /**

  • double[] --> Complex[]
  • @param array double数组
    */
    public static Complex[] getComplexArray(int[] array) {
    Complex[] complexArray = new Complex[array.length];
    for (int i = 0; i < array.length; i++) {
    complexArray[i] = new Complex(array[i]);
    }
    return complexArray;
    }

  /**

  • double[][] --> Complex[][]
  • @param array double二维数组
    */
    public static Complex[][] getComplexArray(int[][] array) {
    int length = array.length;
    Complex[][] complexArray = new Complex[length][];
    for (int i = 0; i < length; i++) {
    complexArray[i] = getComplexArray(array[i]);
    }
    return complexArray;
    }

  /**

  • Complex.real[] --> int[]
  • @param complexArray 复数数组
    */
    public static int[] getRealArray(Complex[] complexArray) {
    int length = complexArray.length;
    int[] array = new int[length];
    for (int i = 0; i < length; i++) {
    array[i] = (int) Math.round(complexArray[i].getReal());
    }
    return array;
    }

  /**

  • Complex.real[][] --> int[][]
  • @param complexArray 二维复数数
    */
    public static int[][] getRealArray(Complex[][] complexArray) {
    int length = complexArray.length;
    int[][] array = new int[length][];
    for (int i = 0; i < length; i++) {
    array[i] = getRealArray(complexArray[i]);
    }
    return array;
    }

  /**

  • Complex.image[] --> int[]
  • @param complexArray 复数数组
    */
    public static int[] getImageArray(Complex[] complexArray) {
    int length = complexArray.length;
    int[] array = new int[length];
    for (int i = 0; i < length; i++) {
    array[i] = (int) Math.round(complexArray[i].getImage());
    }
    return array;
    }

  /**

  • Complex.image[][] --> int[][]
  • @param complexArray 二维复数数
    */
    public static int[][] getImageArray(Complex[][] complexArray) {
    int length = complexArray.length;
    int[][] array = new int[length][];
    for (int i = 0; i < length; i++) {
    array[i] = getImageArray(complexArray[i]);
    }
    return array;
    }

  /**

  • 二维复数数组转置
  • @param a 二维复数数组
    */
    public static Complex[][] transform(Complex[][] a) {
    int row = a.length;
    int column = a[0].length;
    Complex[][] result = new Complex[column][row];
    for (int i = 0; i < column; i++)
    for (int j = 0; j < row; j++)
    result[i][j] = a[j][i];
    return result;
    }

  public static void print(Complex[] complexArray) {
  for (Complex complex : complexArray)
  System.out.print(complex + " ");
  System.out.println();
  }

  public static void print(Complex[][] complexArray) {
  for (Complex[] complexes : complexArray)
  print(complexes);
  }
  }
  ————————————————
  版权声明：本文为CSDN博主「@一头雾水@」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
  原文链接：https://blog.csdn.net/qq_36511401/article/details/103105056