public void FWT2DTest()
{
double[,] original =
{
{ 5, 6, 1, 2 },
{ 4, 2, 5, 5 },
{ 3, 1, 7, 1 },
{ 6, 3, 5, 1 }
};
double[,] data = (double[, ])original.Clone();
Haar.FWT(data, 1);
double[,] expected =
{
{ 6.3640, 5.6569, 4.2426, 4.9497 },
{ 6.3640, 2.8284, 8.4853, 1.4142 },
{ 0.7071, 2.8284, -2.8284, -2.1213 },
{ -2.1213, -1.4142, 1.4142, 0 }
};
Haar.IWT(data, 1);
Assert.IsTrue(Matrix.IsEqual(data, original, 0.0001));
}
public void FWT2DTest2()
{
int levels = 2;
double[,] original =
{
{ 5, 6, 1, 2 },
{ 4, 2, 5, 5 },
{ 3, 1, 7, 1 },
{ 6, 3, 5, 1 }
};
double[,] data = (double[, ])original.Clone();
Haar.FWT(data, levels);
double[,] expected =
{
{ 3.5625, 0.1875, 0.25, -0.25 },
{ 0.1875, 0.3125, 1.25, 2.5 },
{ 1.25, -1.75, -0.75, -0.25 },
{ -1.25, 0.5, -0.25, 0.5 }
};
string dataStr = data.ToString(CSharpMatrixFormatProvider.InvariantCulture);
Assert.IsTrue(Matrix.IsEqual(expected, data, 1e-5));
Haar.IWT(data, levels);
Assert.IsTrue(Matrix.IsEqual(data, original, 0.0001));
}
//Метод для реинициализации трекера, принимает в себя тип детектирования и изображение
//Возвращает инициализированный трекер
public static MultiTracker Reinit_Tracker(InitTypes type, Mat frame)
{
//Результаты детектирования для иницилазиции KFC трекеров
List <Rectangle> Result = new List <Rectangle>();
//Детектирование с помощью каскадов Хаара
if (type == InitTypes.Haar)
{
var Rects = Haar.DetectMultiScale(frame, HScaleFactor, HMinNeighbors, HMinSize, HMaxSize);
foreach (var rect in Rects)
{
if (rect != null)
{
Result.Add(rect);
}
}
}
//Детектирования с помощью Хог дескриптора
else
{
var RowRects = Hog.DetectMultiScale(frame, 0, HogWinStride, scale: HogScaleFactor);
foreach (var rowRect in RowRects)
{
Result.Add(rowRect.Rect);
}
}
//Инициализация KCF трекерами
var TTracker = new MultiTracker();
foreach (var rect in Result)
{
TTracker.Add(new TrackerKCF(), frame, rect);
}
return(TTracker);
}
public static void TestHaar2D()
{
Console.WriteLine();
Console.WriteLine("The 2D Haar Transform as tensor (I.e. all iterations)");
double[][] mat = Get2DTestData();
Haar.Haar2D(mat, 4, 4);
var result = new Matrix(mat);
result.PrintPretty();
}
public static void TestHaar1D()
{
Console.WriteLine();
Console.WriteLine("The 1D Haar Transform as tensor (I.e. all iterations)");
double[] data = Get1DTestData();
Haar.Haar1D(data, 8);
IOUtils.Print(Console.Out, data);
// check if it's the same as
double[] result = Get1DResultData();
Assert.That(data, Is.EqualTo(result).AsCollection.Within(0.001), "fail at [0]");
}
public void IWTTest()
{
double[] original = { 1, 2, 3, 4 };
double[] data = { 1, 2, 3, 4 };
double[] expected = { 2.1213, 4.9497, -0.7071, -0.7071 };
Haar.FWT(data);
var d = data.Multiply(Constants.Sqrt2);
Assert.IsTrue(Matrix.IsEqual(expected, d, 0.001));
Haar.IWT(data);
Assert.IsTrue(Matrix.IsEqual(original, data, 0.001));
}
public static Matrix GetWaveletTransformedMatrix(double[][] image, WaveletMethod waveletMethod)
{
int width = image[0].Length;
int height = image.Length;
Matrix dwtMatrix = null;
Stopwatch stopWatch = Stopwatch.StartNew();
long startS = stopWatch.ElapsedTicks;
switch (waveletMethod)
{
case WaveletMethod.Haar:
Haar.Haar2D(image, height, width);
dwtMatrix = new Matrix(image);
break;
case WaveletMethod.HaarTransformTensor: // This is using the tensor product layout
dwtMatrix = WaveletUtils.HaarWaveletTransform2D(image);
break;
case WaveletMethod.HaarWaveletDecompositionTensor: // This is using the tensor product layout
var haar = new StandardHaarWaveletDecomposition();
haar.DecomposeImageInPlace(image);
dwtMatrix = new Matrix(image);
break;
case WaveletMethod.NonStandardHaarWaveletDecomposition: // JPEG 2000
var haarNonStandard = new NonStandardHaarWaveletDecomposition();
haarNonStandard.DecomposeImageInPlace(image);
dwtMatrix = new Matrix(image);
break;
case WaveletMethod.HaarCSharp:
ForwardWaveletTransform.Transform2D(image, false, 2);
dwtMatrix = new Matrix(image);
break;
case WaveletMethod.HaarWaveletCompress:
int lastHeight = 0;
int lastWidth = 0;
WaveletCompress.HaarTransform2D(image, 10000, out lastHeight, out lastWidth);
dwtMatrix = new Matrix(image);
break;
default:
break;
}
long endS = stopWatch.ElapsedTicks;
Console.WriteLine("WaveletMethod: {0} Time in ticks: {1}", Enum.GetName(typeof(WaveletMethod), waveletMethod), (endS - startS));
// increase all values
const int mul = 50;
double[][] haarImageNormalized5k = dwtMatrix.MatrixData.Select(i => i.Select(j => j * mul).ToArray()).ToArray();
// convert to byte values (0 - 255)
// duplicate the octave/ matlab method uint8
var uint8 = new double[haarImageNormalized5k.Length][];
for (int i = 0; i < haarImageNormalized5k.Length; i++)
{
uint8[i] = new double[haarImageNormalized5k.Length];
for (int j = 0; j < haarImageNormalized5k[i].Length; j++)
{
double v = haarImageNormalized5k[i][j];
if (v > 255)
{
uint8[i][j] = 255;
}
else if (v < 0)
{
uint8[i][j] = 0;
}
else
{
uint8[i][j] = (byte)haarImageNormalized5k[i][j];
}
}
}
var uint8Matrix = new Matrix(uint8);
return(uint8Matrix);
}
private static void test01()
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests HAAR_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 06 March 2014
//
// Author:
//
// John Burkardt
//
{
int i;
Console.WriteLine("");
Console.WriteLine("TEST01");
Console.WriteLine(" HAAR_1D computes the Haar transform of a vector.");
//
// Random data.
//
int n = 16;
int seed = 123456789;
double[] u = UniformRNG.r8vec_uniform_01_new(n, ref seed);
double[] v = typeMethods.r8vec_copy_new(n, u);
Haar.haar_1d(n, ref v);
double[] w = typeMethods.r8vec_copy_new(n, v);
Haar.haar_1d_inverse(n, ref w);
Console.WriteLine("");
Console.WriteLine(" i U(i) H(U)(i) Hinv(H(U))(i)");
Console.WriteLine("");
for (i = 0; i < n; i++)
{
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(2)
+ " " + u[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + v[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + w[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
//
// Constant signal.
//
n = 8;
u = typeMethods.r8vec_ones_new(n);
v = typeMethods.r8vec_copy_new(n, u);
Haar.haar_1d(n, ref v);
w = typeMethods.r8vec_copy_new(n, v);
Haar.haar_1d_inverse(n, ref w);
Console.WriteLine("");
Console.WriteLine(" i U(i) H(U)(i) Hinv(H(U))(i)");
Console.WriteLine("");
for (i = 0; i < n; i++)
{
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(2)
+ " " + u[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + v[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + w[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
//
// Linear signal.
//
n = 16;
u = typeMethods.r8vec_linspace_new(n, 1.0, n);
v = typeMethods.r8vec_copy_new(n, u);
Haar.haar_1d(n, ref v);
w = typeMethods.r8vec_copy_new(n, v);
Haar.haar_1d_inverse(n, ref w);
Console.WriteLine("");
Console.WriteLine(" i U(i) H(U)(i) Hinv(H(U))(i)");
Console.WriteLine("");
for (i = 0; i < n; i++)
{
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(2)
+ " " + u[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + v[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + w[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
//
// Quadratic data.
//
n = 8;
u = new double[n];
u[0] = 25.0;
u[1] = 16.0;
u[2] = 9.0;
u[3] = 4.0;
u[4] = 1.0;
u[5] = 0.0;
u[6] = 1.0;
u[7] = 4.0;
v = typeMethods.r8vec_copy_new(n, u);
Haar.haar_1d(n, ref v);
w = typeMethods.r8vec_copy_new(n, v);
Haar.haar_1d_inverse(n, ref w);
Console.WriteLine("");
Console.WriteLine(" i U(i) H(U)(i) Hinv(H(U))(i)");
Console.WriteLine("");
for (i = 0; i < n; i++)
{
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(2)
+ " " + u[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + v[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + w[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
//
// N not a power of 2.
//
n = 99;
seed = 123456789;
u = UniformRNG.r8vec_uniform_01_new(n, ref seed);
v = typeMethods.r8vec_copy_new(n, u);
Haar.haar_1d(n, ref v);
w = typeMethods.r8vec_copy_new(n, v);
Haar.haar_1d_inverse(n, ref w);
double err = typeMethods.r8vec_diff_norm(n, u, w);
Console.WriteLine("");
Console.WriteLine(" For N = " + n
+ ", ||u-Haar.haar_1d_inverse(Haar.haar_1d(u))|| = " + err + "");
}
private static void test02()
//****************************************************************************80
//
// Purpose:
//
// TEST02 tests HAAR_2D and HAAR_2D_INVERSE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 06 March 2014
//
// Author:
//
// John Burkardt
//
{
int m = 16;
int n = 4;
Console.WriteLine("");
Console.WriteLine("TEST02");
Console.WriteLine(" HAAR_2D computes the Haar transform of an array.");
Console.WriteLine(" HAAR_2D_INVERSE inverts the transform.");
//
// Demonstrate successful inversion.
//
int seed = 123456789;
double[] u = UniformRNG.r8mat_uniform_01_new(m, n, ref seed);
typeMethods.r8mat_print(m, n, u, " Input array U:");
double[] v = typeMethods.r8mat_copy_new(m, n, u);
Haar.haar_2d(m, n, ref v);
typeMethods.r8mat_print(m, n, v, " Transformed array V:");
double[] w = typeMethods.r8mat_copy_new(m, n, v);
Haar.haar_2d_inverse(m, n, ref w);
typeMethods.r8mat_print(m, n, w, " Recovered array W:");
//
// M, N not powers of 2.
//
m = 37;
n = 53;
seed = 123456789;
u = UniformRNG.r8mat_uniform_01_new(m, n, ref seed);
v = typeMethods.r8mat_copy_new(m, n, u);
Haar.haar_2d(m, n, ref v);
w = typeMethods.r8mat_copy_new(m, n, v);
Haar.haar_2d_inverse(m, n, ref w);
double err = typeMethods.r8mat_dif_fro(m, n, u, w);
Console.WriteLine("");
Console.WriteLine(" M = " + m
+ ", N = " + n
+ ", ||Haar.haar_2d_inverse(Haar.haar_2d(u))-u|| = " + err + "");
}
private static void test03()
//****************************************************************************80
//
// Purpose:
//
// TEST03 tests HAAR, HAARIN and HNORM.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 16 March 2011
//
// Author:
//
// John Burkardt
//
{
int j;
const int n = 16;
Console.WriteLine("");
Console.WriteLine("TEST03");
Console.WriteLine(" HAAR computes a Haar transform.");
Console.WriteLine(" HNORM normalizes the transformed data.");
Console.WriteLine(" HAARIN computes an inverse Haar transform.");
for (j = 1; j <= 2; j++)
{
double[] w;
int i;
switch (j)
{
case 1:
int seed = 123456789;
w = UniformRNG.r8vec_uniform_01_new(n, ref seed);
break;
default:
{
w = new double[n];
for (i = 0; i < n; i++)
{
w[i] = i + 1;
}
break;
}
}
double[] x = typeMethods.r8vec_copy_new(n, w);
Haar.haar(n, ref w);
double[] y = typeMethods.r8vec_copy_new(n, w);
Haar.hnorm(n, ref w);
double[] z = typeMethods.r8vec_copy_new(n, w);
Haar.haarin(n, ref w);
Console.WriteLine("");
Console.WriteLine(" I X(I) Y=HAAR(X) Z=HNORM(Y) W=HAARIN(Z)");
Console.WriteLine("");
for (i = 0; i < n; i++)
{
Console.WriteLine(" " + i.ToString(CultureInfo.InvariantCulture).PadLeft(2)
+ " " + x[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + y[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + z[i].ToString(CultureInfo.InvariantCulture).PadLeft(10)
+ " " + w[i].ToString(CultureInfo.InvariantCulture).PadLeft(10) + "");
}
}
}
