Ejemplo n.º 1
0
        public void testGetEstimatedFootprintInBytes()  
        {
            Histogram histogram = new Histogram(highestTrackableValue, numberOfSignificantValueDigits);
            /*
            *     largestValueWithSingleUnitResolution = 2 * (10 ^ numberOfSignificantValueDigits);
            *     subBucketSize = roundedUpToNearestPowerOf2(largestValueWithSingleUnitResolution);

            *     expectedHistogramFootprintInBytes = 512 +
            *          ({primitive type size} / 2) *
            *          (log2RoundedUp((highestTrackableValue) / subBucketSize) + 2) *
            *          subBucketSize
            */
            long largestValueWithSingleUnitResolution = 2 * (long) Math.Pow(10, numberOfSignificantValueDigits);
            int subBucketCountMagnitude = (int)Math.Ceiling(Math.Log(largestValueWithSingleUnitResolution) / Math.Log(2));
            int subBucketSize = (int) Math.Pow(2, (subBucketCountMagnitude));

            long expectedSize = 512 +
                    ((8 *
                     ((long)(
                            Math.Ceiling(
                             Math.Log(highestTrackableValue / subBucketSize)
                                     / Math.Log(2)
                            )
                           + 2)) *
                        (1 << (64 - MiscUtilities.numberOfLeadingZeros(2 * (long)Math.Pow(10, numberOfSignificantValueDigits))))
                     ) / 2);
            Assert.assertEquals(expectedSize, histogram.getEstimatedFootprintInBytes());
        }
Ejemplo n.º 2
0
      /// <summary>
      /// Add a plot of the 1D histogram. You should call the Refresh() function to update the control after all modification is complete.
      /// </summary>
      /// <param name="name">The name of the histogram</param>
      /// <param name="color">The drawing color</param>
      /// <param name="histogram">The 1D histogram to be drawn</param>
      public void AddHistogram(String name, System.Drawing.Color color, Histogram histogram)
      {
         Debug.Assert(histogram.Dimension == 1, "Only 1D histogram is supported");

         GraphPane pane = new GraphPane();
         // Set the Title
         pane.Title.Text = name;
         pane.XAxis.Title.Text = "Color Intensity";
         pane.YAxis.Title.Text = "Pixel Count";

         #region draw the histogram
         RangeF range = histogram.Ranges[0];
         int binSize = histogram.BinDimension[0].Size;
         float step = (range.Max - range.Min) / binSize;
         float start = range.Min;
         double[] bin = new double[binSize];
         for (int binIndex = 0; binIndex < binSize; binIndex++)
         {
            bin[binIndex] = start;
            start += step;
         }

         PointPairList pointList = new PointPairList(
            bin,
            Array.ConvertAll<float, double>(histogram.Data, System.Convert.ToDouble));

         pane.AddCurve(name, pointList, color);
         #endregion

         zedGraphControl1.MasterPane.Add(pane);
      }
	public static void Main() {
		bool reverse = false;
		modshogun.init_shogun_with_defaults();
		int order = 3;
		int gap = 4;

		String[] fm_train_dna = Load.load_dna("../data/fm_train_dna.dat");

		StringCharFeatures charfeat = new StringCharFeatures(fm_train_dna, EAlphabet.DNA);
		StringWordFeatures feats = new StringWordFeatures(charfeat.get_alphabet());
		feats.obtain_from_char(charfeat, order-1, order, gap, reverse);

		Histogram histo = new Histogram(feats);
		histo.train();

		double[] histogram = histo.get_histogram();

		foreach(double item in histogram) {
			Console.Write(item);
		}
		//int  num_examples = feats.get_num_vectors();
		//int num_param = histo.get_num_model_parameters();

		//double[,] out_likelihood = histo.get_log_likelihood();
		//double out_sample = histo.get_log_likelihood_sample();

		modshogun.exit_shogun();
	}
Ejemplo n.º 4
0
 /// <summary>
 /// Display the specific histogram
 /// </summary>
 /// <param name="hist">The histogram to be displayed</param>
 /// <param name="title">The name of the histogram</param>
 public static void Show(Histogram hist, string title)
 {
    HistogramViewer viewer = new HistogramViewer();
    viewer.HistogramCtrl.AddHistogram(title, Color.Black, hist);
    viewer.HistogramCtrl.Refresh();
    viewer.Show();
 }
        static HistogramDataAccessTest()
        {
            histogram = new Histogram(highestTrackableValue, numberOfSignificantValueDigits);
            scaledHistogram = new Histogram(1000, highestTrackableValue * 512, numberOfSignificantValueDigits);
            rawHistogram = new Histogram(highestTrackableValue, numberOfSignificantValueDigits);
            scaledRawHistogram = new Histogram(1000, highestTrackableValue * 512, numberOfSignificantValueDigits);
            // Log hypothetical scenario: 100 seconds of "perfect" 1msec results, sampled
            // 100 times per second (10,000 results), followed by a 100 second pause with
            // a single (100 second) recorded result. Recording is done indicating an expected
            // interval between samples of 10 msec:
            for (int i = 0; i < 10000; i++) 
            {
                histogram.recordValueWithExpectedInterval(1000 /* 1 msec */, 10000 /* 10 msec expected interval */);
                scaledHistogram.recordValueWithExpectedInterval(1000 * 512 /* 1 msec */, 10000 * 512 /* 10 msec expected interval */);
                rawHistogram.recordValue(1000 /* 1 msec */);
                scaledRawHistogram.recordValue(1000 * 512/* 1 msec */);
            }
            histogram.recordValueWithExpectedInterval(100000000L /* 100 sec */, 10000 /* 10 msec expected interval */);
            scaledHistogram.recordValueWithExpectedInterval(100000000L * 512 /* 100 sec */, 10000 * 512 /* 10 msec expected interval */);
            rawHistogram.recordValue(100000000L /* 100 sec */);
            scaledRawHistogram.recordValue(100000000L * 512 /* 100 sec */);

            postCorrectedHistogram = rawHistogram.copyCorrectedForCoordinatedOmission(10000 /* 10 msec expected interval */);
            postCorrectedScaledHistogram = scaledRawHistogram.copyCorrectedForCoordinatedOmission(10000 * 512 /* 10 msec expected interval */);
        }
Ejemplo n.º 6
0
        public void PermutationDistribution()
        {
            // We want to test that GetRandomPermutation actually samples all permutations equally

            // Don't let n get too big or we will have a ridiculously large number of bins
            for (int n = 2; n < 8; n++) {

                // Build a mapping that assign each permutation a unique integer index from 0 to (n! - 1)
                Dictionary<Permutation, int> index = new Dictionary<Permutation, int>();
                int count = 0;
                foreach (Permutation p in Permutation.Permutations(n)) {
                    index.Add(p, count);
                    count++;
                }

                // Create a historgram of randomly generated permutation indexes
                Histogram histogram = new Histogram(count);
                Random rng = new Random(2);
                for (int i = 0; i < 8 * count; i++) {
                    Permutation p = Permutation.GetRandomPermutation(n, rng);
                    histogram.Bins[index[p]].Increment();
                }

                //for (int i = 0; i < count; i++) {
                //    Console.WriteLine("{0} {1}", i, bins[i].Counts);
                //}

                TestResult result = histogram.ChiSquaredTest(new DiscreteUniformDistribution(0, count - 1));
                Console.WriteLine(result.RightProbability);
                Assert.IsTrue(result.RightProbability > 0.01);

            }
        }
Ejemplo n.º 7
0
    internal static ArrayList run(IList para)
    {
        bool reverse = false;
        modshogun.init_shogun_with_defaults();
        int order = (int)((int?)para[0]);
        int gap = (int)((int?)para[1]);

        string[] fm_train_dna = Load.load_dna("../data/fm_train_dna.dat");

        StringCharFeatures charfeat = new StringCharFeatures(fm_train_dna, DNA);
        StringWordFeatures feats = new StringWordFeatures(charfeat.get_alphabet());
        feats.obtain_from_char(charfeat, order-1, order, gap, reverse);

        Histogram histo = new Histogram(feats);
        histo.train();

        histo.get_histogram();

        int num_examples = feats.get_num_vectors();
        int num_param = histo.get_num_model_parameters();

        DoubleMatrix out_likelihood = histo.get_log_likelihood();
        double out_sample = histo.get_log_likelihood_sample();

        ArrayList result = new ArrayList();
        result.Add(histo);
        result.Add(out_sample);
        result.Add(out_likelihood);
        modshogun.exit_shogun();
        return result;
    }
Ejemplo n.º 8
0
        public void Evaluate_NormalSample()
        {
            var sample = Enumerable
                .Range(1, 10)
                .Select(n => new { p = Functions.NormalDistribution(n, 2.87f, 5), n = n })
                .SelectMany(x => Enumerable.Range(1, (int)(x.p * 100)).Select(n => (x.n).OutOf(10)))
                .ToList()
                .AsQueryable();

            var hist = new Histogram(0.02f);
            var kde = new KernelDensityEstimator(0.02f);
            var histF = hist.Evaluate(sample);
            var kdeF = kde.Evaluate(sample);
            var stdDevMu = Functions.MeanStdDev(sample);

            Console.WriteLine("Mean\t{0}", stdDevMu.Item1);
            Console.WriteLine("StdDev\t{0}", stdDevMu.Item2);

            var hRes = Enumerable.Range(1, 10).Select(n => new { n = n, p = histF(n.OutOf(10)) });
            var kRes = Enumerable.Range(1, 10).Select(n => kdeF(n.OutOf(10))).Normalise().ToList();
            int i = 0;

            foreach (var x in hRes)
            {
                var kr = kRes[i++];
                Console.WriteLine("{0}\t{1}\t{2}", x.n, x.p.Value, kr.Value);
                Assert.That(Math.Round(x.p.Value, 4), Is.EqualTo(Math.Round(kr.Value, 4)));
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        ///   Constructs a new instance of the HistogramView.
        /// </summary>
        /// 
        public HistogramView()
        {
            InitializeComponent();

            this.histogram = new Histogram();
            graphBars = new ZedGraph.BarItem(String.Empty);
            graphBars.Color = Color.DarkBlue;
            zedGraphControl.GraphPane.Title.FontSpec.IsBold = true;
            zedGraphControl.GraphPane.Title.FontSpec.Size = 32f;
            zedGraphControl.GraphPane.Title.IsVisible = true;
            zedGraphControl.GraphPane.XAxis.Type = AxisType.Text;
            zedGraphControl.GraphPane.XAxis.Title.IsVisible = false;
            zedGraphControl.GraphPane.XAxis.MinSpace = 0;
            zedGraphControl.GraphPane.XAxis.MajorGrid.IsVisible = false;
            zedGraphControl.GraphPane.XAxis.MinorGrid.IsVisible = false;
            zedGraphControl.GraphPane.XAxis.MajorTic.IsBetweenLabels = true;
            zedGraphControl.GraphPane.XAxis.MajorTic.IsInside = false;
            zedGraphControl.GraphPane.XAxis.MajorTic.IsOpposite = false;
            zedGraphControl.GraphPane.XAxis.MinorTic.IsAllTics = false;
            zedGraphControl.GraphPane.XAxis.Scale.FontSpec.IsBold = true;
            zedGraphControl.GraphPane.XAxis.Scale.FontSpec.IsAntiAlias = true;
            zedGraphControl.GraphPane.YAxis.MinorTic.IsAllTics = false;
            zedGraphControl.GraphPane.YAxis.MajorTic.IsOpposite = false;
            zedGraphControl.GraphPane.YAxis.Title.Text = "Frequency";
            zedGraphControl.GraphPane.YAxis.Title.FontSpec.Size = 24f;
            zedGraphControl.GraphPane.YAxis.Title.FontSpec.IsBold = true;
            zedGraphControl.GraphPane.Border.IsVisible = false;
            zedGraphControl.GraphPane.BarSettings.MinBarGap = 0;
            zedGraphControl.GraphPane.BarSettings.MinClusterGap = 0;
            zedGraphControl.GraphPane.CurveList.Add(graphBars);
        }
Ejemplo n.º 10
0
        public void Analyse_TimeSeries()
        {
            var now = DateTime.UtcNow;
            var now_plusx = new Func<int, DateTime>(x => now.AddHours(x));
            var width = TimeSpan.FromHours(1);
            var hist = new Histogram(width.TotalMilliseconds);

            var sample = new[] {
                new { date = now, name = "a" },
                new { date = now_plusx(1), name = "b" },
                new { date = now_plusx(1), name = "c" },
                new { date = now_plusx(3), name = "d" },
                new { date = now_plusx(4), name = "e" },
                new { date = now_plusx(6), name = "f" },
                new { date = now_plusx(6), name = "g" },
                new { date = now_plusx(8), name = "h" }
            }.AsQueryable();

            var histSample = hist.Analyse(sample, v => v.date);
            
            Assert.That(histSample.Min, Is.EqualTo(now));
            Assert.That(histSample.Max, Is.EqualTo(now_plusx(8)));
            Assert.That(histSample.Total, Is.EqualTo(sample.Count()));
            Assert.That(histSample.Width, Is.EqualTo(width));
            Assert.That(histSample.Bins.Count, Is.EqualTo(9));
            Assert.That(histSample.Bins[0], Is.EqualTo(1));
            Assert.That(histSample.Bins[1], Is.EqualTo(2));
            Assert.That(histSample.Bins[6], Is.EqualTo(2));
        }
Ejemplo n.º 11
0
        public void Hystogram_Dump_1()
        {
            const int CNT = 100000;
              const int MAX_RND = 100;

              var hist = new Histogram<int>("Random Histogram",
                new Dimension<int>(
                    "ValBucket",
                    partCount: MAX_RND,
                    partitionFunc: (dim, v) => {
                        return v;// % 100;
                    },
                    partitionNameFunc: (i) => i.ToString()
                )
            );

             // var rnd = new Random();
              for(var i=0; i<CNT; i++)
              {
             //   var r = rnd.Next(100);// ExternalRandomGenerator.Instance.NextScaledRandomInteger(0,100);
            var r = ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, MAX_RND);
            hist.Sample( r );
             //   ExternalRandomGenerator.Instance.FeedExternalEntropySample( (int)NFX.OS.Computer.GetMemoryStatus().AvailablePhysicalBytes);
              }

              string output = hist.ToStringReport();
              Console.WriteLine( output );

              var countPerRandomSeed = CNT / (double)MAX_RND;
              var tolerance = countPerRandomSeed * 0.15d;//Guarantees uniform random distribution. The lower the number, the more uniform gets
              foreach(var he in hist)
               Assert.IsTrue( he.Count >countPerRandomSeed-tolerance && he.Count < countPerRandomSeed+tolerance);
        }
Ejemplo n.º 12
0
 private static void AssertBinCounts(Histogram histogram, int[] counts)
 {
     Assert.IsTrue(histogram.BelowRangeBin.Counts == counts[0]);
     for (int i = 0; i < histogram.Bins.Count; i++) {
         Assert.IsTrue(histogram.Bins[i].Counts == counts[i + 1]);
     }
     Assert.IsTrue(histogram.AboveRangeBin.Counts == counts[histogram.Bins.Count + 1]);
 }
Ejemplo n.º 13
0
 protected Metric(double mean, double min, double max, long count, double accumulatedVariance, Histogram histogram)
 {
     Mean = mean;
     Min = min;
     Max = max;
     Count = count;
     this.accumulatedVariance = accumulatedVariance;
     Histogram = histogram;
 }
Ejemplo n.º 14
0
 public void testConstructionArgumentGets()  
 {
     Histogram histogram = new Histogram(highestTrackableValue, numberOfSignificantValueDigits);
     Assert.assertEquals(1, histogram.getLowestTrackableValue());
     Assert.assertEquals(highestTrackableValue, histogram.getHighestTrackableValue());
     Assert.assertEquals(numberOfSignificantValueDigits, histogram.getNumberOfSignificantValueDigits());
     Histogram histogram2 = new Histogram(1000, highestTrackableValue, numberOfSignificantValueDigits);
     Assert.assertEquals(1000, histogram2.getLowestTrackableValue());
 }
Ejemplo n.º 15
0
        public CorrelationScoreTable(ScoreMethod method, int intensityBins, double[] binEdges)
        {
            _method = method;
            _binEdges = binEdges;
            IntensityBins = null;
            _intensityBinCount = intensityBins;
            WorstScore = new Probability<int>(0);

            _intensityHistogram = new Histogram<FitScore>(new CompareFitScoreByIntensity());
        }
Ejemplo n.º 16
0
 public TimeHistogram(
     string title,
     string dim1Name,
     PartitionFunc<double> dim1PartitionFunc = null,
     PartitionNameFunc dim1PartitionNameFunc = null)
 {
     m_Hist = new Histogram<double>(title,
         new TimeDimension(
             dim1Name, TimeDimension.DEFAULT_PART_COUNT,
             dim1PartitionFunc, dim1PartitionNameFunc));
 }
        public void CanCreateCategoricalFromHistogram()
        {
            double[] smallDataset = { 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5 };
            Histogram hist = new Histogram(smallDataset, 10, 0.0, 10.0);
            var m = new Categorical(hist);

            for (int i = 0; i <= m.Maximum; i++)
            {
                AssertEx.AreEqual<double>(1.0/10.0, m.P[i]);
            }
        }
Ejemplo n.º 18
0
        public void CanCreateMultinomialFromHistogram()
        {
            double[] smallDataset = { 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5 };
            var hist = new Histogram(smallDataset, 10, 0.0, 10.0);
            var m = new Multinomial(hist, 7);

            foreach (var t in m.P)
            {
                Assert.AreEqual(1.0, t);
            }
        }
Ejemplo n.º 19
0
 public TimeHistogram(
     string title,
     string dim1Name,
     int    dim1PartCount,
     PartitionFunc<double>   dim1PartitionFunc = null,
     PartitionNameFunc       dim1PartitionNameFunc = null)
 {
     m_Hist = new Histogram<double>(title,
         new TimeDimension(
             dim1Name, dim1PartCount, dim1PartitionFunc, dim1PartitionNameFunc));
 }
Ejemplo n.º 20
0
 public void Save(string v, Histogram histogram, bool shouldCompress = false)
 {
     stage.Unlock(true);
     if (shouldCompress)
     {
         Image quantized = quantizer.QuantizeImage(bmp, 128, 0, histogram, 128);
         quantized.Save(v, System.Drawing.Imaging.ImageFormat.Png);
     } else
     {
         bmp.Save(v, System.Drawing.Imaging.ImageFormat.Png);
     }
 }
Ejemplo n.º 21
0
		void OnEnable()
		{
			p_CurrentChannel = serializedObject.FindProperty("e_CurrentChannel");
			p_Logarithmic = serializedObject.FindProperty("e_Logarithmic");
			p_AutoRefresh = serializedObject.FindProperty("e_AutoRefresh");

			m_Target = target as Histogram;
			m_Target.e_OnFrameEnd = UpdateHistogram;
			m_Target.InternalForceRefresh();

			InternalEditorUtility.RepaintAllViews();
		}
Ejemplo n.º 22
0
 public static Histogram<string> ParseString(string line)
 {
     string[] splitted = line.Split(' ');
     Histogram<string> dic = new Histogram<string>();
     foreach (string elt in splitted)
     {
         if (elt.Contains(":"))
             dic.UpdateKey(elt.Split(':')[0], Convert.ToDouble(elt.Split(':')[1].Replace('.', ',')));
         else
             dic.UpdateKey(elt, 1);
     }
     return dic;
 }
Ejemplo n.º 23
0
        public void Analyse_SimpleSample()
        {
            var hist = new Histogram(1);
            var sample = new[] { 1, 4, 4, 5, 5, 5, 6, 6, 8, 10 }.Select(n => n.OutOf(1)).ToList().AsQueryable();
            var histSample = hist.Analyse(sample);

            Assert.That(histSample.Min, Is.EqualTo(1));
            Assert.That(histSample.Total, Is.EqualTo(sample.Count()));
            Assert.That(histSample.Width, Is.EqualTo(1));
            Assert.That(histSample.Bins.Count, Is.EqualTo(10));
            Assert.That(histSample.Bins[0], Is.EqualTo(1));
            Assert.That(histSample.Bins[9], Is.EqualTo(1));
        }
Ejemplo n.º 24
0
		protected override Profile [] Prepare (Gdk.Pixbuf image)
		{
			Histogram hist = new Histogram (image);
			tables = new GammaTable [3];

			for (int channel = 0; channel < tables.Length; channel++) {
				int high, low;
				hist.GetHighLow (channel, out high, out low);
				System.Console.WriteLine ("high = {0}, low = {1}", high, low);
				tables [channel] = StretchChannel (255, low / 255.0, high / 255.0); 
			}

			return new Profile [] { new Profile (IccColorSpace.Rgb, tables) };
		}
        protected override List<Cms.Profile> GenerateAdjustments()
        {
            List <Cms.Profile> profiles = new List <Cms.Profile> ();
            Histogram hist = new Histogram (Input);
            tables = new GammaTable [3];

            for (int channel = 0; channel < tables.Length; channel++) {
                int high, low;
                hist.GetHighLow (channel, out high, out low);
                Log.DebugFormat ("high = {0}, low = {1}", high, low);
                tables [channel] = StretchChannel (255, low / 255.0, high / 255.0);
            }
            profiles.Add (new Cms.Profile (IccColorSpace.Rgb, tables));
            return profiles;
        }
Ejemplo n.º 26
0
        public PrecursorOffsetFrequencyTable(double searchWidth, int charge = 1, double binWidth = 1.005)
        {
            _offsetCounts = new Histogram<double>();
            _searchWidth = searchWidth;
            _binWidth = binWidth;
            Charge = charge;
            Total = 0;
            GenerateEdges();
            BaseIonType[] baseIons = { BaseIonType.Y };
            NeutralLoss[] neutralLosses = { NeutralLoss.NoLoss };

            var ionTypeFactory = new IonTypeFactory(baseIons, neutralLosses, charge);

            _precursorIonTypes = ionTypeFactory.GetAllKnownIonTypes().ToList();
        }
Ejemplo n.º 27
0
        public void ComputeTest2()
        {
            HistogramView target = new HistogramView();

            Histogram histogram = new Histogram();
            histogram.Compute(new double[] { 200.0, 200.0, 200.0 });

            target.DataSource = null;

            target.DataSource = histogram;
            target.TrackBar.Maximum = 30;
            target.TrackBar.Minimum = 0;
            target.TrackBar.Value = 21;

            target.DataSource = null;
        }
Ejemplo n.º 28
0
        public void BuildHistogram(Aurigma.GraphicsMill.Bitmap bitmap, int mode)
        {
            mHist = bitmap.Statistics.GetLuminosityHistogram();
            rHist = bitmap.Channels[Channel.Red].Statistics.GetSumHistogram();
            gHist = bitmap.Channels[Channel.Green].Statistics.GetSumHistogram();
            bHist = bitmap.Channels[Channel.Blue].Statistics.GetSumHistogram();

            var pixelx = bitmap.Width;
            var pixely = bitmap.Height;
            int totalPixels = pixelx * pixely;

            buildPeaks(mHist, totalPixels);
            buildRedPeaks(rHist, totalPixels);
            buildBluePeaks(bHist, totalPixels);
            buildGreenPeaks(gHist, totalPixels);
        }
Ejemplo n.º 29
0
        public void Evaluate_RandomSample()
        {
            foreach (var i in Enumerable.Range(0, 10))
            {
                var hist = new Histogram();
                var sample = Enumerable.Range(1, 100).Select(n => Fraction.Random()).ToList().AsQueryable();
                var histF = hist.Evaluate(sample);

                foreach (var h in hist.Analyse(sample).Bins)
                {
                    Console.WriteLine("{0}={1}", h.Key, h.Value);
                }

                var p = histF((1).OutOf(32));
            }
        }
Ejemplo n.º 30
0
        private void buildRedPeaks(Histogram histogram, int totalPixels)
        {
            redPeaks.Clear();
            for (int i = 0; i < histogram.Length; i++)
            {
                double thisPop = rHist[i];
                double thisPeak = (thisPop / totalPixels) * 100;

                if ((i == 0) || (i == 255))
                {
                    thisPeak = 0;
                }

                int peakValue = Convert.ToInt32(thisPeak * 100);
                redPeaks.Add(peakValue);
            }
        }
 public LatencyStepEventHandler_V3(FunctionStep functionStep, Histogram histogram, long nanoTimeCost)
 {
     _functionStep = functionStep;
     _histogram    = histogram;
     _nanoTimeCost = nanoTimeCost;
 }
Ejemplo n.º 32
0
        public PerformanceReportViewModel(filterReportDS data, ReportSettings settings, IDialogCoordinator dialogService) : base(null)
        {
            Data      = data;
            Settings  = settings;
            CopyChart = new RelayCommand <PlotView>(x => x.CopyToClipboard());
            SaveChart = new RelayCommand <PlotView>(x =>
            {
                try
                {
                    x.SaveAsPNG();
                }
                catch (Exception ex)
                {
                    dialogService.ShowMessageAsync(this, "Error saving image", ex.Message);
                }
            });

            //Calculate best fit line for the return vs size scatter chart
            double rsq;

            double[] b;
            MathUtils.MLR(
                Data.positionSizesVsReturns.Select(x => x.size).ToList(),
                Data.positionSizesVsReturns.Select(x => x.ret).ToList(),
                out b,
                out rsq);

            _retVsSizeBestFitLineConstant = b[0];
            _retVsSizeBestFitLineSlope    = b[1];

            //Calculate best fit line for the return vs length scatter chart
            MathUtils.MLR(
                Data.tradeLengthsVsReturns.Select(x => x.ret).ToList(),
                Data.tradeLengthsVsReturns.Select(x => x.length).ToList(),
                out b,
                out rsq);

            _retVsLengthBestFitLineConstant = b[0];
            _retVsLengthBestFitLineSlope    = b[1];

            //Histograms
            try
            {
                var sharpeHistogram = new Histogram(Enumerable.Select(Data.MCRatios, x => x.Sharpe), 20);
                MCSharpeHistogramBuckets = sharpeHistogram.GetBuckets();

                var marHistogram = new Histogram(Enumerable.Select(Data.MCRatios, x => x.MAR), 20);
                MCMARHistogramBuckets = marHistogram.GetBuckets();

                var kRatioHistogram = new Histogram(Enumerable.Select(Data.MCRatios, x => x.KRatio), 20);
                MCKRatioHistogramBuckets = kRatioHistogram.GetBuckets("0");
            }
            catch { } //Yeah this is bad, there's a ton of stupid errors that are not easy to check for...re-do this in the future

            //Benchmark stats
            if (Settings.Benchmark != null)
            {
                BenchmarkAlpha            = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).alpha;
                BenchmarkBeta             = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).beta;
                BenchmarkCorrelation      = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).correlation;
                BenchmarkRSquare          = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).rsquare;
                BenchmarkInformationRatio = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).informationRatio;
                BenchmarkActiveReturn     = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).activeReturn;
                BenchmarkTrackingError    = ((filterReportDS.benchmarkStatsRow)Data.benchmarkStats.Rows[0]).trackingError;
                BenchmarkInstrument       = Settings.Benchmark.Name;
            }

            //avg cumulative winner/loser returns by day in trade
            AvgCumulativeWinnerRets =
                Enumerable.Select(data
                                  .AverageDailyRets
                                  .Where(x => !x.IswinnersRetsNull()), x => new KeyValuePair <int, double>(x.day, x.winnersRets))
                .ToList();

            AvgCumulativeLoserRets =
                Enumerable.Select(data
                                  .AverageDailyRets
                                  .Where(x => !x.IslosersRetsNull()), x => new KeyValuePair <int, double>(x.day, x.losersRets))
                .ToList();

            //build plot models
            CreatePLByStrategyChartModel();
            CreateCapitalUsageByStrategyChartModel();
            CreateRelativeCapitalUsageByStrategyChartModel();
            CreateRoacByStrategyChartModel();
            CreateMdsChartModel();
            CreateTradeRetsByDayAndHourChartModel();
        }
Ejemplo n.º 33
0
        public TimerValue Scale(TimeUnit rate, TimeUnit duration)
        {
            var durationFactor = DurationUnit.ScalingFactorFor(duration);

            return(new TimerValue(Rate.Scale(rate), Histogram.Scale(durationFactor), ActiveSessions, duration));
        }
Ejemplo n.º 34
0
    public static void Draw_HISTOGRAM_LINE_Y(float _x, float _y, float _w, float _h, Color _col_MIN, Color _col_MAX, bool _alphaFade, Histogram _histogram)
    {
        int   _TOTAL_BINS = _histogram.binCount;
        float _DIV        = _h / _TOTAL_BINS;

        for (int i = 0; i < _TOTAL_BINS; i++)
        {
            float _CURRENT   = _y + (_DIV * i);
            float _BIN_VALUE = _histogram.Get_Value(i);
            Color _COL       = Color.Lerp(_col_MIN, _col_MAX, _BIN_VALUE);
            GL_DRAW.Draw_LINE(_x, _CURRENT, _x + (_w * _histogram.Get_Value(i)), _CURRENT, (_alphaFade) ? COL.Set_alphaStrength(_COL, _BIN_VALUE) : _COL);
        }
    }
Ejemplo n.º 35
0
        /// <summary>
        /// Gather horizontal intensity statistics for specified image.
        /// </summary>
        ///
        /// <param name="image">Source image.</param>
        ///
        private void ProcessImage(UnmanagedImage image)
        {
            PixelFormat pixelFormat = image.PixelFormat;
            // get image dimension
            int width  = image.Width;
            int height = image.Height;

            red = green = blue = gray = null;

            // do the job
            unsafe
            {
                // check pixel format
                if (pixelFormat == PixelFormat.Format8bppIndexed)
                {
                    // 8 bpp grayscale image
                    byte *p      = (byte *)image.ImageData.ToPointer( );
                    int   offset = image.Stride - width;

                    // histogram array
                    int[] g = new int[width];

                    // for each pixel
                    for (int y = 0; y < height; y++)
                    {
                        // for each pixel
                        for (int x = 0; x < width; x++, p++)
                        {
                            g[x] += *p;
                        }
                        p += offset;
                    }

                    // create historgram for gray level
                    gray = new Histogram(g);
                }
                else if (pixelFormat == PixelFormat.Format16bppGrayScale)
                {
                    // 16 bpp grayscale image
                    byte *basePtr = (byte *)image.ImageData.ToPointer( );
                    int   stride  = image.Stride;

                    // histogram array
                    int[] g = new int[width];

                    // for each pixel
                    for (int y = 0; y < height; y++)
                    {
                        ushort *p = (ushort *)(basePtr + stride * y);

                        // for each pixel
                        for (int x = 0; x < width; x++, p++)
                        {
                            g[x] += *p;
                        }
                    }

                    // create historgram for gray level
                    gray = new Histogram(g);
                }
                else if (
                    (pixelFormat == PixelFormat.Format24bppRgb) ||
                    (pixelFormat == PixelFormat.Format32bppRgb) ||
                    (pixelFormat == PixelFormat.Format32bppArgb))
                {
                    // 24/32 bpp color image
                    byte *p         = (byte *)image.ImageData.ToPointer( );
                    int   pixelSize = (pixelFormat == PixelFormat.Format24bppRgb) ? 3 : 4;
                    int   offset    = image.Stride - width * pixelSize;

                    // histogram arrays
                    int[] r = new int[width];
                    int[] g = new int[width];
                    int[] b = new int[width];

                    // for each line
                    for (int y = 0; y < height; y++)
                    {
                        // for each pixel
                        for (int x = 0; x < width; x++, p += pixelSize)
                        {
                            r[x] += p[RGB.R];
                            g[x] += p[RGB.G];
                            b[x] += p[RGB.B];
                        }
                        p += offset;
                    }

                    // create histograms
                    red   = new Histogram(r);
                    green = new Histogram(g);
                    blue  = new Histogram(b);
                }
                else if (
                    (pixelFormat == PixelFormat.Format48bppRgb) ||
                    (pixelFormat == PixelFormat.Format64bppArgb))
                {
                    // 48/64 bpp color image
                    byte *basePtr   = (byte *)image.ImageData.ToPointer( );
                    int   stride    = image.Stride;
                    int   pixelSize = (pixelFormat == PixelFormat.Format48bppRgb) ? 3 : 4;

                    // histogram arrays
                    int[] r = new int[width];
                    int[] g = new int[width];
                    int[] b = new int[width];

                    // for each line
                    for (int y = 0; y < height; y++)
                    {
                        ushort *p = (ushort *)(basePtr + stride * y);

                        // for each pixel
                        for (int x = 0; x < width; x++, p += pixelSize)
                        {
                            r[x] += p[RGB.R];
                            g[x] += p[RGB.G];
                            b[x] += p[RGB.B];
                        }
                    }

                    // create histograms
                    red   = new Histogram(r);
                    green = new Histogram(g);
                    blue  = new Histogram(b);
                }
            }
        }
Ejemplo n.º 36
0
        public static Histogram ToHistogram(this IEnumerable <ExecutionHistoryEntry> entries, bool detailed = false)
        {
            if (entries == null || entries.Any() == false)
            {
                return(null);
            }

            var hst = new Histogram();

            foreach (var entry in entries)
            {
                TimeSpan?duration = null;
                string   cssClass = "";
                string   state    = "Finished";

                if (entry.FinishedTimeUtc != null)
                {
                    duration = entry.FinishedTimeUtc - entry.ActualFireTimeUtc;
                }

                if (entry.Vetoed == false && entry.FinishedTimeUtc == null) // still running
                {
                    duration = DateTime.UtcNow - entry.ActualFireTimeUtc;
                    cssClass = "running";
                    state    = "Running";
                }

                if (entry.Vetoed)
                {
                    state = "Vetoed";
                }

                string durationHtml = "", delayHtml = "", errorHtml = "", detailsHtml = "";

                if (!string.IsNullOrEmpty(entry.ErrorMessage))
                {
                    state     = "Failed";
                    cssClass  = "failed";
                    errorHtml = $"<p class=\"text-left text-capitalize\">Error: <b>{entry.ErrorMessage}</b></p>";
                }

                if (duration != null)
                {
                    durationHtml = $"<p class=\"text-left text-capitalize\">Duration: <b>{duration.ToNiceFormat()}</b></p>";
                }

                if (entry.ScheduledFireTimeUtc != null)
                {
                    delayHtml = $"<p class=\"text-left text-capitalize\">Delay: <b>{(entry.ActualFireTimeUtc - entry.ScheduledFireTimeUtc).ToNiceFormat()}</b></p>";
                }

                if (detailed)
                {
                    detailsHtml = $"<p class=\"text-left text-capitalize\">Job: <b>{entry.JobName}</b></p>" +
                                  $"<p class=\"text-left text-capitalize\">Trigger: <b>{entry.TriggerName}</b></p>";
                }

                hst.AddBar(duration?.TotalSeconds ?? 1,
                           //$"<div class=\"panel panel-default\" style=\"width: 300px;height: 150px;\"><div class=\"panel-body\">" +
                           $"{detailsHtml}" +
                           $"<p class=\"text-left text-capitalize\">Fired: <b>{entry.ActualFireTimeUtc.ToDefaultFormat()} UTC</b></p>" +
                           $"{durationHtml}{delayHtml}" +
                           $"<p class=\"text-left text-capitalize\">State: <b>{state}</b></p>" +
                           $"{errorHtml}",
                           //+$"</div></div>",
                           cssClass);
            }

            return(hst);
        }
Ejemplo n.º 37
0
        /// <summary>
        /// 处理监控事项
        /// </summary>
        /// <param name="services"></param>
        void MetricsHandle(IServiceCollection services)
        {
            var metricsHub = new MetricsHub();

            //counter
            metricsHub.AddCounter("/register", Metrics.CreateCounter("business_register_user", "注册用户数。"));
            metricsHub.AddCounter("/order", Metrics.CreateCounter("business_order_total", "下单总数。"));
            metricsHub.AddCounter("/pay", Metrics.CreateCounter("business_pay_total", "支付总数。"));
            metricsHub.AddCounter("/ship", Metrics.CreateCounter("business_ship_total", "发货总数。"));

            //gauge
            var orderGauge = Metrics.CreateGauge("business_order_count", "当前下单数量。");
            var payGauge   = Metrics.CreateGauge("business_pay_count", "当前支付数量。");
            var shipGauge  = Metrics.CreateGauge("business_ship_count", "当前发货数据。");

            metricsHub.AddGauge("/order", new Dictionary <string, Gauge> {
                { "+", orderGauge }
            });
            metricsHub.AddGauge("/pay", new Dictionary <string, Gauge> {
                { "-", orderGauge },
                { "+", payGauge }
            });
            metricsHub.AddGauge("/ship", new Dictionary <string, Gauge> {
                { "+", shipGauge },
                { "-", payGauge }
            });
            //summary 百分位数[在一组由小到大的数字中,某个数字大于80%的数字,这个数字就第80个的百分位数]

            /*0.5-quantile后面是0.05,0.9-quantile后面是0.01,而0.95后面是0.005,而0.99后面是0.001。这些是我们设置的能容忍的误差。0.5-quantile: 0.05意思是允许最后的误差不超过0.05。假设某个0.5-quantile的值为120,由于设置的误差为0.05,所以120代表的真实quantile是(0.45, 0.55)范围内的某个值。
             */
            var orderSummary = Metrics
                               .CreateSummary("business_order_summary", "10分钟内的订单数量",
                                              new SummaryConfiguration
            {
                Objectives = new[]
                {
                    new QuantileEpsilonPair(0.1, 0.05),
                    new QuantileEpsilonPair(0.3, 0.05),
                    new QuantileEpsilonPair(0.5, 0.05),
                    new QuantileEpsilonPair(0.7, 0.05),
                    new QuantileEpsilonPair(0.9, 0.05),
                }
            });

            metricsHub.AddSummary("/order", orderSummary);

            //histogram

            /*
             * grafana中  histogram_quantile(0.95, rate(business_order_histogram_seconds_bucket[5h]))
             * 95%的订单金额小于等于这个值
             */

            var orderHistogram = Metrics.CreateHistogram("business_order_histogram", "订单直方图。",
                                                         new HistogramConfiguration
            {
                //Buckets = Histogram.ExponentialBuckets(start: 1000, factor: 2, count: 5)
                Buckets = Histogram.LinearBuckets(start: 1000, width: 1000, count: 6)
            });

            metricsHub.AddHistogram("/order", orderHistogram);



            services.AddSingleton(metricsHub);
        }
Ejemplo n.º 38
0
 /// <summary>
 /// Initializes a new instance of the SnapshotHistgramVerifier class, with the tolerance histogram curve initialized to the specified tolerance value.
 /// </summary>
 /// <param name="tolerance">The tolerance Histogram to use for verification.</param>
 public SnapshotHistogramVerifier(Histogram tolerance)
 {
     this.Tolerance = tolerance;
 }
Ejemplo n.º 39
0
 /// <summary>
 /// Initializes a new instance of the SnapshotHistgramVerifier class, with the tolerance histogram curve initialized to zero tolerance for non-black values.
 /// </summary>
 public SnapshotHistogramVerifier()
 {
     Tolerance = new Histogram();
 }
Ejemplo n.º 40
0
        public void CanAddBucket()
        {
            var h = new Histogram();

            h.AddBucket(new Bucket(0.0, 1.0));
        }
Ejemplo n.º 41
0
 /// <summary>
 /// Collects all sum values of a histogram recorded across both unlabeled and labeled metrics.
 /// </summary>
 internal static IEnumerable <double> CollectAllSumValues(this Histogram histogram, bool excludeUnlabeled = false)
 {
     return(CollectAllMetrics <Histogram, Histogram.Child, IHistogram, double>(histogram, c => c.Sum, excludeUnlabeled));
 }
Ejemplo n.º 42
0
        public void RootsTest3(double step)
        {
            Test.Begin("cubic roots tests");
            var    range   = new Range1d(-1.0, 1.0);
            double half    = 0.5 * step;
            double epsilon = Fun.Cbrt(Constant <double> .PositiveTinyValue);

            Report.Value("epsilon", epsilon);
            var  stats                 = Stats <bool> .ComputeMaxMean;
            var  uniqueStats           = Stats <bool> .ComputeMaxMean;
            var  multipleStats         = Stats <bool> .ComputeMaxMean;
            var  residualStats         = Stats <bool> .ComputeMaxMean;
            var  uniqueHisto           = new Histogram(-16, -8, 8);
            var  multipleHisto         = new Histogram(-16, 0, 16);
            var  uniqueResidualStats   = Stats <bool> .ComputeMaxMean;
            var  multipleResidualStats = Stats <bool> .ComputeMaxMean;
            long multipleCount         = 0;

            for (double x0 = range.Min; x0 < range.Max + half; x0 += step)
            {
                var p0 = new double[] { -x0, 1.0 };
                for (double x1 = range.Min; x1 < range.Max + half; x1 += step)
                {
                    var p1  = new double[] { -x1, 1.0 };
                    var p01 = Polynomial.Multiply(p0, p1);
                    for (double x2 = range.Min; x2 < range.Max + half; x2 += step)
                    {
                        var p2   = new double[] { -x2, 1.0 };
                        var p012 = Polynomial.Multiply(p01, p2);

                        var t     = Aardvark.Base.TupleExtensions.CreateAscending(x0, x1, x2);
                        var exact = new double[] { t.Item1, t.Item2, t.Item3 };
                        var roots = p012.RealRoots();

                        var multiple = CountDoubles(exact, 0.0001);
                        if (multiple > 0)
                        {
                            ++multipleCount;
                        }

                        var rootCountsOk = exact.Length == roots.Length;
                        Test.IsTrue(rootCountsOk, "wrong number of roots found");
                        if (!rootCountsOk)
                        {
                            using (Report.Job("problematic roots:"))
                            {
                                Report.Line("exact: [" + exact.Select(x => x.ToString()).Join(",") + "]");
                                Report.Line("roots: [" + roots.Select(x => x.ToString()).Join(",") + "]");
                            }
                            continue;
                        }
                        for (int i = 0; i < 3; i++)
                        {
                            var err = (exact[i] - roots[i]).Abs();
                            Test.IsTrue(err < epsilon, "root differs significantly from exact value {0}", err);
                            double res = p012.Evaluate(roots[i]).Abs();
                            stats.Add(err);
                            residualStats.Add(res);
                            if (multiple == 0)
                            {
                                uniqueStats.Add(err);
                                uniqueHisto.AddLog10(err);
                                uniqueResidualStats.Add(res);
                            }
                            else
                            {
                                multipleStats.Add(err);
                                multipleHisto.AddLog10(err);
                                multipleResidualStats.Add(res);
                            }
                        }
                    }
                }
            }
            Report.Value("roots error", stats);
            Report.Value("unique roots error", uniqueStats);
            Report.Value("unique roots log error histogram", uniqueHisto);
            Report.Value("multiple roots error", multipleStats);
            Report.Value("multiple roots log error histogram", multipleHisto);
            Report.Value("residual error", residualStats);
            Report.Value("unique roots residual error", uniqueResidualStats);
            Report.Value("multiple residual error", multipleResidualStats);
            Test.End();
        }
Ejemplo n.º 43
0
 public void SetParent(Histogram parent)
 {
     _parent = parent;
 }
Ejemplo n.º 44
0
 public double CalculateConsumedRatio(Histogram eventCpuConsumedSeconds)
 {
     return(CalculateConsumedRatio(eventCpuConsumedSeconds.CollectAllSumValues().Sum(x => x)));
 }
Ejemplo n.º 45
0
        public override async Task <IActionResult> Index()
        {
            await base.Index();

            //var histStore = Scheduler.Context.GetExecutionHistoryStore();
            var metadata = await Scheduler.GetMetaData();

            var jobKeys = await Scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());

            var triggerKeys = await Scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup());

            var currentlyExecutingJobs = await Scheduler.GetCurrentlyExecutingJobs();

            IEnumerable <object> pausedJobGroups            = null;
            IEnumerable <object> pausedTriggerGroups        = null;
            IEnumerable <ExecutionHistoryEntry> execHistory = null;

            try
            {
                pausedJobGroups = await GetGroupPauseState(await Scheduler.GetJobGroupNames(), async x => await Scheduler.IsJobGroupPaused(x));
            }
            catch (NotImplementedException) { }

            try
            {
                pausedTriggerGroups = await GetGroupPauseState(await Scheduler.GetTriggerGroupNames(), async x => await Scheduler.IsTriggerGroupPaused(x));
            }
            catch (NotImplementedException) { }

            int?failedJobs   = null;
            int executedJobs = metadata.NumberOfJobsExecuted;

            if (histStore != null)
            {
                execHistory = await histStore?.FilterLast(10);

                executedJobs = await histStore?.GetTotalJobsExecuted();

                failedJobs = await histStore?.GetTotalJobsFailed();
            }

            var histogram = execHistory.ToHistogram(detailed: true) ?? Histogram.CreateEmpty();

            histogram.BarWidth = 14;

            return(View(new
            {
                History = histogram,
                MetaData = metadata,
                RunningSince = metadata.RunningSince != null ? metadata.RunningSince.Value.UtcDateTime.ToDefaultFormat() + " UTC" : "N / A",
                Environment.MachineName,
                Application = Environment.CommandLine,
                JobsCount = jobKeys.Count,
                TriggerCount = triggerKeys.Count,
                ExecutingJobs = currentlyExecutingJobs.Count,
                ExecutedJobs = executedJobs,
                FailedJobs = failedJobs?.ToString(CultureInfo.InvariantCulture) ?? "N / A",
                JobGroups = pausedJobGroups,
                TriggerGroups = pausedTriggerGroups,
                HistoryEnabled = histStore != null,
            }));
        }
Ejemplo n.º 46
0
        /// <summary>
        /// Do your analysis. This method is called once per segment (typically one-minute segments).
        /// </summary>
        /// <param name="audioRecording"></param>
        /// <param name="configuration"></param>
        /// <param name="segmentStartOffset"></param>
        /// <param name="getSpectralIndexes"></param>
        /// <param name="outputDirectory"></param>
        /// <param name="imageWidth"></param>
        /// <returns></returns>
        public override RecognizerResults Recognize(AudioRecording audioRecording, Config configuration, TimeSpan segmentStartOffset, Lazy <IndexCalculateResult[]> getSpectralIndexes, DirectoryInfo outputDirectory, int?imageWidth)
        {
            const double minAmplitudeThreshold = 0.1;
            const int    percentile            = 5;
            const double scoreThreshold        = 0.3;
            const bool   doFiltering           = true;
            const int    windowWidth           = 1024;
            const int    signalBuffer          = windowWidth * 2;

            //string path = @"C:\SensorNetworks\WavFiles\Freshwater\savedfortest.wav";
            //audioRecording.Save(path); // this does not work
            int sr      = audioRecording.SampleRate;
            int nyquist = audioRecording.Nyquist;

            // Get a value from the config file - with a backup default
            //int minHz = (int?)configuration[AnalysisKeys.MinHz] ?? 600;

            // Get a value from the config file - with no default, throw an exception if value is not present
            //int maxHz = ((int?)configuration[AnalysisKeys.MaxHz]).Value;

            // Get a value from the config file - without a string accessor, as a double
            //double someExampleSettingA = (double?)configuration.someExampleSettingA ?? 0.0;

            // common properties
            //string speciesName = (string)configuration[AnalysisKeys.SpeciesName] ?? "<no species>";
            //string abbreviatedSpeciesName = (string)configuration[AnalysisKeys.AbbreviatedSpeciesName] ?? "<no.sp>";

            // min score for an acceptable event
            double eventThreshold = (double)configuration.GetDoubleOrNull(AnalysisKeys.EventThreshold);

            // get samples
            var samples = audioRecording.WavReader.Samples;

            double[] bandPassFilteredSignal = null;

            if (doFiltering)
            {
                // high pass filter
                int windowLength = 71;
                DSP_IIRFilter.ApplyMovingAvHighPassFilter(samples, windowLength, out var highPassFilteredSignal);

                //DSP_IIRFilter filter2 = new DSP_IIRFilter("Chebyshev_Highpass_400");
                //int order2 = filter2.order;
                //filter2.ApplyIIRFilter(samples, out highPassFilteredSignal);

                // Amplify 40dB and clip to +/-1.0;
                double factor = 100; // equiv to 20dB
                highPassFilteredSignal = DspFilters.AmplifyAndClip(highPassFilteredSignal, factor);

                //low pass filter
                string        filterName = "Chebyshev_Lowpass_5000, scale*5";
                DSP_IIRFilter filter     = new DSP_IIRFilter(filterName);
                int           order      = filter.order;

                //System.LoggedConsole.WriteLine("\nTest " + filterName + ", order=" + order);
                filter.ApplyIIRFilter(highPassFilteredSignal, out bandPassFilteredSignal);
            }
            else // do not filter because already filtered - using Chris's filtered recording
            {
                bandPassFilteredSignal = samples;
            }

            // calculate an amplitude threshold that is above Nth percentile of amplitudes in the subsample
            int window = 66;

            Histogram.GetHistogramOfWaveAmplitudes(bandPassFilteredSignal, window, out var histogramOfAmplitudes, out var minAmplitude, out var maxAmplitude, out var binWidth);
            int percentileBin = Histogram.GetPercentileBin(histogramOfAmplitudes, percentile);

            double amplitudeThreshold = (percentileBin + 1) * binWidth;

            if (amplitudeThreshold < minAmplitudeThreshold)
            {
                amplitudeThreshold = minAmplitudeThreshold;
            }

            bool doAnalysisOfKnownExamples = true;

            if (doAnalysisOfKnownExamples)
            {
                // go to fixed location to check
                //1:02.07, 1:07.67, 1:12.27, 1:12.42, 1:12.59, 1:12.8, 1.34.3, 1:35.3, 1:40.16, 1:50.0, 2:05.9, 2:06.62, 2:17.57, 2:21.0
                //2:26.33, 2:43.07, 2:43.15, 3:16.55, 3:35.09, 4:22.44, 4:29.9, 4:42.6, 4:51.48, 5:01.8, 5:21.15, 5:22.72, 5:32.37, 5.36.1,
                //5:42.82, 6:03.5, 6:19.93, 6:21.55, 6:42.0, 6:42.15, 6:46.44, 7:12.17, 7:42.65, 7:45.86, 7:46.18, 7:52.38, 7:59.11, 8:10.63,
                //8:14.4, 8:14.63, 8_15_240, 8_46_590, 8_56_590, 9_25_77, 9_28_94, 9_30_5, 9_43_9, 10_03_19, 10_24_26, 10_24_36, 10_38_8,
                //10_41_08, 10_50_9, 11_05_13, 11_08_63, 11_44_66, 11_50_36, 11_51_2, 12_04_93, 12_10_05, 12_20_78, 12_27_0, 12_38_5,
                //13_02_25, 13_08_18, 13_12_8, 13_25_24, 13_36_0, 13_50_4, 13_51_2, 13_57_87, 14_15_00, 15_09_74, 15_12_14, 15_25_79

                //double[] times = { 2.2, 26.589, 29.62 };
                //double[] times = { 2.2, 3.68, 10.83, 24.95, 26.589, 27.2, 29.62 };
                //double[] times = { 2.2, 3.68, 10.83, 24.95, 26.589, 27.2, 29.62, 31.39, 62.1, 67.67, 72.27, 72.42, 72.59, 72.8, 94.3, 95.3,
                //                   100.16, 110.0, 125.9, 126.62, 137.57, 141.0, 146.33, 163.07, 163.17, 196.55, 215.09, 262.44, 269.9, 282.6,
                //                   291.48, 301.85, 321.18, 322.72, 332.37, 336.1, 342.82, 363.5, 379.93, 381.55, 402.0, 402.15, 406.44, 432.17,
                //                   462.65, 465.86, 466.18, 472.38, 479.14, 490.63, 494.4, 494.63, 495.240, 526.590, 536.590, 565.82, 568.94,
                //                   570.5, 583.9, 603.19, 624.26, 624.36, 638.8, 641.08, 650.9, 65.13, 68.63, 704.66,
                //                   710.36, 711.2, 724.93, 730.05, 740.78, 747.05, 758.5, 782.25, 788.18, 792.8,
                //                   805.24, 816.03, 830.4, 831.2, 837.87, 855.02, 909.74, 912.14, 925.81  };

                var filePath = new FileInfo(@"C:\SensorNetworks\WavFiles\Freshwater\GruntSummaryRevisedAndEditedByMichael.csv");
                List <CatFishCallData> data = Csv.ReadFromCsv <CatFishCallData>(filePath, true).ToList();

                //var catFishCallDatas = data as IList<CatFishCallData> ?? data.ToList();
                int count = data.Count();

                var subSamplesDirectory = outputDirectory.CreateSubdirectory("testSubsamples_5000LPFilter");

                //for (int t = 0; t < times.Length; t++)
                foreach (var fishCall in data)
                {
                    //Image bmp1 = IctalurusFurcatus.AnalyseLocation(bandPassFilteredSignal, sr, times[t], windowWidth);

                    // use following line where using time in seconds
                    //int location = (int)Math.Round(times[t] * sr); //assume location points to start of grunt
                    //double[] subsample = DataTools.Subarray(bandPassFilteredSignal, location - signalBuffer, 2 * signalBuffer);

                    // use following line where using sample
                    int location1 = fishCall.Sample / 2;                        //assume Chris's sample location points to centre of grunt. Divide by 2 because original recording was 44100.
                    int location  = (int)Math.Round(fishCall.TimeSeconds * sr); //assume location points to centre of grunt

                    double[] subsample = DataTools.Subarray(bandPassFilteredSignal, location - signalBuffer, 2 * signalBuffer);

                    // calculate an amplitude threshold that is above 95th percentile of amplitudes in the subsample
                    //int[] histogramOfAmplitudes;
                    //double minAmplitude;
                    //double maxAmplitude;
                    //double binWidth;
                    //int window = 70;
                    //int percentile = 90;
                    //Histogram.GetHistogramOfWaveAmplitudes(subsample, window, out histogramOfAmplitudes, out minAmplitude, out maxAmplitude, out binWidth);
                    //int percentileBin = Histogram.GetPercentileBin(histogramOfAmplitudes, percentile);

                    //double amplitudeThreshold = (percentileBin + 1) * binWidth;
                    //if (amplitudeThreshold < minAmplitudeThreshold) amplitudeThreshold = minAmplitudeThreshold;

                    double[] scores1 = AnalyseWaveformAtLocation(subsample, amplitudeThreshold, scoreThreshold);
                    string   title1  = $"scores={fishCall.Timehms}";
                    var      bmp1    = GraphsAndCharts.DrawGraph(title1, scores1, subsample.Length, 300, 1);

                    //bmp1.Save(path1.FullName);

                    string title2 = $"tStart={fishCall.Timehms}";
                    var    bmp2   = GraphsAndCharts.DrawWaveform(title2, subsample, 1);
                    var    path1  = subSamplesDirectory.CombineFile($"scoresForTestSubsample_{fishCall.TimeSeconds}secs.png");

                    //var path2 = subSamplesDirectory.CombineFile($@"testSubsample_{times[t]}secs.wav.png");
                    Image <Rgb24>[] imageList = { bmp2, bmp1 };
                    var             bmp3      = ImageTools.CombineImagesVertically(imageList);
                    bmp3.Save(path1.FullName);

                    //write wave form to txt file for later work in XLS
                    //var path3 = subSamplesDirectory.CombineFile($@"testSubsample_{times[t]}secs.wav.csv");
                    //signalBuffer = 800;
                    //double[] subsample2 = DataTools.Subarray(bandPassFilteredSignal, location - signalBuffer, 3 * signalBuffer);
                    //FileTools.WriteArray2File(subsample2, path3.FullName);
                }
            }

            int signalLength = bandPassFilteredSignal.Length;

            // count number of 1000 sample segments
            int blockLength = 1000;
            int blockCount  = signalLength / blockLength;

            int[]    indexOfMax = new int[blockCount];
            double[] maxInBlock = new double[blockCount];

            for (int i = 0; i < blockCount; i++)
            {
                double max        = -2.0;
                int    blockStart = blockLength * i;
                for (int s = 0; s < blockLength; s++)
                {
                    double absValue = Math.Abs(bandPassFilteredSignal[blockStart + s]);
                    if (absValue > max)
                    {
                        max           = absValue;
                        maxInBlock[i] = max;
                        indexOfMax[i] = blockStart + s;
                    }
                }
            }

            // transfer max values to a list
            var indexList = new List <int>();

            for (int i = 1; i < blockCount - 1; i++)
            {
                // only find the blocks that contain a max value that is > neighbouring blocks
                if (maxInBlock[i] > maxInBlock[i - 1] && maxInBlock[i] > maxInBlock[i + 1])
                {
                    indexList.Add(indexOfMax[i]);
                }

                //ALTERNATIVELY
                // look at max in each block
                //indexList.Add(indexOfMax[i]);
            }

            // now process neighbourhood of each max
            int binCount = windowWidth / 2;

            FFT.WindowFunc wf               = FFT.Hamming;
            var            fft              = new FFT(windowWidth, wf);
            int            maxHz            = 1000;
            double         hzPerBin         = nyquist / (double)binCount;
            int            requiredBinCount = (int)Math.Round(maxHz / hzPerBin);

            // init list of events
            List <AcousticEvent> events = new List <AcousticEvent>();

            double[] scores = new double[signalLength]; // init of score array

            int id = 0;

            foreach (int location in indexList)
            {
                //System.LoggedConsole.WriteLine("Location " + location + ", id=" + id);

                int start = location - binCount;
                if (start < 0)
                {
                    continue;
                }

                int end = location + binCount;
                if (end >= signalLength)
                {
                    continue;
                }

                double[] subsampleWav = DataTools.Subarray(bandPassFilteredSignal, start, windowWidth);

                var spectrum = fft.Invoke(subsampleWav);

                // convert to power
                spectrum = DataTools.SquareValues(spectrum);
                spectrum = DataTools.filterMovingAverageOdd(spectrum, 3);
                spectrum = DataTools.normalise(spectrum);
                var subBandSpectrum = DataTools.Subarray(spectrum, 1, requiredBinCount); // ignore DC in bin zero.

                // now do some tests on spectrum to determine if it is a candidate grunt
                bool eventFound = false;

                double[] scoreArray = CalculateScores(subBandSpectrum, windowWidth);
                double   score      = scoreArray[0];

                if (score > scoreThreshold)
                {
                    eventFound = true;
                }

                if (eventFound)
                {
                    for (int i = location - binCount; i < location + binCount; i++)
                    {
                        scores[location] = score;
                    }

                    var    startTime  = TimeSpan.FromSeconds((location - binCount) / (double)sr);
                    string startLabel = startTime.Minutes + "." + startTime.Seconds + "." + startTime.Milliseconds;
                    Image  image4     = GraphsAndCharts.DrawWaveAndFft(subsampleWav, sr, startTime, spectrum, maxHz * 2, scoreArray);

                    var path4 = outputDirectory.CreateSubdirectory("subsamples").CombineFile($@"subsample_{location}_{startLabel}.png");
                    image4.Save(path4.FullName);

                    // have an event, store the data in the AcousticEvent class
                    double duration = 0.2;
                    int    minFreq  = 50;
                    int    maxFreq  = 1000;
                    var    anEvent  = new AcousticEvent(segmentStartOffset, startTime.TotalSeconds, duration, minFreq, maxFreq);
                    anEvent.Name = "grunt";

                    //anEvent.Name = DataTools.WriteArrayAsCsvLine(subBandSpectrum, "f4");
                    anEvent.Score = score;
                    events.Add(anEvent);
                }

                id++;
            }

            // make a spectrogram
            var config = new SonogramConfig
            {
                NoiseReductionType      = NoiseReductionType.Standard,
                NoiseReductionParameter = configuration.GetDoubleOrNull(AnalysisKeys.NoiseBgThreshold) ?? 0.0,
            };
            var sonogram = (BaseSonogram) new SpectrogramStandard(config, audioRecording.WavReader);

            //// when the value is accessed, the indices are calculated
            //var indices = getSpectralIndexes.Value;

            //// check if the indices have been calculated - you shouldn't actually need this
            //if (getSpectralIndexes.IsValueCreated)
            //{
            //    // then indices have been calculated before
            //}

            var plot = new Plot(this.DisplayName, scores, eventThreshold);

            return(new RecognizerResults()
            {
                Events = events,
                Hits = null,

                //ScoreTrack = null,
                Plots = plot.AsList(),
                Sonogram = sonogram,
            });
        }
Ejemplo n.º 47
0
        public PrometheusEventCallback(ICollectorRegistry collectorRegistry)
        {
            var metricsFactory = new MetricFactory(collectorRegistry);

            _httpServerRequestCounter = metricsFactory.CreateCounter("http_server_request", "HTTP server requests",
                                                                     new CounterConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method" }
            });

            _httpServerResponseHistogram = metricsFactory.CreateHistogram("http_server_response",
                                                                          "HTTP server response duration (ms)", new HistogramConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "statusCode" },
                Buckets    = new double[] { 10, 30, 100, 300, 1000, 3000, 10000 }
            });

            _httpServerExceptionHistogram = metricsFactory.CreateHistogram("http_server_exception",
                                                                           "HTTP server exception duration (ms)", new HistogramConfiguration
            {
                // TODO: Useful part of path?
                // TODO: Exception name maybe?
                LabelNames = new[] { "method" },
                Buckets    = new double[] { 10, 30, 100, 300, 1000, 3000, 10000 }
            });

            _httpClientRequestCounter = metricsFactory.CreateCounter("http_client_request", "HTTP client requests",
                                                                     new CounterConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "targetService" }
            });

            _httpClientResponseHistogram = metricsFactory.CreateHistogram("http_client_response",
                                                                          "HTTP client response duration (ms)", new HistogramConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "statusCode", "targetService" },
                Buckets    = new double[] { 10, 30, 100, 300, 1000, 3000, 10000 }
            });

            _httpClientRetryCounter = metricsFactory.CreateCounter("http_client_retry", "HTTP client retrys",
                                                                   new CounterConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "targetService" }
            });

            _httpClientExceptionHistogram = metricsFactory.CreateHistogram("http_client_exception",
                                                                           "HTTP client exception duration (ms)", new HistogramConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "targetService" },
                Buckets    = new double[] { 10, 30, 100, 300, 1000, 3000, 10000 }
            });

            _httpClientTimedOutHistogram = metricsFactory.CreateHistogram("http_client_timed_out",
                                                                          "HTTP client timed out duration (ms)", new HistogramConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "targetService" },
                Buckets    = new double[] { 10, 30, 100, 300, 1000, 3000, 10000 }
            });

            _httpClientServerUnavailableHistogram = metricsFactory.CreateHistogram("http_client_server_unavailable",
                                                                                   "HTTP client server unavailable duration (ms)", new HistogramConfiguration
            {
                // TODO: Useful part of path?
                LabelNames = new[] { "method", "targetService" },
                Buckets    = new double[] { 10, 30, 100, 300, 1000, 3000, 10000 }
            });
        }
 public void Add(string key, Histogram value)
 {
     _data.Add(key, value);
 }
        public Histogram CreateHistogram(string name, string help, double[] buckets = null, params string[] labelNames)
        {
            var metric = new Histogram(name, help, labelNames, buckets);

            return((Histogram)_registry.GetOrAdd(metric));
        }
Ejemplo n.º 50
0
        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            EKGMaaling.Title = "EKG-måling";
            Maalingcollection.Clear();
            EKGMaaling.Values.Clear();
            ChartECG.AxisX[0].Separator.Step = 0.04 / (1 / SAMPLE_RATE);
            ChartECG.AxisX[1].Separator.Step = 0.2 / (1 / SAMPLE_RATE);
            ChartECG.AxisY[0].Separator.Step = 0.1;
            ChartECG.AxisY[1].Separator.Step = 0.5;
            EKGMaaling.Fill          = System.Windows.Media.Brushes.Transparent;
            EKGMaaling.PointGeometry = null;

            if (offentlig == true)
            {
                double        baseline   = 0;
                var           histogram1 = Histogram.CreateEmpty(-1.8, 5.8, 76);
                DTO.DTO_ECG[] dTO_array  = new DTO.DTO_ECG[500];
                dTO_array = logicRef.ECGData(måleID).ToArray();

                for (int i = 0; i < dTO_array.Length; i++)
                {
                    ekgarray[i] = Convert.ToDouble(dTO_array[i].ECGVoltage);
                    histogram1.Increment(ekgarray[i]);
                }

                var max = histogram1.MaxIndex();
                Interval <double> bin = histogram1.Bins[max];
                baseline = bin.LowerBound + bin.Width / 2;

                for (int i = 0; i < ekgarray.Length; i++)
                {
                    EKGMaaling.Values.Add(ekgarray[i] - baseline);
                }

                STEMI_Button.IsEnabled   = false;
                NOSTEMI_Button.IsEnabled = false;
                cpr_Lb.Content           = socSecNb;
            }
            else if (offentlig == false)
            {
                double        baseline   = 0;
                var           histogram1 = Histogram.CreateEmpty(-1.8, 5.8, 76);
                DTO.DTO_ECG[] dTO_array  = new DTO.DTO_ECG[500];
                dTO_array      = logicRef.GetLokalinfo()._lokalECG.ToArray();
                cpr_Lb.Content = logicRef.GetLokalinfo()._borger_cprnr;

                for (int i = 0; i < dTO_array.Length; i++)
                {
                    ekgarray[i] = Convert.ToDouble(dTO_array[i].ECGVoltage);
                    histogram1.Increment(ekgarray[i]);
                }

                var max = histogram1.MaxIndex();
                Interval <double> bin = histogram1.Bins[max];
                baseline = bin.LowerBound + bin.Width / 2;

                for (int i = 0; i < ekgarray.Length; i++)
                {
                    EKGMaaling.Values.Add(ekgarray[i] - baseline);
                }

                if (logicRef.GetLokalinfo()._STEMI_suspected == true)
                {
                    Analyse_label.Content = "STEMI mistænkt";
                }

                else if (logicRef.GetLokalinfo()._STEMI_suspected == false)
                {
                    Analyse_label.Content = "Ingen STEMI";
                }
            }

            Maalingcollection.Add(EKGMaaling);
        }
Ejemplo n.º 51
0
 public static Histogram ToHistogram(this Vector <double> self, int nbuckets) =>
 Histogram.Create(self.Enumerate(), nbuckets);
 /// <summary>
 /// Collects all sum values of a histogram recorded across both unlabeled and labeled metrics.
 /// </summary>
 internal static IEnumerable <double> CollectAllSumValues(this Histogram histogram, bool excludeUnlabeled = false)
 {
     return(CollectAllMetrics(histogram, excludeUnlabeled).Select(x => x.histogram.sample_sum));
 }
Ejemplo n.º 53
0
 public static void Draw_HISTOGRAM_RADIAL(Histogram _histogram, float _x, float _y, float _radius_start, float _radius_end, Color _col_MIN, Color _col_MAX, bool _alphaFade = false, float _angle_start = 0, float _angle_end = 1, float _rotation = 1)
 {
     Draw_HISTOGRAM_RADIAL(_histogram.values, _x, _y, _radius_start, _radius_end, _col_MIN, _col_MAX, _alphaFade, _angle_start, _angle_end, _rotation);
 }
 /// <summary>
 /// Collects all count values of a histogram recorded across both unlabeled and labeled metrics.
 /// </summary>
 internal static IEnumerable <ulong> CollectAllCountValues(this Histogram histogram)
 {
     return(CollectAllMetrics(histogram).Select(x => x.histogram.sample_count));
 }
Ejemplo n.º 55
0
        public override IPopup GetResult()
        {
            int       extraMargin      = 5;
            Histogram toScaleHistogram = Histogram_Builder.GetResult(Color.White);
            int       HistogramWidth   = toScaleHistogram.Width;


            DoubleParamPopup result = new DoubleParamPopup
            {
                form      = new Form(),
                Ok_Button = new Button()
                {
                    Text = "ok"
                },
                Cancel_Button = new Button()
                {
                    Text = "cancel"
                },
                Aply_Button = new Button()
                {
                    Text = "apply"
                },

                value    = new TrackBar(),
                MaxValue = new TrackBar(),

                value_Value    = new Label(),
                MaxValue_Value = new Label(),

                ifMaxValue = new CheckBox()
            };

            FlowLayoutPanel ButtonContainer = new FlowLayoutPanel()
            {
                Dock          = DockStyle.Bottom,
                Height        = result.Ok_Button.Height + extraMargin,
                FlowDirection = FlowDirection.RightToLeft,
                WrapContents  = false
            };

            result.value.Left    = extraMargin;
            result.MaxValue.Left = extraMargin;

            result.form.FormClosing += result.Form_FormClosing;

            result.Ok_Button.Click     += result.Ok_Button_Click;
            result.Cancel_Button.Click += result.Cancel_Button_Click;
            result.Aply_Button.Click   += result.Aply_Button_Click;

            result.value.Height = ButtonContainer.Height / 2;
            result.value.Width  = HistogramWidth;
            result.value.Top    = extraMargin;

            result.MaxValue.Height = result.value.Height;
            result.MaxValue.Width  = result.value.Width;
            result.MaxValue.Top    = result.value.Top + result.value.Height;

            result.value.ValueChanged    += result.Value_ValueChanged;
            result.MaxValue.ValueChanged += result.Value_ValueChanged;

            result.form.Height = ButtonContainer.Height
                                 + result.value.Height
                                 + result.MaxValue.Height
                                 + 64;
            result.form.Width = HistogramWidth
                                + result.value_Value.Width
                                + extraMargin * 3;

            result.value_Value.Top  = result.value.Top;
            result.value_Value.Left = result.value.Width + extraMargin;

            result.MaxValue_Value.Top  = result.MaxValue.Top;
            result.MaxValue_Value.Left = result.MaxValue.Width + extraMargin;


            result.form.Controls.Add(result.value);
            result.form.Controls.Add(result.MaxValue);

            result.form.Controls.Add(result.value_Value);
            result.form.Controls.Add(result.MaxValue_Value);

            result.form.Controls.Add(ButtonContainer);
            ButtonContainer.Controls.Add(result.Aply_Button);
            ButtonContainer.Controls.Add(result.Cancel_Button);
            ButtonContainer.Controls.Add(result.Ok_Button);
            //result.form.Show();

            return(result);
        }
Ejemplo n.º 56
0
        protected override void MakeVisualization([NotNull] ScenarioSliceParameters slice, bool isPresent)
        {
            var          dbHouse         = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.Houses, slice);
            List <House> houses1         = dbHouse.Fetch <House>();
            var          heatingsystems1 = dbHouse.Fetch <HeatingSystemEntry>();
            Dictionary <string, HeatingSystemEntry> heatingsystemsByGuid = new Dictionary <string, HeatingSystemEntry>();

            foreach (var hse in heatingsystems1)
            {
                heatingsystemsByGuid.Add(hse.HouseGuid, hse);
            }

            MakeHeatingSystemAnalysis();
            EnergyIntensityHistogram();
            MakeHeatingTypeIntensityMap();
            MakeHeatingTypeMap();
            MakeHeatingSystemSankey();
            HeatingSystemCountHistogram();
            MakeHeatingSystemMapError();
            MakeHeatingSystemMap();
            MakeFernwärmeTypeMap();
            if (isPresent)
            {
                PresentOnlyVisualisations(heatingsystemsByGuid, slice, houses1, dbHouse);
            }

            void MakeHeatingSystemAnalysis()
            {
                var filename = MakeAndRegisterFullFilename("analysis.csv", slice);
                var sw       = new StreamWriter(filename);

                sw.WriteLine("Original Heating system - Anzahl");
                foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType)))
                {
                    var fs1 = heatingsystems1.Where(x => x.OriginalHeatingSystemType == hst).ToList();
                    sw.WriteLine(hst + ";" + fs1.Count);
                }

                sw.WriteLine("");
                sw.WriteLine("");
                sw.WriteLine("Original Heating system - Summe");
                foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType)))
                {
                    var fs1 = heatingsystems1.Where(x => x.OriginalHeatingSystemType == hst).ToList();
                    sw.WriteLine(hst + ";" + fs1.Sum(x => x.EffectiveEnergyDemand));
                }

                sw.WriteLine("");
                sw.WriteLine("");

                sw.WriteLine("Target Anzahl");
                foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType)))
                {
                    var fs1 = heatingsystems1.Where(x => x.SynthesizedHeatingSystemType == hst).ToList();
                    sw.WriteLine(hst + ";" + fs1.Count);
                }

                sw.WriteLine("");
                sw.WriteLine("");

                sw.WriteLine("Target Summe");
                foreach (HeatingSystemType hst in Enum.GetValues(typeof(HeatingSystemType)))
                {
                    var fs1 = heatingsystems1.Where(x => x.SynthesizedHeatingSystemType == hst).ToList();
                    sw.WriteLine(hst + ";" + fs1.Sum(x => x.EffectiveEnergyDemand));
                }

                sw.Close();
            }

            void EnergyIntensityHistogram()
            {
                var filename  = MakeAndRegisterFullFilename("EnergyIntensityHistogram.png", slice);
                var ages      = heatingsystems1.Select(x => x.CalculatedAverageHeatingEnergyDemandDensity).Where(y => y > 0).ToList();
                var barSeries = new List <BarSeriesEntry>();
                var h         = new Histogram(ages, 100);

                barSeries.Add(BarSeriesEntry.MakeBarSeriesEntry(h, out var colnames, "F0"));
                Services.PlotMaker.MakeBarChart(filename, "EnergyIntensityHistogram", barSeries, colnames);
                var xlsfilename    = MakeAndRegisterFullFilename("EnergyIntensity.xlsx", slice);
                var heatingSystems = heatingsystems1.Where(y => y.CalculatedAverageHeatingEnergyDemandDensityWithNulls != null).ToList();
                var rbDict         = new Dictionary <string, RowBuilder>();

                foreach (var hs in heatingSystems)
                {
                    int        bucket = (int)(Math.Floor(hs.CalculatedAverageHeatingEnergyDemandDensityWithNulls / 50 ?? 0) * 50);
                    string     key    = bucket.ToString();
                    string     et     = hs.EnergyType.ToString();
                    RowBuilder rb;
                    if (rbDict.ContainsKey(key))
                    {
                        rb = rbDict[key];
                    }
                    else
                    {
                        rb = RowBuilder.Start("Energieträger", key);
                        rbDict.Add(key, rb);
                    }

                    rb.AddToPossiblyExisting(et, 1);
                }
                RowCollection rc = new RowCollection("energy", "energy");

                foreach (var builder in rbDict)
                {
                    rc.Add(builder.Value);
                }
                RowCollection rc2 = new RowCollection("raw", "raw");

                foreach (var heatingSystemEntry in heatingsystems1)
                {
                    RowBuilder rb = RowBuilder.Start("Träger", heatingSystemEntry.EnergyType)
                                    .Add("Effektiv", heatingSystemEntry.EffectiveEnergyDemand)
                                    .Add("EBF", heatingSystemEntry.Ebf);
                    rc2.Add(rb);
                }
                XlsxDumper.WriteToXlsx(xlsfilename, rc, rc2);
            }

            void MakeHeatingSystemSankey()
            {
                var ssa1 = new SingleSankeyArrow("HouseHeatingSystems", 1500, MyStage, SequenceNumber, Name, slice, Services);

                ssa1.AddEntry(new SankeyEntry("Houses", houses1.Count, 5000, Orientation.Straight));
                var ssa2 = new SingleSankeyArrow("EnergyBySystems", 1500, MyStage, SequenceNumber, Name, slice, Services);

                ssa2.AddEntry(new SankeyEntry("Houses", heatingsystems1.Sum(x => x.EffectiveEnergyDemand) / 1000000, 5000, Orientation.Straight));
                var counts = new Dictionary <HeatingSystemType, int>();
                var energy = new Dictionary <HeatingSystemType, double>();

                foreach (var entry in heatingsystems1)
                {
                    if (!counts.ContainsKey(entry.SynthesizedHeatingSystemType))
                    {
                        counts.Add(entry.SynthesizedHeatingSystemType, 0);
                        energy.Add(entry.SynthesizedHeatingSystemType, 0);
                    }

                    counts[entry.SynthesizedHeatingSystemType]++;
                    energy[entry.SynthesizedHeatingSystemType] += entry.EffectiveEnergyDemand;
                }

                var i = 1;

                foreach (var pair in counts)
                {
                    ssa1.AddEntry(new SankeyEntry(pair.Key.ToString(), pair.Value * -1, 2000 * i, Orientation.Up));
                    i++;
                }

                i = 1;
                foreach (var pair in energy)
                {
                    ssa2.AddEntry(new SankeyEntry(pair.Key.ToString(), pair.Value * -1 / 1000000, 2000 * i, Orientation.Up));
                    i++;
                }

                Services.PlotMaker.MakeSankeyChart(ssa1);
                Services.PlotMaker.MakeSankeyChart(ssa2);
            }

            void HeatingSystemCountHistogram()
            {
                var counts = new Dictionary <HeatingSystemType, int>();

                foreach (var entry in heatingsystems1)
                {
                    if (!counts.ContainsKey(entry.SynthesizedHeatingSystemType))
                    {
                        counts.Add(entry.SynthesizedHeatingSystemType, 0);
                    }

                    counts[entry.SynthesizedHeatingSystemType]++;
                }

                var filename  = MakeAndRegisterFullFilename("HeatingSystemHistogram.png", slice);
                var names     = new List <string>();
                var barSeries = new List <BarSeriesEntry>();
                var column    = 0;

                foreach (var pair in counts)
                {
                    names.Add(pair.Value.ToString());
                    var count = pair.Value;
                    barSeries.Add(BarSeriesEntry.MakeBarSeriesEntry(pair.Key.ToString(), count, column));
                    column++;
                }

                Services.PlotMaker.MakeBarChart(filename, "HeatingSystemHistogram", barSeries, names);
            }

            void MakeHeatingSystemMapError()
            {
                RGB GetColor(House h)
                {
                    var hse = heatingsystemsByGuid[h.Guid];

                    if (hse.OriginalHeatingSystemType == HeatingSystemType.Fernwärme)
                    {
                        return(Constants.Red);
                    }

                    if (hse.OriginalHeatingSystemType == HeatingSystemType.Gas)
                    {
                        return(Constants.Orange);
                    }

                    if (hse.OriginalHeatingSystemType == HeatingSystemType.FeuerungsstättenGas)
                    {
                        return(Constants.Orange);
                    }

                    return(Constants.Black);
                }

                var mapPoints = houses1.Select(x => x.GetMapPoint(GetColor)).ToList();

                var filename      = MakeAndRegisterFullFilename("KantonHeatingSystemErrors.svg", slice);
                var legendEntries = new List <MapLegendEntry> {
                    new MapLegendEntry("Kanton Fernwärme", Constants.Red),
                    new MapLegendEntry("Kanton Gas", Constants.Orange)
                };

                Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
            }

            void MakeHeatingSystemMap()
            {
                var rgbs = new Dictionary <HeatingSystemType, RGB>();
                var hs   = heatingsystems1.Select(x => x.SynthesizedHeatingSystemType).Distinct().ToList();
                var idx  = 0;

                foreach (var type in hs)
                {
                    rgbs.Add(type, ColorGenerator.GetRGB(idx++));
                }

                RGB GetColor(House h)
                {
                    var hse = heatingsystemsByGuid[h.Guid];

                    return(rgbs[hse.SynthesizedHeatingSystemType]);
                }

                var mapPoints = houses1.Select(x => x.GetMapPoint(GetColor)).ToList();

                var filename      = MakeAndRegisterFullFilename("HeatingSystemMap.svg", slice);
                var legendEntries = new List <MapLegendEntry>();

                foreach (var pair in rgbs)
                {
                    legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value));
                }

                Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
            }

            void MakeHeatingTypeMap()
            {
                var maxEnergy             = heatingsystems1.Max(x => x.EffectiveEnergyDemand);
                var colorsByHeatingSystem = new Dictionary <HeatingSystemType, RGB> {
                    {
                        HeatingSystemType.Gas, Constants.Orange
                    }, {
                        HeatingSystemType.Öl, Constants.Black
                    }, {
                        HeatingSystemType.Electricity, Constants.Green
                    }, {
                        HeatingSystemType.Heatpump, Constants.Green
                    }, {
                        HeatingSystemType.Fernwärme, Constants.Blue
                    }, {
                        HeatingSystemType.Other, Constants.Türkis
                    }, {
                        HeatingSystemType.None, Constants.Yellow
                    }
                };

                RGBWithSize GetColorWithSize(House h)
                {
                    var s      = heatingsystemsByGuid[h.Guid];
                    var energy = Math.Log(s.EffectiveEnergyDemand / maxEnergy * 100) * 50;

                    if (energy < 10)
                    {
                        energy = 10;
                    }

                    if (!colorsByHeatingSystem.ContainsKey(s.SynthesizedHeatingSystemType))
                    {
                        throw new Exception("undefined color for " + s.SynthesizedHeatingSystemType);
                    }

                    var rgb = colorsByHeatingSystem[s.SynthesizedHeatingSystemType];

                    return(new RGBWithSize(rgb.R, rgb.G, rgb.B, (int)energy));
                }

                RGB GetColor(House h)
                {
                    var s = heatingsystemsByGuid[h.Guid];

                    if (!colorsByHeatingSystem.ContainsKey(s.SynthesizedHeatingSystemType))
                    {
                        throw new Exception("undefined color for " + s.SynthesizedHeatingSystemType);
                    }

                    var rgb = colorsByHeatingSystem[s.SynthesizedHeatingSystemType];

                    return(new RGB(rgb.R, rgb.G, rgb.B));
                }

                var mapPoints     = houses1.Select(x => x.GetMapPointWithSize(GetColorWithSize)).ToList();
                var filename      = MakeAndRegisterFullFilename("MapHeatingTypeAndSystemPerHousehold.svg", slice);
                var legendEntries = new List <MapLegendEntry>();

                foreach (var pair in colorsByHeatingSystem)
                {
                    legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value));
                }

                Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
                var filenameOsm = MakeAndRegisterFullFilename("MapHeatingTypeAndSystemPerHouseholdOsm.png", slice);

                legendEntries.Add(new MapLegendEntry("Nicht Stadtgebiet", Constants.Red));
                var mceh = houses1.Select(x => x.GetMapColorForHouse(GetColor)).ToList();

                Services.PlotMaker.MakeOsmMap("HeatingTypeMap", filenameOsm, mceh, new List <WgsPoint>(), legendEntries, new List <LineEntry>());
            }

            void MakeFernwärmeTypeMap()
            {
                RGBWithLabel GetColor(House h)
                {
                    var s = heatingsystemsByGuid[h.Guid];

                    if (s.SynthesizedHeatingSystemType == HeatingSystemType.Fernwärme)
                    {
                        return(new RGBWithLabel(Constants.Green, ""));
                    }

                    return(new RGBWithLabel(Constants.Blue, "")); //h.ComplexName
                }

                var legendEntries = new List <MapLegendEntry>();
                var filenameOsm   = MakeAndRegisterFullFilename("FernwärmeOSM.png", slice);

                legendEntries.Add(new MapLegendEntry("Nicht Stadtgebiet", Constants.Red));
                legendEntries.Add(new MapLegendEntry("Nicht Fernwärme", Constants.Blue));
                legendEntries.Add(new MapLegendEntry("Fernwärme", Constants.Green));
                var mceh = houses1.Select(x => x.GetMapColorForHouse(GetColor)).ToList();

                Services.PlotMaker.MakeOsmMap("HeatingTypeMap", filenameOsm, mceh, new List <WgsPoint>(), legendEntries, new List <LineEntry>());
            }

            void MakeHeatingTypeIntensityMap()
            {
                var colorsByHeatingSystem = new Dictionary <HeatingSystemType, RGB> {
                    {
                        HeatingSystemType.Gas, Constants.Orange
                    }, {
                        HeatingSystemType.Öl, Constants.Black
                    }, {
                        HeatingSystemType.Electricity, Constants.Green
                    }, {
                        HeatingSystemType.Heatpump, Constants.Green
                    }, {
                        HeatingSystemType.Fernwärme, Constants.Blue
                    }, {
                        HeatingSystemType.Other, Constants.Türkis
                    }, {
                        HeatingSystemType.None, Constants.Türkis
                    }
                };

                RGBWithSize GetColor(House h)
                {
                    var s      = heatingsystemsByGuid[h.Guid];
                    var energy = s.CalculatedAverageHeatingEnergyDemandDensity / 10;

                    if (energy < 10)
                    {
                        energy = 10;
                    }

                    if (!colorsByHeatingSystem.ContainsKey(s.SynthesizedHeatingSystemType))
                    {
                        throw new Exception("undefined color for " + s.SynthesizedHeatingSystemType);
                    }

                    var rgb = colorsByHeatingSystem[s.SynthesizedHeatingSystemType];

                    return(new RGBWithSize(rgb.R, rgb.G, rgb.B, (int)energy));
                }

                var mapPoints     = houses1.Select(x => x.GetMapPointWithSize(GetColor)).ToList();
                var filename      = MakeAndRegisterFullFilename("MapHeatingTypeAndIntensityPerHouse.svg", slice);
                var legendEntries = new List <MapLegendEntry>();

                foreach (var pair in colorsByHeatingSystem)
                {
                    legendEntries.Add(new MapLegendEntry(pair.Key.ToString(), pair.Value));
                }

                Services.PlotMaker.MakeMapDrawer(filename, Name, mapPoints, legendEntries);
            }
        }
Ejemplo n.º 57
0
        /// <summary>
        /// Verifies a diffed image based on the number of pixels of a given brightness per color.
        /// A tolerance Histogram curve can be created from an XML file, produced from a reference image, or manually created for use as a tolerance.
        /// </summary>
        /// <param name="image">The actual Snapshot to be verified.</param>
        /// <returns>A VerificationResult enumeration value based on the image, the expected color, and the tolerance.</returns>
        public override VerificationResult Verify(Snapshot image)
        {
            Histogram actual = Histogram.FromSnapshot(image);

            return((actual.IsLessThan(Tolerance)) ? VerificationResult.Pass : VerificationResult.Fail);
        }
        /// <summary>
        /// The main application entry point.
        /// </summary>
        /// <param name="args">Command line arguments.</param>
        public static void Main(string[] args)
        {
            // get data
            Console.WriteLine("Loading data....");
            var path    = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..\california_housing.csv"));
            var housing = Frame.ReadCsv(path, separators: ",");

            housing = housing.Where(kv => ((decimal)kv.Value["median_house_value"]) < 500000);

            // convert the house value range to thousands
            housing["median_house_value"] /= 1000;

            // shuffle row indices
            var rnd     = new Random();
            var indices = Enumerable.Range(0, housing.Rows.KeyCount).OrderBy(v => rnd.NextDouble());

            // shuffle the frame using the indices
            housing = housing.IndexRowsWith(indices).SortRowsByKey();

            // create the rooms_per_person feature
            housing.AddColumn("rooms_per_person",
                              (housing["total_rooms"] / housing["population"]).Select(v => v.Value <= 4.0 ? v.Value : 4.0));

            // calculate the correlation matrix
            var correlation = Measures.Correlation(housing.ToArray2D <double>());

            // show the correlation matrix
            Console.WriteLine(housing.ColumnKeys.ToArray().ToString <string>());
            Console.WriteLine(correlation.ToString <double>("0.0"));

            // calculate binned latitudes
            var binned_latitude =
                from l in housing["latitude"].Values
                let bin = (from b in Bins(32, 41)
                           where l >= b.Min && l < b.Max
                           select b)
                          select bin.First().Min;

            // add one-hot encoding columns
            foreach (var i in Enumerable.Range(32, 10))
            {
                housing.AddColumn($"latitude {i}-{i + 1}",
                                  from l in binned_latitude
                                  select l == i ? 1 : 0);
            }

            // drop the latitude column
            housing.DropColumn("latitude");

            // show the data frame on the console
            housing.Print();

            // calculate rooms_per_person histogram
            var histogram = new Histogram();

            histogram.Compute(housing["rooms_per_person"].Values.ToArray(), 0.1);

            // plot the histogram
            Plot(histogram, "Histogram", "Rooms per person", "Number of housing blocks");

            Console.ReadLine();
        }
Ejemplo n.º 59
0
 /// <summary>
 /// Collects all count values of a histogram recorded across both unlabeled and labeled metrics.
 /// </summary>
 internal static IEnumerable <ulong> CollectAllCountValues(this Histogram histogram)
 {
     return(CollectAllMetrics <Histogram, Histogram.Child, IHistogram, ulong>(histogram, c => (ulong)c.Count));
 }
Ejemplo n.º 60
0
 /// <summary/>
 public static SnapshotHistogramVerifier SnapshotHistogramVerifier(Histogram tolerance)
 {
     new System.Security.PermissionSet(System.Security.Permissions.PermissionState.Unrestricted).Assert();
     return(new SnapshotHistogramVerifier(tolerance));
 }