private void TransformMethod()
{
if (SelectedSignal != null)
{
SampledSignal signal = new SampledSignal();
signal.PointsY = SelectedSignal.PointsY;
signal.Name = $"{SelectedSignal.Name} {SelectedTransform}";
Stopwatch timer = new Stopwatch();
timer.Start();
switch (SelectedTransform.Substring(1, 4))
{
case "F1.1":
signal.ComplexPoints = FourierTransform.Transform(signal.PointsY);
break;
case "F1.2":
FastFourierTransform fourierTransform = new FastFourierTransform();
signal.ComplexPoints = fourierTransform.Transform(signal.PointsY);
break;
case "F1.3":
signal.ComplexPoints = WaveletTransform.Transform(signal.PointsY);
break;
}
timer.Stop();
Time = timer.ElapsedMilliseconds;
SignalCreator.AddSignal(signal);
}
}
private void btnBackward_Click(object sender, EventArgs e)
{
// Create inverse transform
WaveletTransform wt = new WaveletTransform(wavelet, true);
// Apply inverse transform
pictureBox.Image = wt.Apply(transformed);
}
private void BackwardButtonOnClick(object sender, EventArgs eventArgs)
{
// Create inverse transform
var wt = new WaveletTransform(this.wavelet, true);
// Apply inverse transform
this.transformImage.SetImageBitmap((Android.Graphics.Bitmap)wt.Apply(this.transformed));
}
/// <summary>
/// Applies wavelet transform filter (Accord.NET).
/// </summary>
/// <param name="img">Image.</param>
/// <param name="wavelet">A wavelet function.</param>
/// <param name="backward">True to perform backward transform, false otherwise.</param>
/// <returns>Transformed image.</returns>
private static Image <TColor, TDepth> WaveletTransform <TColor, TDepth>(this Image <TColor, TDepth> img, IWavelet wavelet, bool backward)
where TColor : IColor
where TDepth : struct
{
WaveletTransform wt = new WaveletTransform(wavelet, backward);
return(img.ApplyFilter((BaseFilter)wt));
}
public static InverseMultipleComponentTransformer Create(WaveletTransform waveletTransformUsed, ArithmeticType arithmeticType)
{
if (waveletTransformUsed == WaveletTransform.Reversible_5_3)
{
return(arithmeticType switch
{
ArithmeticType.Int32 => new ReversibleInverseMultipleComponentTransformer(),
_ => throw NotSupported(arithmeticType)
});
public void wavletHaartInverseSoft(double[] w)
{
deNoisedSignalSoft = new double[w.Length];
Array.Copy(w, 0, deNoisedSignalSoft, 0, w.Length);
IWavelet wavelet = new Accord.Math.Wavelets.Haar(m);
WaveletTransform target = new WaveletTransform(wavelet);
wavelet.Backward(deNoisedSignalSoft);
}
public void wavletHaarForward()
{
wavlet = new double[n];
dij = new double[n / 2];
Array.Copy(dataForExamination, 0, wavlet, 0, dataForExamination.Length);
IWavelet wavelet = new Accord.Math.Wavelets.Haar(m);
WaveletTransform target = new WaveletTransform(wavelet);
wavelet.Forward(wavlet);
Array.Copy(wavlet, n / 2, dij, 0, dij.Length / 2);
}
public async Task <List <AnalyzeResult> > Analyze(List <LotteryRecord> records, int period, int variableTwo)
{
return(await Task.Run(() =>
{
records = records.OrderByDescending(r => r.ID).Take(period).OrderBy(o => o.ID).ToList();
var result = new List <AnalyzeResult>();
var dataMatrix = new Matrix(new double[, ] {
{ 1, 0 }, { 0, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { 0, 0 }, { 1, 0 }, { 0, 0 }
});
var transform = new WaveletTransform(new HaarLift(), 1);
dataMatrix = transform.DoForward(dataMatrix);
return result;
}));
}
static void ApplyWavelet()
{
int times = 7;
string[] images = Directory.GetFiles(@"..\..\..\TestHaarCSharp\Resources_Noisy\", "*", SearchOption.AllDirectories);
Parallel.ForEach(images, (i) =>
{
Bitmap initial = new Bitmap(Image.FromFile(i));
//var res = AddNoise(initial, 50);
//res.Save($@"..\..\..\TestHaarCSharp\Resources_noisy\{Path.GetFileName(i)}", res.RawFormat);
Bitmap forward = new Bitmap(initial);
var channels = ColorChannels.CreateColorChannels(initial.Width, initial.Height);
var transform = WaveletTransform.CreateTransform(true, times);
var imageProcessor = new ImageProcessor(channels, transform);
imageProcessor.ApplyTransform(forward);
string newPath = Path.Combine(@"..\..\..\TestHaarCSharp\Forward_Noisy", Path.GetFileName(i));
string dirName = Path.GetDirectoryName(newPath);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
forward.Save(newPath, initial.RawFormat);
Bitmap inverse = new Bitmap(forward);
transform = WaveletTransform.CreateTransform(false, times);
imageProcessor = new ImageProcessor(channels, transform);
imageProcessor.ApplyTransform(inverse);
var rmse = GetRMSE(initial, inverse);
newPath = Path.Combine(@"..\..\..\TestHaarCSharp\Inverse_Noisy",
$"{Path.GetFileNameWithoutExtension(i)}_{rmse.ToString("#.##")}{Path.GetExtension(i)}");
dirName = Path.GetDirectoryName(newPath);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
inverse.Save(newPath, inverse.RawFormat);
});
}
private void DB6(object sender, RoutedEventArgs e)
{
var waveletTransformationOutput = WaveletTransform.WaveletTransformation(Signal);
var output = new List <Value>();
for (int i = 0; i < waveletTransformationOutput.Count(); i++)
{
var value = new Value
{
X = new Complex(i, 0),
Y = new Complex(waveletTransformationOutput[i].Real, 0)
};
output.Add(value);
}
Signal = DiscreteSignal.ForParameters("DB6", CPS.Signal.SignalType.CONTINUOUS, 1, output);
ChartWrapper.SetSignal(SignalSlot, Signal);
ChartWrapper.Replot();
}
private Bitmap ApplyHaarTransform(bool forward, bool safe, int iterations, Bitmap bmp)
{
var maxScale = WaveletTransform.GetMaxScale(bmp.Width, bmp.Height);
if (iterations < 1 || iterations > maxScale)
{
MessageBox.Show(string.Format("Iteration must be Integer from 1 to {0}", maxScale));
return(new Bitmap(bmp.Width, bmp.Height));
}
var channels = ColorChannels.CreateColorChannels(safe, bmp.Width, bmp.Height);
var transform = WaveletTransform.CreateTransform(forward, iterations);
var imageProcessor = new ImageProcessor(channels, transform);
imageProcessor.ApplyTransform(bmp);
return(bmp);
}
private void btnForward_Click(object sender, EventArgs e)
{
if ((string)cbWavelet.SelectedItem == "Haar")
{
wavelet = new Haar((int)numIterations.Value);
}
else
{
wavelet = new CDF97((int)numIterations.Value);
}
// Create forward transform
WaveletTransform wt = new WaveletTransform(wavelet);
// Apply forward transform
transformed = wt.Apply(lenna);
pictureBox.Image = transformed;
}
public void WaveletTransformConstructorTest()
{
// Start with a grayscale image
Bitmap src = Properties.Resources.lena512;
// Create a wavelet filter
IWavelet wavelet = new Accord.Math.Wavelets.Haar(2);
WaveletTransform target = new WaveletTransform(wavelet);
// Apply the transformation
Bitmap dst = target.Apply(src);
// Revert the transformation
target.Backward = true;
Bitmap org = target.Apply(dst);
double[,] actual = org.ToDoubleMatrix(0);
double[,] expected = src.ToDoubleMatrix(0);
Assert.IsTrue(actual.IsEqual(expected, 0.102));
}
public void WaveletTransformConstructorTest()
{
// Start with a grayscale image
Bitmap src = Accord.Imaging.Image.Clone(Resources.lena512);
// Create a wavelet filter
IWavelet wavelet = new Accord.Math.Wavelets.Haar(2);
WaveletTransform target = new WaveletTransform(wavelet);
// Apply the transformation
Bitmap dst = target.Apply(src);
// Revert the transformation
target.Backward = true;
Bitmap org = target.Apply(dst);
double[,] actual; new ImageToMatrix().Convert(org, out actual);
double[,] expected; new ImageToMatrix().Convert(src, out expected);
Assert.IsTrue(actual.IsEqual(expected, atol: 0.102));
}
public void Compute()
{
Stopwatch timer = new Stopwatch();
List <Complex> complex = new List <Complex>();
timer.Start();
string chartCase = SelectedOutputChart.Substring(1, 2);
switch (SelectedOperation.Substring(1, 4))
{
case "F1.1":
complex = FourierTransform.Transform(SelectedSignal1Tab.TabContent.Data.Samples);
break;
case "F1.2":
FastFourierTransform f = new FastFourierTransform();
complex = f.Transform(SelectedSignal1Tab.TabContent.Data.Samples);
break;
case "F1.3":
complex = WaveletTransform.Transform(SelectedSignal1Tab.TabContent.Data.Samples);
break;
}
timer.Stop();
var time = timer.ElapsedMilliseconds;
if (chartCase.Contains("W1"))
{
ComplexChartsW1 window = new ComplexChartsW1(complex);
window.Show();
MessageBox.Show("Czas obliczeń: " + time.ToString() + " ms", "Czas", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
ComplexChartsW2 window = new ComplexChartsW2(complex);
window.Show();
MessageBox.Show("Czas obliczeń: " + time.ToString() + " ms", "Czas", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
private void ForwardButtonOnClick(object sender, System.EventArgs e)
{
var selectedTransform = (string)this.transformsSpinner.SelectedItem;
var numIterations = Convert.ToInt32((string)this.iterationsSpinner.SelectedItem);
if (selectedTransform == "Haar")
{
this.wavelet = new Haar(numIterations);
}
else
{
this.wavelet = new CDF97(numIterations);
}
// Create forward transform
var wt = new WaveletTransform(this.wavelet);
// Apply forward transform
this.transformed = wt.Apply(this.lenna);
this.transformImage.SetImageBitmap((Android.Graphics.Bitmap) this.transformed);
}
//------------------------------------------------Вейвлет-----------------------------------------------------------------------
private void button7_Click(object sender, EventArgs e)
{
//---------------Вейвлет----------------------------------
double[,] frame_mass = new double[frames, 512]; //массив всех фреймов по 512
set_frames(frame_mass);
Hamming_window(frame_mass, frames);
var dataMatrix = new Matrix(frame_mass);
var transform = new WaveletTransform(new HaarLift(), 2);
dataMatrix = transform.DoForward(dataMatrix);
string wavelet_str = dataMatrix.ToString();
double[] wavelet_mass = wavelet_str.Split(new char[] { ' ', '\n' }, StringSplitOptions.RemoveEmptyEntries).Select(n => double.Parse(n)).ToArray();
pictureBox4.Width = wavelet_mass.Length; //подгоняем ширину графика под кол-во данных
Bitmap bmp = new Bitmap(pictureBox4.Width, pictureBox4.Height); //создаём в оперативной памяти новый рисунок
Graphics gr = Graphics.FromImage(bmp);
Pen VioletPen = new Pen(Color.BlueViolet, 1);
Pen RedPen = new Pen(Color.Red, 1);
for (int i = 0; i < wavelet_mass.Length; i++)
{
gr.DrawLine(VioletPen, i, bmp.Height, i, bmp.Height - bmp.Height * Convert.ToInt32(wavelet_mass[i]) / 10000);
}
for (int i = 0; i < wavelet_mass.Length; i = i + 256)
{
gr.DrawLine(RedPen, new Point(i, 0), new Point(i, 200));
}
pictureBox4.Image = bmp;
}
public static InverseDiscreteWaveletTransformer Create(WaveletTransform waveletTransform, int componentSamplePrecision)
{
ThrowIf(componentSamplePrecision > 16);
if (waveletTransform == WaveletTransform.Reversible_5_3)
{
return(new ReversibleInverseDiscreteWaveletTransformer());
}
else if (waveletTransform == WaveletTransform.Irreversible_9_7)
{
if (componentSamplePrecision <= 8)
{
return(new SinglePrecisionIrreversibleInverseDiscreteWaveletTransformer());
}
else
{
return(new DoublePrecisionIrreversibleInverseDiscreteWaveletTransformer());
}
}
else
{
throw NotSupported(waveletTransform);
}
}
public void Example1()
{
Bitmap image = Accord.Imaging.Image.Clone(Properties.Resources.lena512);
// Create a new Haar Wavelet transform filter
var wavelet = new WaveletTransform(new Haar(1));
// Apply the Wavelet transformation
Bitmap result = wavelet.Apply(image);
// Show on the screen
//ImageBox.Show(result);
Assert.IsNotNull(result);
// Extract only one of the resulting images
var crop = new Crop(new Rectangle(0, 0,
image.Width / 2, image.Height / 2));
Bitmap quarter = crop.Apply(result);
// Show on the screen
//ImageBox.Show(quarter);
Assert.IsNotNull(quarter);
}
/// <summary>
/// not finished.
/// TODO: pywt.wavedec2 is too complicated.
/// </summary>
/// <param name="bmp"></param>
/// <param name="hash_size">@hash_size must be a power of 2 and less than @image_scale.</param>
/// <param name="image_scale">@image_scale must be power of 2 and less than image size. By default is equal to max power of 2 for an input image.</param>
/// <param name="mode">'haar' - Haar wavelets, by default; 'db4' - Daubechies wavelets</param>
/// <param name="remove_max_haar_ll">whether remove the lowest low level (LL) frequency using Haar wavelet.</param>
public static void WHash(SKBitmap bmp, int hash_size = 8, int image_scale = 16, string mode = "haar", bool remove_max_haar_ll = true)
{
// assert image_scale & (image_scale - 1) == 0, "image_scale is not power of 2"
if ((image_scale & (image_scale - 1)) == 0)
{
throw new Exception("image_scale is not power of 2");
}
// image_scale = 2**int(numpy.log2(min(image.size)))
// image.size: im.size ⇒ (width, height)
// Image size, in pixels.The size is given as a 2 - tuple( width, height ).
// ** 幂 - 返回x的y次幂
int minWH = System.Math.Min(bmp.Width, bmp.Height);
int b = Accord.Math.Tools.Log2(minWH);
image_scale = (int)System.Math.Pow(2, b);
// ll_max_level = int(numpy.log2(image_scale))
int ll_max_level = Accord.Math.Tools.Log2(image_scale);
// assert hash_size & (hash_size-1) == 0, "hash_size is not power of 2"
if ((hash_size & (hash_size - 1)) == 0)
{
throw new Exception("hash_size is not power of 2");
}
// level = int(numpy.log2(hash_size))
int level = (int)(System.Math.Log(hash_size, 2));
//assert level <= ll_max_level, "hash_size in a wrong range"
if (level <= ll_max_level)
{
throw new Exception("hash_size in a wrong range");
}
// dwt_level = ll_max_level - level
int dwt_level = ll_max_level - level;
// image = image.convert("L").resize((image_scale, image_scale), Image.ANTIALIAS)
// L (8-bit pixels, black and white)
// im.resize(size) ⇒ image
// Returns a resized copy of an image. The size argument gives the requested size in pixels, as a 2-tuple: (width, height).
var imgLMode = SkiaSharpUtility.ConvertToLMode(bmp);
var imgResized = SkiaSharpUtility.ResizeBitmap(imgLMode, image_scale, image_scale);
// pixels = numpy.array( image.getdata(), dtype = numpy.float ).reshape( (image_scale, image_scale) )
var pixels = SkiaSharpUtility.GetPixelValuesTo2DArray(imgResized);
// pixels /= 255
Vision.Math.Matrix.Scale(ref pixels, imgResized.Height, imgResized.Width, 1f / 255);
// 上面应该是像素值进行了归一化处理。
//# Remove low level frequency LL(max_ll) if @remove_max_haar_ll using haar filter
//if remove_max_haar_ll:
// coeffs = pywt.wavedec2( pixels, 'haar', level = ll_max_level )
// coeffs = list( coeffs )
// coeffs[0] *= 0
// pixels = pywt.waverec2( coeffs, 'haar' )
if (remove_max_haar_ll)
{
// 2D multilevel decomposition using wavedec2
WaveletTransform wtHaar = new WaveletTransform(new Accord.Math.Wavelets.Haar(ll_max_level)); // 只能处理Bitmap
Vision.Math.DiscreteHaarWaveletTransformation.FWT(pixels, ll_max_level);
}
//WaveletTransform wt = new WaveletTransform( new Accord.Math.Wavelets.Haar( 1 ) );
}
private void DB6reverse(object sender, RoutedEventArgs e)
{
Signal = WaveletTransform.WaveletBackwardTransformation(Signal);
ChartWrapper.SetSignal(SignalSlot, Signal);
ChartWrapper.Replot();
}
public CodMarker(
bool usePrecincts,
bool useEph,
bool useSop,
Size codeblockSize,
Size[] precinctSizes,
ProgressionOrder progression,
ushort qualityLayers,
bool useMultiComponentTransform,
WaveletTransform waveletFilter,
byte decompositionLevels,
CodeblockStyle cblkStyle)
: base(MarkerType.COD)
{
_scod = CodingStyle.None;
_scod |=
usePrecincts ? CodingStyle.UsePrecincts : CodingStyle.None;
_scod |=
useSop ? CodingStyle.UseSopMarker : CodingStyle.None;
_scod |=
useEph ? CodingStyle.UseEphMarker: CodingStyle.None;
Progression = progression;
QualityLayers = qualityLayers;
DecompositionLevels = decompositionLevels;
UseMultipleComponentTransform = useMultiComponentTransform;
CBlkStyle = cblkStyle;
WaveletFilter = waveletFilter;
// width > max || height > max
if ((new List <int> {
codeblockSize.Width,
codeblockSize.Height,
MAX_CBLK_SIZE
}).Max() != MAX_CBLK_SIZE)
{
throw new ArgumentOutOfRangeException(
"Codeblock dimensions must be up to "
+ MAX_CBLK_SIZE + " samples on each side");
}
bool isCodeblockPow2 =
BitHacks.IsPowerOf2((uint)codeblockSize.Width) &&
BitHacks.IsPowerOf2((uint)codeblockSize.Height);
if (!isCodeblockPow2)
{
throw new ArgumentException(
"Codeblock size must be power of 2");
}
// codeblock size range is [4,64], and is a power of 2.
// to save space and fill it inside a byte,
// codestream specifies them using the 2-exponent in the range
// [0, 16]. The additional 2 is implicit.
_cblkExpnX = (byte)(BitHacks.LogFloor2((uint)codeblockSize.Width));
_cblkExpnX -= 2;
_cblkExpnY = (byte)(BitHacks.LogFloor2((uint)codeblockSize.Height));
_cblkExpnY -= 2;
if (UsePrecincts)
{
bool valid = precinctSizes.Any();
valid &= precinctSizes.Length <= (decompositionLevels + 1);
valid &= precinctSizes
.All(prc => BitHacks.IsPowerOf2((uint)prc.Width));
valid &= precinctSizes
.All(prc => BitHacks.IsPowerOf2((uint)prc.Height));
if (!valid)
{
throw new ArgumentException(
"precincts unspecified or not power of two");
}
_ppx = new byte[decompositionLevels + 1];
_ppx = new byte[decompositionLevels + 1];
int idx = 0;
foreach (var prc in precinctSizes)
{
_ppx[idx] = (byte)BitHacks.LogFloor2((uint)prc.Width);
_ppy[idx] = (byte)BitHacks.LogFloor2((uint)prc.Height);
idx++;
}
for (; idx <= decompositionLevels; idx++)
{
// there is at least one element in ppx/ppy
// because we checked that precSizes.Any()
_ppx[idx] = _ppx[idx - 1];
_ppy[idx] = _ppy[idx - 1];
}
}
else
{
// maximal precincts: size 2^15
_ppx = new byte[] { 0xF };
_ppy = new byte[] { 0xF };
}
_markerBody = GenerateMarkerBody();
_markerLength = (ushort)(_markerBody.Length + 2);
}
/// <summary>
/// Applies wavelet transform filter (Accord.NET).
/// </summary>
/// <param name="img">Image.</param>
/// <param name="wavelet">A wavelet function.</param>
/// <param name="backward">True to perform backward transform, false otherwise.</param>
/// <returns>Transformed image.</returns>
public static Gray <byte>[,] WaveletTransform(this Gray <byte>[,] img, IWavelet wavelet, bool backward = false)
{
WaveletTransform wt = new WaveletTransform(wavelet, backward);
return(img.ApplyFilter((BaseFilter)wt));
}
