Desktop / КА отчет
.pdf4 Тестирование программы
Программа прошла ручное тестирование. Все ошибки, выявленные в ходе тестирования, были устранены. В приложении B можно ознакомиться с результатами работы программы. В качестве главного критерия правильности работы алгоритма были результаты вывода разницы спектров, полученных при помощи обычного и быстрого алгоритма. А так же визуальное сравнение результатов работы этих алгоритмов.
11
5 Исследование алгоритма
После тестирования программы было произведено несколько экспериментальных запусков программы на различных изображениях. В результате было вычислено среднее время работы алгоритмов. В таблице 5.1 приведены результаты исследований на изображениях различных размеров. Уже при размере изображения 16*16 сильно заметна эффективность быстрого алгоритма. Можно сделать вывод, что быстрое преобразование Фурье существенно увеличивает скорость расчётов, давая при этом незначительные (для большинства прикладных задач) потери точности.
|
|
|
Порядок |
Размер |
FFT |
DFT |
максимальной |
|
|
|
погрешности |
16*16 |
0,14 |
0,27 |
10^(-12) |
64*64 |
0,32 |
741,66 |
10^(-11) |
256*256 |
5,12 |
>28000 |
10^(-10) |
1024*1024 |
278 |
>>100000 |
- |
Таблица 5.1 Сравнение времени выполнения и погрешности
Для размера 1024*1024 не удалось вычислить прямое обычно преобразование Фурье и в силу этого не была рассчитана разница, однако есть основания полагать, что она будет точно меньше 10^(-5).
На основании таблицы 5.1 постоим график наглядно демонстрирующий высочайшую эффективность быстрого алгоритма преобразования Фурье:
30000,00 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
25000,00 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
20000,00 |
|
|
|
|
|
|
|
|
|
|
|
|
FFT |
|
|
|
|
|
|
|
|
|
|
|
|
||
15000,00 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|||||
10000,00 |
|
|
|
|
|
|
|
|
|
|
|
|
DFT |
|
|
|
|
|
|
|
|
|
|
|
|
||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
5000,00 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
0,00 |
|
|
|
|
|
|
|
|
|
|
|
|
|
16 |
64 |
256 |
1024 |
|
|
|
|
|
|||||
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Рисунок 5.1 График зависимости времени выполнения алгоритмов от размера входного изображения
12
Приложение А. Листинг программы
Класс Algorithm.java
/*
*To change this template, choose Tools | Templates
*and open the template in the editor.
*/
package src.algorithm;
import src.ui.additional.ImageHelper;
import java.awt.*;
import java.util.HashMap; import java.util.Map;
/**
*Created by IntelliJ IDEA.
*User: buggy
*Date: 10.12.11
*Time: 13:06
*To change this template use File | Settings | File Templates. */
public class Algorithm {
public static final int SQUARE = 4; public static final int START_N = 16;
protected Map<Point, HyperComplex> lastResult;
public Map<Point, Integer> execute(Image image) {
Map<Point, Integer> startingMatrix = ImageHelper.grayImageAsMatrix(image);
int size = getMatrixDimension(startingMatrix);
Map<Point, Integer> permutedMatrix = permute(startingMatrix);
Map<Point, HyperComplex> xMap = extractXValues(permutedMatrix);
Map<Point, HyperComplex> transformed = xMap;
for (int n = START_N; n <= size; n *= SQUARE) { transformed = fourierTransform(transformed, n);
}
lastResult = transformed;
Map<Point, Integer> normalizedMatrix = normalize(transformed);
return normalizedMatrix;
}
protected Map<Point, Integer> normalize(Map<Point, HyperComplex> inputComplexMap) { Map<Point, Integer> result = new HashMap<Point, Integer>();
HyperComplex firstElement = inputComplexMap.entrySet().iterator().next().getValue();
HyperComplex minComplex = firstElement;
HyperComplex maxComplex = firstElement;
for (Map.Entry<Point, HyperComplex> entry : inputComplexMap.entrySet()) {
minComplex = HyperComplex.min(minComplex, entry.getValue());
maxComplex = HyperComplex.max(maxComplex, entry.getValue());
}
double min = minComplex.getABS();
double minMaxDiff = (maxComplex.getABS() - minComplex.getABS()) / min;
13
//double minMaxDiff = 20000;
//double min = 0;
System.out.println(minComplex.getABS());
System.out.println(maxComplex.getABS());
for (Point point : inputComplexMap.keySet()) { HyperComplex complex = inputComplexMap.get(point);
double x = complex.getABS();
Integer value = Math.min(255, Math.max(0, (int) (255 * (x - min) / minMaxDiff))); result.put(point, value);
}
return result;
}
protected Map<Point, HyperComplex> fourierTransform(Map<Point, HyperComplex> xMap, int n) { Map<Point, HyperComplex> result = new HashMap<Point, HyperComplex>();
int inputSize = getMatrixDimension(xMap);
int blockCount = n / SQUARE;
for (int startX = 0; startX < inputSize; startX += n) { for (int startY = 0; startY < inputSize; startY += n) {
for (int m1 = 0; m1 < blockCount; m1++) { for (int m2 = 0; m2 < blockCount; m2++) {
for (int k = 0; k < SQUARE; k++) { for (int l = 0; l < SQUARE; l++) {
HyperComplex xKL = countXkl(startX, startY, m1, m2, k, l, n, xMap);
int x = startX + m1 + k * blockCount; int y = startY + m2 + l * blockCount;
result.put(new Point(x, y), xKL);
}
}
}
}
}
}
return result;
}
/*
private void setBlockValues(int startX, int startY, int m1, int m2, HyperComplex xM1M2, int n, Map<Point, HyperComplex> mapToFill) {
for (int k = 0; k < SQUARE; k++) { for (int l = 0; l < SQUARE; l++) {
HyperComplex xKL = xM1M2.mult(HyperComplex.i(k)).mult(HyperComplex.j(l));
int x = startX + m1 + k * n / SQUARE; int y = startY + m2 + l * n / SQUARE;
mapToFill.put(new Point(x, y), xKL);
}
}
}*/
protected Map<Point, Integer> inverseXY(Map<Point, Integer> matrixToInverse) { Map<Point, Integer> result = new HashMap<Point, Integer>();
14
for (Point point : matrixToInverse.keySet()) { Integer value = matrixToInverse.get(point);
result.put(new Point(point.y, point.x), value);
}
return result;
}
private HyperComplex countXab(int startX, int startY, int m1, int m2, int a, int b, int n, Map<Point, HyperComplex> xMap) { HyperComplex summ = HyperComplex.NULL;
int nDiv4 = n / SQUARE;
HyperComplex omega1 = countOmega1(nDiv4);
HyperComplex omega2 = countOmega2(nDiv4);
for (int n1 = 0; n1 < nDiv4; n1++) { for (int n2 = 0; n2 < nDiv4; n2++) {
HyperComplex x = xMap.get(new Point(startX + SQUARE * n1 + a, startY + SQUARE * n2 + b));
summ = summ.add(omega1.toPower(m1 * n1).mult(x).mult(omega2.toPower(m2 * n2)));
}
}
return summ;
}
private HyperComplex countCorrectXab(int startX, int startY, int m1, int m2, int a, int b, int n, Map<Point, HyperComplex> xMap) {
HyperComplex x = xMap.get(new Point(startX + a * n / SQUARE + m1, startY + b * n / SQUARE + m2));
return x;
}
private HyperComplex countXkl(int startX, int startY, int m1, int m2, int k, int l, int n, Map<Point, HyperComplex> xMap) { HyperComplex summ = HyperComplex.NULL;
HyperComplex omega1 = countOmega1(n);
HyperComplex omega2 = countOmega2(n);
for (int a = 0; a < SQUARE; a++) { for (int b = 0; b < SQUARE; b++) {
HyperComplex xab = countCorrectXab(startX, startY, m1, m2, a, b, n, xMap);
HyperComplex i = HyperComplex.i(a * k);
HyperComplex j = HyperComplex.j(b * l);
HyperComplex omega1Powered = omega1.toPower(a * m1);
HyperComplex omega2Powered = omega2.toPower(b * m2);
summ = summ.add(xab.mult(i).mult(j).mult(omega1Powered).mult(omega2Powered));
}
}
return summ;
}
protected Map<Point, HyperComplex> extractXValues(Map<Point, Integer> input) { int size = getMatrixDimension(input);
Map<Point, HyperComplex> result = new HashMap<Point, HyperComplex>();
for (int newX = 0; newX < size; newX += SQUARE) { for (int newY = 0; newY < size; newY += SQUARE) {
15
for (int m1 = 0; m1 < SQUARE; m1++) { for (int m2 = 0; m2 < SQUARE; m2++) {
result.put(new Point(newX + m1, newY + m2), countX(m1, m2, newX, newY, input));
}
}
}
}
return result;
}
private HyperComplex countX(int m1, int m2, int xOffset, int yOffset, Map<Point, Integer> input) { HyperComplex sum = HyperComplex.NULL;
for (int n1 = 0; n1 < SQUARE; n1++) { for (int n2 = 0; n2 < SQUARE; n2++) {
HyperComplex xN1N2 = new HyperComplex(input.get(new Point(n1 + xOffset, n2 + yOffset)), 0, 0, 0);
sum = sum.add(xN1N2.mult(HyperComplex.i(m1 * n1).mult(HyperComplex.j(m2 * n2))));
}
}
return sum;
}
public Map<Point, Integer> permute(Map<Point, Integer> input) { Map<Point, Integer> result = new HashMap<Point, Integer>();
int size = getMatrixDimension(input); for (int i = 0; i < size; i++) {
int permutedRow = getPermutedPosition(i, size);
for (int j = 0; j < size; j++) {
int value = input.get(new Point(permutedRow, getPermutedPosition(j, size)));
result.put(new Point(i, j), value);
}
}
return result;
}
protected int getMatrixDimension(Map<?, ?> matrix) { return (int) Math.sqrt(matrix.size());
}
private static int getPermutedPosition(int position, int size) { int halfSize = size / 4;
int reducedPosition = position / 4;
int offset = (position % 4) * halfSize;
int permutedPosition = (halfSize == 1) ? 0 : getPermutedPosition(reducedPosition, halfSize);
return offset + permutedPosition;
}
protected static HyperComplex countOmega1(int n) { double twoPi = 2 * Math.PI;
double a = Math.cos(twoPi / n); double b = Math.sin(twoPi / n);
return new HyperComplex(a, b, 0, 0);
}
16
protected static HyperComplex countOmega2(int n) { double twoPi = 2 * Math.PI;
double a = Math.cos(twoPi / n); double c = Math.sin(twoPi / n);
return new HyperComplex(a, 0, c, 0);
}
public Map<Point, HyperComplex> getLastResult() { return lastResult;
}
}
17
класс EasyAlgorithm.java
package src.algorithm;
import java.awt.*;
import java.util.HashMap; import java.util.Map;
import src.ui.additional.ImageHelper;
/**
*Created by IntelliJ IDEA.
*User: buggy
*Date: 16.12.11
*Time: 21:59
*To change this template use File | Settings | File Templates. */
public class EasyAlgorithm extends Algorithm {
public EasyAlgorithm() { super();
}
@Override
public Map<Point, Integer> execute(Image image) {
Map<Point, Integer> startingMatrix = ImageHelper.grayImageAsMatrix(image);
int size = getMatrixDimension(startingMatrix);
Map<Point, HyperComplex> simpleDFT = getSimpleDFT(startingMatrix);
lastResult = simpleDFT; return normalize(simpleDFT);
}
private Map<Point, HyperComplex> getSimpleDFT(Map<Point, Integer> xMap) { int size = getMatrixDimension(xMap);
HyperComplex omega1 = countOmega1(size);
HyperComplex omega2 = countOmega2(size);
Map<Point, HyperComplex> result = new HashMap<Point, HyperComplex>(); Map<Point, Double> diff = new HashMap<Point, Double>();
for (int m1 = 0; m1 < size; m1++) { for (int m2 = 0; m2 < size; m2++) {
HyperComplex summ = HyperComplex.NULL;
for (int n1 = 0; n1 < size; n1++) { for (int n2 = 0; n2 < size; n2++) {
HyperComplex x = new HyperComplex(xMap.get(new Point(n1, n2)), 0, 0, 0);
HyperComplex omega1Powered = omega1.toPower((m1 * n1));
HyperComplex omega2Powered = omega2.toPower((m2 * n2));
summ = summ.add(x.mult(omega1Powered).mult(omega2Powered));
}
}
result.put(new Point(m1, m2), summ);
}
}
return result;
}
}
18
класс HyperComplex.java
/*
*To change this template, choose Tools | Templates
*and open the template in the editor.
*/
package src.algorithm;
/**
*Created by IntelliJ IDEA.
*User: buggy
*Date: 10.12.11
*Time: 14:52
*To change this template use File | Settings | File Templates. */
public class HyperComplex implements Cloneable {
public static final HyperComplex ONE = new HyperComplex(1, 0, 0, 0); public static final HyperComplex NULL = new HyperComplex(0, 0, 0, 0); private double value;
private double im1; private double im2; private double im3;
public static HyperComplex i(int power) { HyperComplex result = new HyperComplex(0, 1, 0, 0); result = result.toPower(power);
return result;
}
public static HyperComplex j(int power) { HyperComplex result = new HyperComplex(0, 0, 1, 0); result = result.toPower(power);
return result;
}
public HyperComplex(double a, double b, double c, double d) { this.value = a;
this.im1 = b; this.im2 = c; this.im3 = d;
}
public HyperComplex add(HyperComplex summand) { double a = this.value + summand.value;
double b = this.im1 + summand.im1; double c = this.im2 + summand.im2; double d = this.im3 + summand.im3;
return new HyperComplex(a, b, c, d);
}
public HyperComplex mult(HyperComplex multiplier) { double a = this.value;
double a1 = multiplier.value;
double b = this.im1; double b1 = multiplier.im1;
double c = this.im2; double c1 = multiplier.im2;
double d = this.im3; double d1 = multiplier.im3;
double value = a * a1 - b * b1 - c * c1 + d * d1;
19
double im1 = a1 * b + a * b1 - d * c1 - c * d1; double im2 = a1 * c - d * b1 + a * c1 - b * d1; double im3 = a1 * d + c * b1 + b * c1 + a * d1;
return new HyperComplex(value, im1, im2, im3);
}
public HyperComplex toPower(int power) {
HyperComplex predefined = predefinedPowerValue(power); if (predefined != null) {
return predefined;
}
HyperComplex result = ONE; for (int i = 0; i < power; i++) { result = result.mult(this);
}
return result;
}
private HyperComplex predefinedPowerValue(int power) { if (power < 0) {
throw new IllegalStateException("Power cannot be negative");
}
if (power == 0) { return ONE;
}
if (power == 1) {
return new HyperComplex(this.value, this.im1, this.im2, this.im3);
}
return null;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
boolean hasPrevious = false; if (value != 0) {
sb.append(value); hasPrevious = true;
}
if (im1 != 0) {
appendUnit(im1, sb, hasPrevious, "i"); hasPrevious = true;
}
if (im2 != 0) {
appendUnit(im2, sb, hasPrevious, "j"); hasPrevious = true;
}
if (im3 != 0) {
appendUnit(im3, sb, hasPrevious, "ij");
}
return sb.toString();
}
private static void appendUnit(double unitVal, StringBuilder sb, boolean withSign, String unit) { if (withSign) {
String sign = unitVal < 0 ? " - " : " + ";
20
