static void Main(string[] args)
{
DWT dwt = new DWT("Boat.png");
//DWT dwt = new DWT("Lenna.jpg");
dwt.threshold = 0.5;
dwt.Processing();
dwt.SaveImage();
dwt.SaveMatrix();
IDWT iDwt = new IDWT("Intermediate.dwt");
iDwt.Processing();
iDwt.SaveImage();
//Console.WriteLine("\n" + "Press any key to close...");
//Console.ReadKey();
}
public async Task <double[][][]> PerformDWT(double[] inputData, MotherWavelet inputWavelet, int maxDecompLevel)
{
Signal signal = new Signal(inputData);
MotherWavelet wavelet = inputWavelet;
double[][][] output = new double[3][][];
double[][] reconstrData;
double[][] detailData;
double[][] approxData;
detailData = new double[maxDecompLevel][];
approxData = new double[maxDecompLevel][];
reconstrData = new double[maxDecompLevel][];
for (int r = 1; r <= maxDecompLevel; r++)
{
dwt = DWT.ExecuteDWT(signal, wavelet, r, SignalExtension.ExtensionMode.SymmetricWholePoint, WaveletStudio.Functions.ConvolutionModeEnum.Normal);
detailData[r - 1] = new double[signal.SamplesCount];
approxData[r - 1] = new double[signal.SamplesCount];
reconstrData[r - 1] = new double[signal.SamplesCount];
reconstrData[r - 1] = DWT.ExecuteIDWT(dwt, wavelet, r, WaveletStudio.Functions.ConvolutionModeEnum.Normal);
}
for (int d = 0; d < dwt.Count; d++)
{
approxData[d] = dwt[d].Approximation;
detailData[d] = dwt[d].Details;
}
output[0] = detailData;
output[1] = approxData;
output[2] = reconstrData;
return(output);
}
/// <summary>
/// 一维离散小波变换
/// </summary>
/// <param name="orginal">输入源信号</param>
/// <param name="dwt">变换类</param>
/// <returns>当前近似系数(信号低频成分)+细节系数(信号高频成分)，各层系数长度</returns>
public static List <List <double> > DWT1(List <double> orginal, DWT dwt)
{
List <List <double> > result = new List <List <double> >();
if (orginal == null || dwt == null)
{
return(result);
}
try
{
int lfLength = dwt.Lo_D.Count - 1;
List <double> extend = TransformUtil.DWT1Extend("sym", orginal, lfLength);
if (extend != null && extend.Count > 0)
{
int last = orginal.Count + lfLength;
result.Add(dwt.Space(1, last, TransformUtil.Convolve(extend, dwt.Lo_D, "valid")));
result.Add(dwt.Space(1, last, TransformUtil.Convolve(extend, dwt.Hi_D, "valid")));
}
}
catch (Exception ex) { }
return(result);
}
/// <summary>
/// 提取近似系数
/// </summary>
/// <param name="x">一维小波分解后的结果</param>
/// <param name="l">层级系数</param>
/// <param name="dwt">变换类</param>
/// <param name="i">0 <= i <= length(l)-2</param>
public static List <double> Appcoef(List <double> x, List <int> l, DWT dwt, int i = -1)
{
List <double> result = new List <double>();
if (x != null && l != null && dwt != null)
{
int rmax = l.Count;
int nmax = rmax - 2, n = nmax;
if (i >= 0 && i <= nmax)
{
n = i;
}
result = x.GetRange(0, l[0]);
int imax = rmax + 1;
for (int j = nmax; j >= n + 1; j--)
{
List <double> d = Detcoef(x, l, j);
result = IDWT1(result, d, dwt, l[imax - j]);
}
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="orginal">输入源信号</param>
/// <param name="lev">分解层级</param>
/// <param name="wname">haar、db1~db10</param>
/// <returns>各层近似系数+细节系数，各层系数</returns>
public static WaveDec1ViewModel WaveDec1(List <double> orginal, int lev = 1, string wname = "haar")
{
WaveDec1ViewModel result = new WaveDec1ViewModel();
try
{
DWT dwt = new DWT(orginal, wname);//获取到相关的分解系数
List <double> co = new List <double>();
int[] li = new int[lev + 2];
li[li.Length - 1] = orginal.Count;
for (int i = 0; i < lev; i++)
{
List <List <double> > data = DWTUtil.DWT1(orginal, dwt);
if (data != null && data.Count == 2)
{
orginal = data[0];
List <double> re = data[1];
if (re != null)
{
co = re.Concat(co).ToList();
li[lev - i] = re.Count;
}
}
}
co = orginal.Concat(co).ToList();
li[0] = orginal.Count;
result.AppAndDetail = co;
result.Coefficient = li.ToList();
result.Dwt = dwt;
}
catch (Exception ex)
{
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="orginal">输入源信号</param>
/// <param name="lev">分解层级</param>
/// <param name="wname">haar、db1~db10</param>
/// <returns></returns>
public static List <object> WaveDec2(List <List <double> > orginal, int lev = 1, string wname = "haar")
{
List <object> result = new List <object>();
try
{
if (orginal != null && orginal.Any())
{
DWT dwt = new DWT(orginal, wname);//获取到相关的分解系数
if (dwt != null && dwt.Lo_D != null && dwt.Hi_D != null && dwt.Lo_D.Count == dwt.Hi_D.Count)
{
List <double> cl = new List <double>();
List <List <double> > s = new List <List <double> >();
int r = lev + 2, c = orginal.Count;
for (int i = 0; i < r - 1; i++)
{
List <double> item = new List <double>();
for (int j = 0; j < 2; j++)
{
item.Add(0);
}
s.Add(item);
}
s.Add(new List <double> {
c, orginal[0].Count
});
for (int i = 1; i <= lev; i++)
{
Dictionary <int, List <List <double> > > data = DWTUtil.DWT2(orginal, dwt);
if (data != null && data.Count == 4)
{
//近似分量
orginal = data[0];
//水平细节分量
List <List <double> > ch = data[1];
//垂直细节分量
List <List <double> > cv = data[2];
//对角细节分量
List <List <double> > cd = data[3];
//可优化，没有操作ca，看DWT2是否需要进行ca的值获取
cl = ConvertToLA(ch).Concat(ConvertToLA(cv)).Concat(ConvertToLA(cd)).Concat(cl).ToList();
s[r - i - 1] = new List <double> {
orginal.Count, orginal[0].Count
};
}
}
s[0] = new List <double> {
orginal.Count, orginal[0].Count
};
result.Add(ConvertToLA(orginal).Concat(cl).ToList());
result.Add(s);
}
}
}
catch (Exception ex)
{
var sd = ex;
}
return(result);
}
/// <summary>
/// 二维小波变换
/// </summary>
/// <param name="orginal">输入源信号</param>
/// <param name="dwt">变换类</param>
/// <returns></returns>
public static Dictionary <int, List <List <double> > > DWT2(List <List <double> > orginal, DWT dwt)
{
Dictionary <int, List <List <double> > > result = new Dictionary <int, List <List <double> > >();
try
{
int lodl = dwt.Lo_D.Count - 1, hidl = dwt.Hi_D.Count - 1, orginalRow = orginal.Count, orginalCol = orginal[0].Count;
List <List <double> > y = TransformUtil.DWT2Extend("addcol", "sym", orginal, lodl);
List <List <double> > convresult = TransformUtil.Convolve(y, dwt.Lo_D, "valid");
//近似分量
result.Add(0, TransformUtil.ConvDown(convresult, dwt.Lo_D, lodl, orginalRow, orginalCol));
//水平细节分量
result.Add(1, TransformUtil.ConvDown(convresult, dwt.Hi_D, hidl, orginalRow, orginalCol));
convresult = TransformUtil.Convolve(y, dwt.Hi_D, "valid");
//垂直细节分量
result.Add(2, TransformUtil.ConvDown(convresult, dwt.Lo_D, lodl, orginalRow, orginalCol));
result.Add(3, TransformUtil.ConvDown(convresult, dwt.Hi_D, hidl, orginalRow, orginalCol));
}
catch (Exception ex) { }
return(result);
}
/// <summary>
/// Executes the block
/// </summary>
public override void Execute()
{
var connectingNode = InputNodes[0].ConnectingNode as BlockOutputNode;
if (connectingNode == null || connectingNode.Object == null)
{
return;
}
var signalIndex = 0;
OutputNodes[0].Object.Clear();
OutputNodes[1].Object.Clear();
OutputNodes[2].Object.Clear();
OutputNodes[3].Object.Clear();
foreach (var signal in connectingNode.Object)
{
signalIndex++;
var name = signal.Name;
if (!string.IsNullOrEmpty(name))
{
name += " - ";
}
else
{
name = Resources.Signal + " " + signalIndex + " - ";
}
var decompositionLevels = DWT.ExecuteDWT(signal, _motherWavelet, Level, ExtensionMode);
foreach (var level in decompositionLevels)
{
var apxSignal = signal.Copy();
apxSignal.Name = name + Resources.ApproximationLevel + " " + (level.Index + 1);
apxSignal.Samples = level.Approximation;
OutputNodes[0].Object.Add(apxSignal);
if (Rescale)
{
var rescaledApx = RescaleSignal(apxSignal, signal, level);
OutputNodes[3].Object.Add(rescaledApx);
}
else
{
OutputNodes[3].Object.Add(apxSignal);
}
var detSignal = signal.Copy();
detSignal.Name = name + Resources.DetailsLevel + " " + (level.Index + 1);
detSignal.Samples = level.Details;
OutputNodes[1].Object.Add(detSignal);
if (Rescale)
{
var rescaledDet = RescaleSignal(detSignal, signal, level);
OutputNodes[3].Object.Add(rescaledDet);
}
else
{
OutputNodes[3].Object.Add(detSignal);
}
}
var reconstruction = DWT.ExecuteIDWT(decompositionLevels, _motherWavelet, Level);
var recSignal = signal.Copy();
recSignal.Name = name + Resources.Reconstruction;
recSignal.Samples = reconstruction;
OutputNodes[2].Object.Add(recSignal);
OutputNodes[3].Object.Add(recSignal);
}
if (!Cascade)
{
return;
}
foreach (var output in OutputNodes.Where(output => output.ConnectingNode != null))
{
output.ConnectingNode.Root.Execute();
}
}
/// <summary>
/// 小波基函数
/// </summary>
/// <param name="wname">小波名称</param>
/// <param name="infoModel">小波信息</param>
/// <param name="iter">迭代次数</param>
public static WavefunModel Wavefun(string wname, WaveletsInfoModel infoModel, int iter)
{
WavefunModel data = new WavefunModel();
if (!string.IsNullOrEmpty(wname))
{
string debut = wname.Substring(0, 2);
double coef = Math.Pow(Math.Sqrt(2), iter), pas = (double)1 / Math.Pow(2, iter);
switch (infoModel.type)
{
case 1:
DWT dwt = new DWT(wname);
int logn = dwt.Lo_R.Count;
int nbpts = Convert.ToInt32((logn - 1) / pas + 1);
List <double> psi = DWTUtil.Upcoef("d", dwt, iter);
if (psi != null && psi.Any())
{
psi = psi.Select(m => m * coef).ToList();
}
List <int> result = GetNBpts(nbpts, iter, logn); //nbpts、nb、dn
int nb = result[1], dn = result[2] + 1;
nbpts = result[0];
DWTUtil.Wkeep1(psi, nb, "c");
psi.Insert(0, 0);
for (int i = 1; i <= dn; i++)
{
psi.Add(0);
}
//sign depends on wavelet
if ("co".Equals(debut) || "sy".Equals(debut) || "dm".Equals(debut))
{
psi = psi.Select(m => - m).ToList();
}
//data.phi = phi;
data.psi = psi;
data.type = infoModel.type;
data.xval = Linspace(0, (nbpts - 1) * pas, nbpts);
break;
case 2:
break;
case 3:
break;
case 4:
data = Morlet(infoModel.bounds[0], infoModel.bounds[1], (int)Math.Pow(2, iter));
break;
case 5:
break;
default:
break;
}
}
return(data);
}
