在文章的最下面有详细代码。
原图:
一、傅里叶变换。
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+d^2) +((bc-ad)/(c^2+d^2))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);
}
}