private Complex[][] GenerateGains(double[] gains, int sampleRate, int n)
{
var gainsComplex = new Complex[10][];
var low = 40;
var high = 20;
for (int i = 0; i < 10; i++)
{
if (gains[i] == 0)
{
gains[i] += 1;
}
else if (gains[i] < 0)
{
gains[i] = 1.0 / Math.Abs(gains[i]);
}
var bandFilterFactors = BasicFilter.BandPassFilterFactors(low, high, sampleRate, _filterLength, n);
for (int j = 0; j < bandFilterFactors.Length; j++)
{
bandFilterFactors[j] *= gains[i];
}
gainsComplex[i] = bandFilterFactors;
low *= 2;
high *= 2;
}
return(gainsComplex);
}
public async Task <string> GetServiceBasicData(QueryRequest request)
{
var start = request.Start.ToDateTime();
var end = request.End.ToDateTime();
BasicFilter filter = new BasicFilter {
Service = request.Service,
Instance = request.Instance,
StartTime = start,
EndTime = end,
Count = 6
};
var endpoint = _storage.GetGroupData(filter, GroupType.Route);
var instance = _storage.GetGroupData(filter, GroupType.Instance);
var range = GetTimeRange(start, end);
var app = _storage.GetAppStatus(filter, range);
await Task.WhenAll(endpoint, instance, app);
var result = new
{
endpoint = endpoint.Result,
instance = instance.Result,
range = range,
app = app.Result
};
return(Json(true, result));
}
public void BasicFilter()
{
BasicFilter bfilter = new BasicFilter();
// �趨���������
StringCollection layerCollection = new StringCollection();
//layerCollection.Add("*"); // �������еIJ�
layerCollection.Add("1"); // ���˲� 1
bfilter.SetLayers(layerCollection);
// �趨���������
StringCollection blkCollection = new StringCollection();
//����������еĿ飬���ÿ������ϰ��� "*"
// ������Կ���ˣ����ÿ������ϰ��� ""
blkCollection.Add("");
bfilter.SetBlocks(blkCollection);
//�趨Ҫ�ع�������
StringCollection blkClassification = new StringCollection();
//blkClassification.Add("pipe"); // ����pipeҪ��
blkClassification.Add("") ;// ����Ҫ�ع���
bfilter.SetFeatureClasses(blkClassification);
ObjectIdCollection selectedIDCollection = new ObjectIdCollection();
selectedIDCollection = GetAllEntity();
ObjectIdCollection outIDCollection = new ObjectIdCollection() ;
bfilter.FilterObjects(ref outIDCollection, selectedIDCollection);
// ������˵õ��Ķ���
HighlightEntity(outIDCollection);
}
internal EditBasicFilter(BasicFilter target, string newName, ITag newTag, IOperator newOperator, string newCriteria)
{
_newName = newName;
_newTag = newTag;
_newCriteria = newCriteria;
_target = target;
_newOperator = newOperator;
}
public async Task <IEnumerable <string> > GetTopServiceLoad(BasicFilter filter)
{
var expression = GetServiceExpression(filter);
return(await freeSql.Select <RequestInfo>().Where(expression)
.GroupBy(x => x.Service)
.OrderByDescending(x => x.Count())
.Limit(filter.Count)
.ToListAsync(x => x.Key));
}
private Expression <Func <RequestInfo, bool> > GetServiceExpression(BasicFilter filter)
{
Expression <Func <RequestInfo, bool> > expression = x => x.CreateTime >= filter.StartTime && x.CreateTime < filter.EndTime;
expression = expression
.And(!filter.Service.IsEmpty(), x => x.Service == filter.Service)
.And(!filter.Instance.IsEmpty(), x => x.Instance == filter.Instance);
return(expression);
}
static void Main(string[] args)
{
SamplesTable samplesGenerator = new SamplesTable();
//Console.WriteLine();
StreamWriter sr = new StreamWriter("Samples.html", false);
sr.AutoFlush = true;
sr.Write(samplesGenerator.GetTable());
sr.Close();
string frontPageTemplate = LoadHtmlTemplate();
string filtersContent = "";
Assembly myDll = System.Reflection.Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + @"/zrlabs.Yael.BasicFilters.dll");
FilterManual manual;
NameValueCollection filterCells = new NameValueCollection();
Console.WriteLine(myDll.FullName);
filtersContent += "<table>";
foreach (Module mod in myDll.GetLoadedModules())
{
Console.WriteLine(mod.Name);
}
Image myImg = Bitmap.FromFile("1.jpg");
foreach (Type type in myDll.GetTypes())
{
try
{
BasicFilter myFilter = (BasicFilter)Activator.CreateInstance(type);
manual = new FilterManual(myFilter, type.Name);
Console.WriteLine(type.Name + " " + manual.GetFilterCellHTML());
filterCells.Add(type.Name, manual.GetFilterCellHTML());
manual.SaveDemoImage("images/", myImg);
//manual.
//foreach (MethodInfo prop in type.GetMethods())
//{
// Console.WriteLine(prop.Name);
//}
//myFilter.ExecuteFilter(myImg, null).Save("c:/temp/12_" + type.Name + ".jpg");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
foreach (string key in filterCells)
{
filtersContent += filterCells[key] + "\r\n";
}
string processedHtmlContent = LoadHtmlTemplate().Replace(IMAGES_TABLE_TOKEN, filtersContent);
SaveFront(processedHtmlContent);
return;
}
public async Task <List <string> > GetEndpoints(BasicFilter filter)
{
var Start = DateTime.Now.AddDays(-1);
return(await freeSql.Select <RequestInfo>().Where(x => x.CreateTime >= Start)
.WhereIf(!filter.Service.IsEmpty(), x => x.Service == filter.Service)
.WhereIf(!filter.Instance.IsEmpty(), x => x.Instance == filter.Instance)
.OrderBy(x => x.Route)
.GroupBy(x => x.Route)
.ToListAsync(x => x.Key));
}
public string GetDateFormat(BasicFilter filter)
{
if ((filter.EndTime - filter.StartTime).TotalHours > 1)
{
return("dd-HH");
}
else
{
return("HH:mm");
}
}
static BasicFilter FilterLoadSha512(List<string> words, ushort hashNumber)
{
var watch = new Stopwatch();
BasicFilter filter = new BasicFilter(FilterWidth, HashFunc.SHA512, hashNumber);
watch.Start();
foreach (string w in words)
filter.Insert(w);
watch.Stop();
Console.WriteLine($"SHA512 ({hashNumber} times): {(double)watch.ElapsedMilliseconds / 1000} sec");
return filter;
}
public async Task <string> GetEndpoints(QueryRequest request)
{
BasicFilter filter = new BasicFilter
{
Service = request.Service,
Instance = request.Instance
};
var list = await _storage.GetEndpoints(filter);
return(Json(true, list));
}
static void FilterCheck(BasicFilter filter, List<string> words)
{
var watch = new Stopwatch();
double p = 0.0;
foreach (string w in words)
{
var res = filter.Check(w);
p = res.Probability;
}
watch.Stop();
Console.WriteLine($"{filter.HashFunction}, k={filter.HashNumber}, {words.Count} checks: {(double)watch.ElapsedMilliseconds / 1000} sec with p={p}");
}
public async Task <IndexPageData> GetIndexBasicDataAsync(BasicFilter filter)
{
IndexPageData result = new IndexPageData();
var expression = GetServiceExpression(filter);
result.Total = (await freeSql.Select <RequestInfo>().Where(expression).CountAsync()).ToInt();
result.ServerError = (await freeSql.Select <RequestInfo>().Where(expression).Where(x => x.StatusCode == 500).CountAsync()).ToInt();
result.Service = (await freeSql.Select <RequestInfo>().Where(expression).GroupBy(x => x.Service).CountAsync()).ToInt();
result.Instance = (await freeSql.Select <RequestInfo>().Where(expression).GroupBy(x => x.Instance).CountAsync()).ToInt();
return(result);
}
public async Task <List <BaseTimeModel> > GetServiceHeatMap(BasicFilter filter, List <string> Time)
{
var format = GetDateFormat(filter);
var expression = GetServiceExpression(filter);
string[] span = { "0-200", "200-400", "400-600", "600-800", "800-1000", "1000-1200", "1200-1400", "1400-1600", "1600+" };
var list = await freeSql.Select <RequestInfo>().Where(expression)
.GroupBy(x => new
{
KeyField = SqlExt.Case()
.When(0 < x.Milliseconds && x.Milliseconds <= 200, "0-200")
.When(200 < x.Milliseconds && x.Milliseconds <= 400, "200-400")
.When(400 < x.Milliseconds && x.Milliseconds <= 600, "400-600")
.When(600 < x.Milliseconds && x.Milliseconds <= 800, "600-800")
.When(800 < x.Milliseconds && x.Milliseconds <= 1000, "800-1000")
.When(1000 < x.Milliseconds && x.Milliseconds <= 1200, "1000-1200")
.When(1200 < x.Milliseconds && x.Milliseconds <= 1400, "1200-1400")
.When(1400 < x.Milliseconds && x.Milliseconds <= 1600, "1400-1600")
.Else("1600+").End(),
TimeField = x.CreateTime.ToString(format)
}).ToListAsync(x => new BaseTimeModel
{
KeyField = x.Key.KeyField,
TimeField = x.Key.TimeField,
ValueField = x.Count()
});
var model = new List <BaseTimeModel>();
foreach (var t in Time)
{
foreach (var s in span)
{
var c = list.Where(x => x.TimeField == t && x.KeyField == s).FirstOrDefault();
model.Add(new BaseTimeModel
{
TimeField = t,
KeyField = s,
ValueField = c == null ? 0 : c.ValueField
});
}
}
return(model);
}
public async Task <List <BaseTimeModel> > GetServiceTrend(BasicFilter filter, List <string> range)
{
IEnumerable <string> service = new List <string>()
{
filter.Service
};
if (filter.Service.IsEmpty())
{
service = await GetTopServiceLoad(filter);
}
var expression = GetServiceExpression(filter);
var format = GetDateFormat(filter);
var list = await freeSql.Select <RequestInfo>().Where(expression)
.GroupBy(x => new
{
KeyField = x.Service,
TimeField = x.CreateTime.ToString(format)
}).ToListAsync(x => new BaseTimeModel
{
KeyField = x.Key.KeyField,
TimeField = x.Key.TimeField,
ValueField = x.Count()
});
var model = new List <BaseTimeModel>();
foreach (var s in service)
{
foreach (var r in range)
{
var c = list.Where(x => x.KeyField == s && x.TimeField == r).FirstOrDefault();
model.Add(new BaseTimeModel
{
KeyField = s,
TimeField = r,
ValueField = c == null ? 0 : c.ValueField
});
}
}
return(model);
}
public async Task <List <List <TopServiceResponse> > > GetGroupData(BasicFilter filter, GroupType groupType)
{
var expression = GetServiceExpression(filter);
Expression <Func <RequestInfo, string> > exp = default;
if (groupType == GroupType.Service)
{
exp = x => x.Service;
}
if (groupType == GroupType.Instance)
{
exp = x => x.Instance;
}
if (groupType == GroupType.Route)
{
exp = x => x.Route;
}
List <List <TopServiceResponse> > result = new List <List <TopServiceResponse> >();
var GroupTotal = await freeSql.Select <RequestInfo>().Where(expression).GroupBy(exp).
OrderByDescending(x => x.Count()).Limit(filter.Count).ToListAsync(x => new TopServiceResponse
{
Key = x.Key,
Value = x.Count()
});
var GroupErrorTotal = await freeSql.Select <RequestInfo>().Where(expression).GroupBy(exp).
OrderByDescending(x => x.Avg(x.Value.Milliseconds * 1.00m)).Limit(filter.Count).ToListAsync(x => new TopServiceResponse
{
Key = x.Key,
Value = Convert.ToInt32(x.Avg(x.Value.Milliseconds * 1.00m))
});
var GroupAvg = await freeSql.Select <RequestInfo>().Where(expression).Where(x => x.StatusCode == 500).GroupBy(exp)
.OrderByDescending(x => x.Count()).Limit(filter.Count).ToListAsync(x => new TopServiceResponse
{
Key = x.Key,
Value = x.Count()
});
result.Add(GroupTotal);
result.Add(GroupErrorTotal);
result.Add(GroupAvg);
return(result);
}
public void Murmur3FilterCheck()
{
BasicFilter filter = new BasicFilter(50, HashFunc.Murmur3);
foreach (string str in WordList)
{
filter.Insert(str);
}
foreach (string str in WordList)
{
Assert.True(filter.Check(str).Presence == BloomPresence.MightBeInserted);
}
// This was brute-forced not to be in the set
Assert.True(filter.Check("notInThere5").Presence == BloomPresence.NotInserted);
}
public async Task <List <BaseNode> > GetTopologyData(BasicFilter filter)
{
var result = await freeSql.Select <RequestInfo>()
.Where(x => x.CreateTime >= filter.StartTime && x.CreateTime < filter.EndTime)
.Where(x => !string.IsNullOrEmpty(x.ParentService))
.Where(x => x.Service != x.ParentService)
.GroupBy(x => new
{
x.Service,
x.ParentService
}).ToListAsync(x => new BaseNode {
Key = x.Key.Service,
StringValue = x.Key.ParentService
});
return(result);
}
/// <summary>
/// Gets global filters from ani.xml.
/// </summary>
/// <returns>An array of Filter, containing filtering information.</returns>
internal static Filter[] GetGlobalFilters()
{
List <Filter> retList = new List <Filter>();
XmlDocument doc = new XmlDocument();
doc.Load(Path.Combine(FolderPath, "ani.xml"));
XmlNode GlobalFilterCont = doc.SelectSingleNode("/Root/GlobalFilters");
if (GlobalFilterCont.ChildNodes == null) // If there are no Global filters
{
return(null);
}
foreach (XmlNode n in GlobalFilterCont.ChildNodes)
{
if (n.Name == "Filter")
{
BasicFilter filter = new BasicFilter();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.FilterWord = n.InnerText;
retList.Add(filter);
}
else if (n.Name == "Replace")
{
Replace filter = new Replace();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.From = n.Attributes["From"].InnerText;
filter.To = n.InnerText;
retList.Add(filter);
}
}
return(retList.ToArray());
}
public async Task <List <APPTimeModel> > GetAppStatus(BasicFilter filter, List <string> range)
{
var format = GetDateFormat(filter);
var list = await freeSql.Select <Performance>()
.Where(x => x.CreateTime >= filter.StartTime && x.CreateTime < filter.EndTime)
.WhereIf(!filter.Service.IsEmpty(), x => x.Service == filter.Service)
.WhereIf(!filter.Instance.IsEmpty(), x => x.Instance == filter.Instance)
.GroupBy(x => new
{
TimeField = x.CreateTime.ToString(format)
}).ToListAsync(x => new APPTimeModel
{
TimeField = x.Key.TimeField,
GcGen0_Raw = x.Avg(x.Value.GCGen0),
GcGen1_Raw = x.Avg(x.Value.GCGen1),
GcGen2_Raw = x.Avg(x.Value.GCGen2),
HeapMemory_Raw = x.Avg(x.Value.HeapMemory),
ProcessMemory_Raw = x.Avg(x.Value.ProcessMemory),
ThreadCount_Raw = x.Avg(x.Value.ThreadCount)
});
var model = new List <APPTimeModel>();
foreach (var r in range)
{
var c = list.Where(x => x.TimeField == r).FirstOrDefault();
model.Add(new APPTimeModel
{
TimeField = r,
GcGen0 = c == null ? 0 : c.GcGen0_Raw.ToInt(),
GcGen1 = c == null ? 0 : c.GcGen1_Raw.ToInt(),
GcGen2 = c == null ? 0 : c.GcGen2_Raw.ToInt(),
HeapMemory = c == null ? 0 : c.HeapMemory_Raw.ToDouble(2),
ProcessMemory = c == null ? 0 : c.ProcessMemory_Raw.ToDouble(2),
ThreadCount = c == null ? 0 : c.ThreadCount_Raw.ToInt()
});
}
return(model);
}
public async Task <string> GetTopologyData(QueryRequest request)
{
var start = request.Start.ToDateTime();
var end = request.End.ToDateTime();
BasicFilter filter = new BasicFilter
{
Service = request.Service,
Instance = request.Instance,
StartTime = start,
EndTime = end
};
var Edges = await _storage.GetTopologyData(filter);
List <string> Nodes = Edges.Select(x => x.Key).Concat(Edges.Select(x => x.StringValue)).Distinct().ToList();
return(Json(true, new { Nodes, Edges }));
}
public void SHA512FilterCheck()
{
BasicFilter filter = new BasicFilter(50, HashFunc.SHA512);
foreach (string str in WordList)
{
filter.Insert(str);
}
foreach (string str in WordList)
{
Assert.True(filter.Check(str).Presence == BloomPresence.MightBeInserted);
}
// This was brute-forced not to be in the set
Assert.True(filter.Check("notInThere4").Presence == BloomPresence.NotInserted);
// This was brute-forced to have matching bits although it's not in the set
Assert.True(filter.Check("notInThere11").Presence == BloomPresence.MightBeInserted);
}
public async Task <string> GetIndexBasicData(QueryRequest request)
{
var start = request.Start.ToDateTime();
var end = request.End.ToDateTime();
BasicFilter filter = new BasicFilter
{
Service = request.Service,
Instance = request.Instance,
StartTime = start,
EndTime = end,
Count = 6
};
var basic = _storage.GetIndexBasicDataAsync(filter);
var top = _storage.GetGroupData(filter, GroupType.Service);
var range = GetTimeRange(start, end);
var trend = _storage.GetServiceTrend(filter, range);
var heatmap = _storage.GetServiceHeatMap(filter, range);
await Task.WhenAll(basic, top, trend, heatmap);
var result = new HttpResultEntity(1, "ok", new
{
Total = basic.Result.Total,
ServerError = basic.Result.ServerError,
Service = basic.Result.Service,
Instance = basic.Result.Instance,
Top = top.Result,
Trend = trend.Result,
HeatMap = heatmap.Result
});
return(Json(result));
}
public void BasicFilterWithPrecalculatedProb()
{
BasicFilter filter = new BasicFilter(40000, 1.0E-7);
foreach (string str in WordList)
{
filter.Insert(str);
}
foreach (string str in WordList)
{
Assert.True(filter.Check(str).Presence == BloomPresence.MightBeInserted);
}
// This was brute-forced not to be in the set
Assert.True(filter.Check("notInThere4").Presence == BloomPresence.NotInserted);
// This is inside the set
FilterResult res = filter.Check("radioimmunoelectrophoresis");
Assert.True(res.Presence == BloomPresence.MightBeInserted);
Assert.True(res.Probability <= 1.0E-7);
}
/// <summary>
/// Gets website filters from ani.xml.
/// </summary>
/// <returns>An array of Website, contains filtering information for every read website filter.</returns>
internal static Website[] GetWebsiteFilters()
{
List <Website> retList = new List <Website>();
XmlDocument doc = new XmlDocument();
doc.Load(Path.Combine(FolderPath, "ani.xml"));
XmlNode WebsiteFilterCont = doc.SelectSingleNode("/Root/WebsiteFilters");
if (WebsiteFilterCont.ChildNodes == null)
{
return(null);
}
foreach (XmlNode node in WebsiteFilterCont.ChildNodes)
{
Website web = new Website();
web.Keyword = node.Attributes["Keyword"].InnerText; // Must have Keyword
if (node.Attributes["Blacklist"] != null)
{
web.Blacklist = node.Attributes["Blacklist"].InnerText;
}
else
{
web.Blacklist = null;
}
List <Filter> filters = new List <Filter>();
foreach (XmlNode n in node.ChildNodes)
{
if (n.Name == "Replace")
{
Replace filter = new Replace();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.From = n.Attributes["From"].InnerText;
filter.To = n.InnerText;
filters.Add(filter);
}
else if (n.Name == "RemoveFromStart")
{
RemoveFromStart filter = new RemoveFromStart();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.Char = n.InnerText.ToCharArray()[0];
filters.Add(filter);
}
else if (n.Name == "RemoveFromChar")
{
RemoveFromChar filter = new RemoveFromChar();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.Char = n.InnerText.ToCharArray()[0];
filters.Add(filter);
}
else if (n.Name == "RemoveInBetween")
{
RemoveInBetween filter = new RemoveInBetween();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.FirstChar = n.Attributes["FirstChar"].InnerText.ToCharArray()[0];
filter.LastChar = n.InnerText.ToCharArray()[0];
filters.Add(filter);
}
else if (n.Name == "Filter")
{
BasicFilter filter = new BasicFilter();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.FilterWord = n.InnerText;
filters.Add(filter);
}
else if (n.Name == "Add")
{
BasicAdd filter = new BasicAdd();
filter.Keyword = GetAttribute(n.Attributes, "Keyword") ?? null;
filter.Blacklist = GetAttribute(n.Attributes, "Blacklist") ?? null;
filter.AddWord = n.InnerText;
filters.Add(filter);
}
}
web.Filters = filters.ToArray();
retList.Add(web);
}
return(retList.ToArray());
}
public async Task <string> GetServiceBasicData(QueryRequest request)
{
var start = request.Start.ToDateTime();
var end = request.End.ToDateTime();
#region BuildService
if (request.Service.IsEmpty() || request.Service == "ALL")
{
request.Service = "";
}
if (request.Instance.IsEmpty() || request.Instance == "ALL")
{
request.LocalIP = "";
request.LocalPort = 0;
}
else
{
request.LocalIP = request.Instance.Substring(0, request.Instance.LastIndexOf(':'));
request.LocalPort = request.Instance.Substring(request.Instance.LastIndexOf(':') + 1).ToInt();
}
#endregion
IndexPageDataFilterOption option = new IndexPageDataFilterOption
{
Service = request.Service,
LocalIP = request.LocalIP,
LocalPort = request.LocalPort,
StartTime = start,
EndTime = end,
StartTimeFormat = "yyyy-MM-dd HH:mm:ss",
EndTimeFormat = "yyyy-MM-dd HH:mm:ss",
Take = 6
};
BasicFilter filter = new BasicFilter {
Service = request.Service,
Instance = request.Instance,
StartTime = start,
EndTime = end,
Count = 6
};
var route = await _storage.GetGroupData(filter, GroupType.Route);
var instance = await _storage.GetGroupData(filter, GroupType.Instance);
var range = GetTimeRange(option.StartTime.Value, option.EndTime.Value);
var app = await _storage.GetAppStatus(filter, range);
return(Json(new HttpResultEntity(1, "ok", new
{
route = route,
instance = instance,
range = range,
app = app
})));
}
public double[] Process(WavData wavData)
{
var n = FourierHelper.GetExpandedPow2(_windowLength + _filterLength - 1);
var size = wavData.Samples.Length + n - _windowLength;
var result = new double[size];
var windows = new double[size / _windowHopSize][];
var windowsComplex = new Complex[size / _windowHopSize][];
for (int i = 0; i < windows.Length; i++)
{
windows[i] = new double[n];
windowsComplex[i] = new Complex[n];
}
if (_gain < 0)
{
_gain = 1 / Math.Abs(_gain) - 1;
}
var windowFactors = _window.WindowFactors(_windowLength);
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < _windowLength; j++)
{
if (i * _windowHopSize + j < wavData.Samples.Length)
{
windows[i][j] = windowFactors[j] * wavData.Samples[i * _windowHopSize + j];
}
else
{
windows[i][j] = 0;
}
}
for (int j = _windowLength; j < n; j++)
{
windows[i][j] = 0;
}
}
var freq = wavData.FormatChunk.SampleRate / _lfo;
var filterSize = _endBandFreq - _bandSize - _startBandFreq;
for (int i = 0; i < windows.Length; i++)
{
var highPass = (Math.Sin(2 * Math.PI * i * _windowHopSize / freq) * 0.5 + 0.5) * filterSize + _startBandFreq;
var lowPass = highPass + _bandSize;
var bandFilterFactors = BasicFilter.BandPassFilterFactors(lowPass, highPass, wavData.FormatChunk.SampleRate, _filterLength, n);
windowsComplex[i] = FourierTransform.FFT(windows[i]);
for (int j = 0; j < windowsComplex[i].Length; j++)
{
windowsComplex[i][j] += windowsComplex[i][j] * bandFilterFactors[j] * _gain;
}
windows[i] = FourierTransform.IFFT(windowsComplex[i]);
}
for (int i = 0; i < windows.Length; i++)
{
for (int j = 0; j < windows[i].Length; j++)
{
if (i * _windowHopSize + j < wavData.Samples.Length)
{
result[i * _windowHopSize + j] += windows[i][j];
}
}
}
return(result);
}
protected virtual Criteria ProcessCriteria(BasicFilter criteria)
{
return(null);
}
public FilterManual(ZRLabs.Yael.BasicFilters.BasicFilter myFilter, string name)
{
_filter = myFilter;
_name = name;
}
public async Task <string> GetIndexBasicData(QueryRequest request)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var start = request.Start.ToDateTime();
var end = request.End.ToDateTime();
#region BuildService
if (request.Service.IsEmpty() || request.Service == "ALL")
{
request.Service = "";
}
if (request.Instance.IsEmpty() || request.Instance == "ALL")
{
request.LocalIP = "";
request.LocalPort = 0;
}
else
{
request.LocalIP = request.Instance.Substring(0, request.Instance.LastIndexOf(':'));
request.LocalPort = request.Instance.Substring(request.Instance.LastIndexOf(':') + 1).ToInt();
}
#endregion
IndexPageDataFilterOption option = new IndexPageDataFilterOption {
Service = request.Service,
LocalIP = request.LocalIP,
LocalPort = request.LocalPort,
StartTime = start,
EndTime = end,
StartTimeFormat = "yyyy-MM-dd HH:mm:ss",
EndTimeFormat = "yyyy-MM-dd HH:mm:ss",
Take = 6
};
BasicFilter filter = new BasicFilter
{
Service = request.Service,
Instance = request.Instance,
StartTime = start,
EndTime = end,
Count = 6
};
var a0 = stopwatch.ElapsedMilliseconds;
var basic = await _storage.GetIndexBasicDataAsync(filter);
var a1 = stopwatch.ElapsedMilliseconds;
var top = await _storage.GetGroupData(filter, GroupType.Service);
var a2 = stopwatch.ElapsedMilliseconds;
var range = GetTimeRange(option.StartTime.Value, option.EndTime.Value);
var trend = await _storage.GetServiceTrend(filter, range);
var a3 = stopwatch.ElapsedMilliseconds;
var heatmap = await _storage.GetServiceHeatMap(filter, range);
var a4 = stopwatch.ElapsedMilliseconds;
//await Task.WhenAll(basic,top,trend,heatmap);
stopwatch.Stop();
return(Json(new HttpResultEntity(1, "ok", new
{
Total = basic.Total,
ServerError = basic.ServerError,
Service = basic.Service,
Instance = basic.Instance,
Top = top,
Trend = trend,
HeatMap = heatmap,
Cost = stopwatch.ElapsedMilliseconds
})));
}
public async Task <List <MonitorAlarm> > GetMonitorAlarms(BasicFilter filter)
{
return(await freeSql.Select <MonitorAlarm>().OrderByDescending(x => x.CreateTime).Page(filter.PageNumber, filter.PageSize).ToListAsync());
}
