Добавил:
Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:

Desktop / КА отчет

.pdf
Скачиваний:
32
Добавлен:
16.03.2015
Размер:
1 Мб
Скачать
☆

4 Тестирование программы

Программа прошла ручное тестирование. Все ошибки, выявленные в ходе тестирования, были устранены. В приложении 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

Соседние файлы в папке Desktop