public void MedianWithNumericInputsReturnsCorrectValue()
{
var function = new Median();
var result = function.Execute(FunctionsHelper.CreateArgs(16, 55, 19, 20), this.ParsingContext);
Assert.AreEqual(19.5d, result.Result);
}
public void MedianWithGenericStringInputReturnsPoundValue()
{
var function = new Median();
var result = function.Execute(FunctionsHelper.CreateArgs("string", "string", "string"), this.ParsingContext);
Assert.AreEqual(eErrorType.Value, ((ExcelErrorValue)result.Result).Type);
}
public void MedianWithDoubleInputsReturnsCorrectValue()
{
var function = new Median();
var result = function.Execute(FunctionsHelper.CreateArgs(5.5, 2.3, 15.6, 11.2), this.ParsingContext);
Assert.AreEqual(8.35d, result.Result);
}
public void MedianWithOneInputReturnsCorrectValue()
{
var function = new Median();
var result = function.Execute(FunctionsHelper.CreateArgs(15), this.ParsingContext);
Assert.AreEqual(15d, result.Result);
}
public void MedianWithLogicInputsReturnsCorrectValue()
{
var function = new Median();
var result = function.Execute(FunctionsHelper.CreateArgs(true, false), this.ParsingContext);
Assert.AreEqual(0.5d, result.Result);
}
private bool SwapOut(T[] entries)
{
// if (Median.CompareTo(entries[Left]) == 0) Swap(entries, LeftMedian++, Left);
var leftCompare = Median.AbstractCompareTo(entries[Left]);
if (!leftCompare.ComparisonSucceeded)
{
return(false);
}
if (leftCompare.ComparisonResult == 0)
{
Swap(entries, LeftMedian++, Left);
}
// if (Median.CompareTo(entries[Right]) == 0) Swap(entries, Right, RightMedian--);
var rightCompare = Median.AbstractCompareTo(entries[Right]);
if (!rightCompare.ComparisonSucceeded)
{
return(false);
}
if (rightCompare.ComparisonResult == 0)
{
Swap(entries, Right, RightMedian--);
}
return(true);
}
//populate values
public override void Populate()
{
TimeSeries source = Parameters[0].AsTimeSeries;
Int32 period = Parameters[1].AsInt;
DateTimes = source.DateTimes;
//set EMA constant from period
double rad = 360.0 / period;
rad = rad.ToRadians();
double alpha1 = (Math.Cos(rad) + Math.Sin(rad) - 1.0) / Math.Cos(rad);
//calculate indicator values, prime with median
int start = period + source.FirstValidIndex;
if (start >= source.Count)
{
return;
}
double rm = Median.Calculate(start - 1, source, period);
Values[start - 1] = rm;
for (int n = start; n < source.Count; n++)
{
rm = alpha1 * Median.Calculate(n, source, period) + (1.0 - alpha1) * rm;
Values[n] = rm;
}
}
public void MedianWithNumericStringInputReturnsCorrectValue()
{
var function = new Median();
var result = function.Execute(FunctionsHelper.CreateArgs("16", "55", "19", "20"), this.ParsingContext);
Assert.AreEqual(19.5d, result.Result);
}
/// <summary>
/// Filter: Median Blur
/// Subtract the medium blur (block size ~letter size) from the image
/// </summary>
public void SubtractMedianBlur()
{
var filter = new Median(); // create filter
filter.ApplyInPlace(Image); // apply the filter
Save("medianBlurred");
}
public static CommonOutputs.AnomalyDetectionOutput CreateAnomalyPipelineEnsemble(IHostEnvironment env, PipelineAnomalyInput input)
{
Contracts.CheckValue(env, nameof(env));
var host = env.Register("CombineModels");
host.CheckValue(input, nameof(input));
host.CheckNonEmpty(input.Models, nameof(input.Models));
IRegressionOutputCombiner combiner;
switch (input.ModelCombiner)
{
case ScoreCombiner.Median:
combiner = new Median(host);
break;
case ScoreCombiner.Average:
combiner = new Average(host);
break;
default:
throw host.Except("Unknown combiner kind");
}
var ensemble = SchemaBindablePipelineEnsembleBase.Create(host, input.Models, combiner, MetadataUtils.Const.ScoreColumnKind.AnomalyDetection);
return(CreatePipelineEnsemble <CommonOutputs.AnomalyDetectionOutput>(host, input.Models, ensemble));
}
private void NoiseReduction(ref Bitmap frame)
{
frame = Grayscale.CommonAlgorithms.RMY.Apply(frame); // Make gray
switch (NoiseReduceValue)
{
case 1:
BilateralSmoothing Bil_filter = new BilateralSmoothing();
Bil_filter.KernelSize = 7;
Bil_filter.SpatialFactor = 10;
Bil_filter.ColorFactor = 30;
Bil_filter.ColorPower = 0.5;
Bil_filter.ApplyInPlace(frame);
break;
case 2:
Median M_filter = new Median();
M_filter.ApplyInPlace(frame);
break;
case 3:
Mean Meanfilter = new Mean();
// apply the MirrFilter
Meanfilter.ApplyInPlace(frame);
break;
default:
Median Median_filter = new Median();
Median_filter.ApplyInPlace(frame);
break;
}
GrayscaleToRGB RGBfilter = new GrayscaleToRGB(); // back to color format
frame = RGBfilter.Apply(frame);
}
public void TestMedianEvenCount()
{
var m = new Median();
m.Init();
m.Accumulate(new Pair {
Value = 1, Name = "1"
});
m.Accumulate(new Pair {
Value = 1, Name = "1"
});
m.Accumulate(new Pair {
Value = 5, Name = "5"
});
m.Accumulate(new Pair {
Value = 7, Name = "7"
});
m.Accumulate(new Pair {
Value = 8, Name = "8"
});
m.Accumulate(new Pair {
Value = 1000, Name = "1000"
});
m.Accumulate(new Pair {
Value = 10000, Name = "10000"
});
Assert.AreEqual("7", m.Terminate().Value);
}
// --- External Behaviours:
/// <summary>
/// Determines quintile group of individual with given population index.
/// </summary>
public Group FindQuintile(int populationIndex)
{
if (Median.IsMember(populationIndex))
{
return(Group.median);
} // NOTE: returns Median for 0-index 0-population case
else
{
if (Top.IsMember(populationIndex))
{
return(Group.top);
}
else
{
if (High.IsMember(populationIndex))
{
return(Group.high);
}
else
{
if (Low.IsMember(populationIndex))
{
return(Group.low);
}
else
{
return(Group.bottom);
}
}
}
}
}
private void btnOperation(object sender, RoutedEventArgs e)
{
var master = sender as System.Windows.Controls.Button;
switch (master.Name)
{
case ("btnThreshold"):
var parmTh = (int)nudThreshold.Value;
SrcMImg = SrcMImg.Add(Threshold.Apply(parmTh), StrThreshold.With(parmTh));
break;
case ("btnAdpThreshold"):
var parmAdTh = (int)nudAdpThreshold.Value;
SrcMImg = SrcMImg.Add(AdpTHreshold.Apply(parmAdTh), StrAdpTHreashold.With(parmAdTh));
break;
case ("btnMedian"):
var parmMdn = (int)nudMedian.Value;
SrcMImg = SrcMImg.Add(Median.Apply(parmMdn), StrMedian.With(parmMdn));
break;
case ("btnNormalize"):
var parmNorm = (int)nudNormalize.Value;
SrcMImg = SrcMImg.Add(Normalize.Apply(parmNorm), StrNormalize.With(parmNorm));
break;
}
imgBack.Source = ToBitmapSource(SrcMImg.GetLastValue());
txbLog.Selection.Text = SrcMImg.GetLastPaper().Paper2TextHistory();
var temp = SrcMImg.GetLastPaper().Paper2TextHistory();
}
// B ---------V---------A
// \
// \
// \
// C
//
// Median(Segment(V, C), Triangle(C, A, B)) -> Midpoint(V, Segment(B, A))
//
private static List <EdgeAggregator> InstantiateFromMedian(GroundedClause clause)
{
List <EdgeAggregator> newGrounded = new List <EdgeAggregator>();
if (clause is InMiddle && !(clause is Midpoint))
{
InMiddle im = clause as InMiddle;
foreach (Median median in candidateMedian)
{
newGrounded.AddRange(InstantiateFromMedian(im, median));
}
candidateInMiddle.Add(im);
}
else if (clause is Median)
{
Median median = clause as Median;
foreach (InMiddle im in candidateInMiddle)
{
newGrounded.AddRange(InstantiateFromMedian(im, median));
}
candidateMedian.Add(median);
}
return(newGrounded);
}
public void MedianShouldThrowIfNoArgs()
{
var func = new Median();
var args = FunctionsHelper.Empty();
func.Execute(args, _parsingContext);
}
public Bitmap FiltroMedia(int n)
{
Median media = new Median(n);
imagen = media.Apply(imagen);
return(imagen);
}
public string decodeBitmap(Bitmap img)
{
/////////图像处理
//转为灰度图
Grayscale grayscaleFilter = new Grayscale(0.299, 0.587, 0.114);
Bitmap bitmapGrayscale = grayscaleFilter.Apply(img);
//二值化
Threshold thresholdFilter = new Threshold(128);
Bitmap bitmapThreshold = thresholdFilter.Apply(bitmapGrayscale);
////////中值滤波
Median mediafil = new Median();
Bitmap medianBit = mediafil.Apply(bitmapThreshold);
//锐化
Sharpen sharpPic = new Sharpen();
Bitmap sharpOut = sharpPic.Apply(medianBit);
//统计点数
HorizontalIntensityStatistics his = new HorizontalIntensityStatistics(sharpOut);
Histogram histogram = his.Gray;
int[] dato = histogram.Values;
/////分割图像
charCut(dato);
shunfengdecoder decode = new shunfengdecoder();
string backcode = decode.Decoder(sharpOut, div);
return(backcode);
}
public void TestMedianOddCount()
{
var m = new Median();
m.Init();
m.Accumulate(new Pair {
Value = 1, Name = "1"
});
m.Accumulate(new Pair {
Value = 1, Name = "1"
});
m.Accumulate(new Pair {
Value = 5, Name = "5"
});
m.Accumulate(new Pair {
Value = 6, Name = "6"
});
m.Accumulate(new Pair {
Value = 1000, Name = "1000"
});
m.Accumulate(new Pair {
Value = 10000, Name = "10000"
});
Assert.AreEqual("5 - 6", m.Terminate().Value); // Excel gives 5.5 here
}
public void VectorsRotate120(Bitmap image, List <double[]> vector360Contur, List <double[]> vector360Hull)
{
int i;
ProcessingImage pi = new ProcessingImage();
List <System.Drawing.Point> localPt;
for (i = 180; i < 360; i++)
{
QuickHull qh = new QuickHull();
Contur cont1 = new Contur();
//медианный фильтр для шумов границ размытых объектов
Median filter = new Median();
filter.ApplyInPlace(image);
//поворот на 1 градус
Bitmap image1 = pi.RotateImg(image, i);
image1 = pi.ProcImg(image1);
localPt = pi.GetPoints(image1);
//выделение выпуклой оболочки
List <System.Drawing.Point> ConvexHullLocal = qh.quickHull(localPt);
ConvexHullLocal = qh.DeleteAnglePoints(ConvexHullLocal);
//и контура
List <System.Drawing.Point> ConturLocal = cont1.kontur(image1);
ConturLocal = cont1.DeleteAnglePoints(ConturLocal);
Primary marks = new Primary(image1, ConturLocal, ConvexHullLocal);
vector360Contur.Add(marks.Contour());
vector360Hull.Add(marks.Convex());
}
}
public Bitmap ToMedian(Bitmap Im)
{
AForge.Imaging.Filters.Median Img = new Median();
Bitmap bmImage = AForge.Imaging.Image.Clone(new Bitmap(Im), PixelFormat.Format24bppRgb);
return(Img.Apply(bmImage));
}
private void ReduceNoise()
{
var sw = Stopwatch.StartNew();
if (_bitmapToAnalyze.Width > _maxWidth)
{
Bitmap bmp;
switch (_noiseReduction)
{
case NoiseReductionEnum.High:
bmp = new FastGaussianBlur(_bitmapToAnalyze).Process(2);
break;
case NoiseReductionEnum.Highest:
bmp = new FastGaussianBlur(_bitmapToAnalyze).Process(3);
break;
case NoiseReductionEnum.Median:
bmp = new Median().Apply(_bitmapToAnalyze);
break;
default:
bmp = new FastGaussianBlur(_bitmapToAnalyze).Process(1);
break;
}
_bitmapToAnalyze.Dispose();
_bitmapToAnalyze = bmp;
sw.Stop();
Debug.Print("Time for noise reduction: " + sw.Elapsed);
sw = null;
}
}
public static Maybe <ProcFuncs> ConvertToPreProFunc(ProcRecipe src)
{
var name = src.Item1;
var strparm = src.Item2;
int parameter;
if (!Int32.TryParse(strparm, out parameter))
{
return(None);
}
switch (name)
{
case keyThreshold:
return(Threshold.Apply(parameter));
case keyNormalize:
return(Normalize.Apply(parameter));
case keyAdpThreshold:
return(AdpThreshold.Apply(parameter));
case keyMedian:
return(Median.Apply(parameter));
default:
return(None);
}
}
public void negativeSequence()
{
double[] testInput = new double[] { -1, -2, -3, -4, -5 };
double output = Median.BruteForceMedian(testInput);
double expected = -3;
Assert.AreEqual(expected, output);
}
public static Bitmap MedianFilter(Bitmap sourceImage, int squareSize)
{
var filter = new Median();
var tmp = new Bitmap(sourceImage);
filter.ApplyInPlace(tmp);
return(tmp);
}
/// <summary>
/// Aforge median filtration
/// </summary>
/// <param name="image"></param>
/// <param name="core">Median core size</param>
public static Image Median(this Image image, int core)
{
var bitmapImage = new Bitmap(image);
Median medianFilter = new Median(core);
medianFilter.ApplyInPlace(bitmapImage);
return(bitmapImage);
}
public void Merge(Median Group)
{
List<double> secondDoubleList = Group.DoubleList;
foreach (double d in secondDoubleList)
{
doubleList.Add(d);
}
}
public void mixedSequence()
{
double[] testInput = new double[] { -3, -2, -1, 0, 1, 2, 3 };
double output = Median.BruteForceMedian(testInput);
double expected = 0;
Assert.AreEqual(expected, output);
}
public void sequenceDescending()
{
double[] testInput = new double[] { 5, 4, 3, 2, 1 };
double output = Median.BruteForceMedian(testInput);
double expected = 3;
Assert.AreEqual(expected, output);
}
private EnsembleDistributionPredictor(IHostEnvironment env, ModelLoadContext ctx)
: base(env, RegistrationName, ctx)
{
PredictionKind = (PredictionKind)ctx.Reader.ReadInt32();
_probabilityCombiner = new Median(env);
InputType = InitializeMappers(out _mappers);
ComputeAveragedWeights(out _averagedWeights);
}
public void MedianShouldCalculateCorrectlyWithEvenMembers()
{
var func = new Median();
var args = FunctionsHelper.CreateArgs(1, 2, 3, 4);
var result = func.Execute(args, _parsingContext);
Assert.AreEqual(2.5d, result.Result);
}
public void TestMedianOddCount()
{
var m = new Median();
m.Init();
m.Accumulate(new Pair { Value = 1, Name = "1" });
m.Accumulate(new Pair { Value = 1, Name = "1" });
m.Accumulate(new Pair { Value = 5, Name = "5" });
m.Accumulate(new Pair { Value = 6, Name = "6" });
m.Accumulate(new Pair { Value = 1000, Name = "1000" });
m.Accumulate(new Pair { Value = 10000, Name = "10000" });
Assert.AreEqual("5 - 6", m.Terminate().Value); // Excel gives 5.5 here
}
public void TestMedianEvenCount()
{
var m = new Median();
m.Init();
m.Accumulate(new Pair { Value = 1, Name = "1" });
m.Accumulate(new Pair { Value = 1, Name = "1" });
m.Accumulate(new Pair { Value = 5, Name = "5" });
m.Accumulate(new Pair { Value = 7, Name = "7" });
m.Accumulate(new Pair { Value = 8, Name = "8" });
m.Accumulate(new Pair { Value = 1000, Name = "1000" });
m.Accumulate(new Pair { Value = 10000, Name = "10000" });
Assert.AreEqual("7", m.Terminate().Value);
}
public void Merge(Median Group)
{
_list.AddRange(Group._list);
}
public void Merge(Median Group)
{
// 新增一组数据.
dataList.AddRange(Group.dataList);
}