public MainWindow()
        {
            InitializeComponent();
            Polyline line = new Polyline();
            Polyline line2 = new Polyline();
            line.VerticalAlignment = VerticalAlignment.Center;
            line.Stroke = SystemColors.WindowTextBrush;
            line.StrokeThickness = 2;

            for (int i = -200; i < 200; i++)
            {
                line.Points.Add(new Point(i, Algorithm.CalFitness(i)));
            }

            panel.Children.Add(line);

            Algorithm alogrithm = new Algorithm();

            for (int j = 0; j < Algorithm.MAX_CHANGE; j++)
            {
                List<Polyline> lines = alogrithm.Graph();
                for (int i = 0; i < lines.Count; i++)
                {
                    panel.Children.Add(lines[i]);
                }

                alogrithm.Running ();
            }

            bestX.Content = alogrithm.GlobeBestX.ToString();
            bestY.Content = alogrithm.GlobleBestFitness.ToString();
        }

        public void DrawPuzzle(DotPuzzle puzzle, Canvas colorPointCanvas, Polyline figurePolyline)
        {

            try
            {
                if (puzzle != null)
                {
                    colorPointCanvas.Children.Clear();
                    figurePolyline.Points.Clear();
                    for (int i = 0; i < puzzle.Dots.Count; i++)
                    {
                        Grid dotContainer = new Grid();
                        dotContainer.Width = 80;
                        dotContainer.Height = 80;
                        if (i == 0 || i == puzzle.Dots.Count - 1)
                        {
                            if (i == 0)
                                dotContainer.Children.Add(new Canvas() { Background = new ImageBrush(ConvertBitmapToBitmapSource((Resources.greenBall))) }); // do punktu startowego i koncowego potrzebna grafika, najlepiej jakas animacja
                            if (i == puzzle.Dots.Count - 1)
                                dotContainer.Children.Add(new Canvas() { Background = new ImageBrush(ConvertBitmapToBitmapSource((Resources.redBall))) });
                            

                            TextBlock dotLabel = new TextBlock();
                            //dotLabel.Text = (i + 1).ToString();
                            dotLabel.Foreground = Brushes.White;
                            dotLabel.FontSize = 35;
                            dotLabel.HorizontalAlignment = HorizontalAlignment.Center;
                            dotLabel.VerticalAlignment = VerticalAlignment.Center;
                            dotContainer.Children.Add(dotLabel);

                            Canvas.SetTop(dotContainer, puzzle.Dots[i].Y - (dotContainer.Height / 2));
                            Canvas.SetLeft(dotContainer, puzzle.Dots[i].X - (dotContainer.Width / 2));
                            colorPointCanvas.Children.Add(dotContainer);

                        }
                        else
                            dotContainer.Children.Add(new Ellipse() { Fill = figurePolyline.Stroke });

                        //TextBlock dotLabel = new TextBlock();
                        ////dotLabel.Text = (i + 1).ToString();
                        //dotLabel.Foreground = Brushes.White;
                        //dotLabel.FontSize = 35;
                        //dotLabel.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
                        //dotLabel.VerticalAlignment = System.Windows.VerticalAlignment.Center;
                        //dotContainer.Children.Add(dotLabel);

                        //Canvas.SetTop(dotContainer, puzzle.Dots[i].Y - (dotContainer.Height / 2));
                        //Canvas.SetLeft(dotContainer, puzzle.Dots[i].X - (dotContainer.Width / 2));
                        //ColorPointCanvas.Children.Add(dotContainer);
                        figurePolyline.Points.Add(new Point(puzzle.Dots[i].X, puzzle.Dots[i].Y));

                    }
                }
            }
            catch (Exception ex)
            {


            }
        }

        public void DrawLine(IList<ScreenPoint> points, OxyColor stroke, double thickness, double[] dashArray,
                             OxyPenLineJoin lineJoin, bool aliased)
        {
            var e = new Polyline();
            if (stroke != null && thickness > 0)
            {
                e.Stroke = GetCachedBrush(stroke);

                switch (lineJoin)
                {
                    case OxyPenLineJoin.Round:
                        e.StrokeLineJoin = PenLineJoin.Round;
                        break;
                    case OxyPenLineJoin.Bevel:
                        e.StrokeLineJoin = PenLineJoin.Bevel;
                        break;
                    //  The default StrokeLineJoin is Miter
                }

                if (thickness != 1) // default values is 1
                    e.StrokeThickness = thickness;
                if (dashArray != null)
                    e.StrokeDashArray = new DoubleCollection(dashArray);
            }
            // pl.Fill = null;
            if (aliased)
                e.SetValue(RenderOptions.EdgeModeProperty, EdgeMode.Aliased);

            var pc = new PointCollection(points.Count);
            foreach (var p in points)
                pc.Add(ToPoint(p));
            e.Points = pc;

            Add(e);
        }

        protected override void OnStylusDown(StylusDownEventArgs args)
        {
            base.OnStylusDown(args);
            Point ptStylus = args.GetPosition(canv);

            // ���� �ձ� Polyline�� ������ ���濡 ���
            polyStylus = new Polyline();
            polyStylus.Stroke = brushStylus;
            polyStylus.StrokeThickness = widthStroke;
            polyStylus.StrokeStartLineCap = PenLineCap.Round;
            polyStylus.StrokeEndLineCap = PenLineCap.Round;
            polyStylus.StrokeLineJoin = PenLineJoin.Round;
            polyStylus.Points = new PointCollection();
            polyStylus.Points.Add(ptStylus);

            // �׸��ڿ����� �� Polyline
            polyShadow = new Polyline();
            polyShadow.Stroke = brushShadow;
            polyShadow.StrokeThickness = widthStroke;
            polyShadow.StrokeStartLineCap = PenLineCap.Round;
            polyShadow.StrokeEndLineCap = PenLineCap.Round;
            polyShadow.StrokeLineJoin = PenLineJoin.Round;
            polyShadow.Points = new PointCollection();
            polyShadow.Points.Add(ptStylus + vectShadow);

            // ������ ��� �������� ������ �׸��� ���������� ����
            canv.Children.Insert(canv.Children.Count / 2, polyShadow);

            // ���� �������� ����� ���������� �߰�
            canv.Children.Add(polyStylus);

            CaptureStylus();
            isDrawing = true;
            args.Handled = true;
        }

        public Spiral()
        {
            Title = "Spiral";

            // Make Canvas content of window.
            Canvas canv = new Canvas();
            canv.SizeChanged += CanvasOnSizeChanged;
            Content = canv;

            // Make Polyline child of Canvas.
            poly = new Polyline();
            poly.Stroke = SystemColors.WindowTextBrush;
            canv.Children.Add(poly);

            // Define the points.
            Point[] pts = new Point[numpts];

            for (int i = 0; i < numpts; i++)
            {
                double angle = i * 2 * Math.PI / (numpts / revs);
                double scale = 250 * (1 - (double) i / numpts);

                pts[i].X = scale * Math.Cos(angle);
                pts[i].Y = scale * Math.Sin(angle);
            }
            poly.Points = new PointCollection(pts);
        }

        private void tekenLijn()
        {
            //Polyline aanmaken
            Polyline line = new Polyline();
            line.Stroke = Brushes.Aquamarine;
            line.Visibility = Visibility.Visible;
            line.StrokeThickness = 3;

            //Punten
            PointCollection punten = new PointCollection();

            //Dingen die in de formule ingevuld gaan worden
            double a = 100;// canvas.Height / 2; //De evenwichtsstand
            double b = 2;// canvas.Height / 4; //De amplitude
            //double d = Convert.ToDouble(ActualHeightProperty.ToString()) ; //de x-coördinaat van een punt waar de grafiek stijgend de evenwichtsstand snijdt

            double windowbreedte = canvas.ActualWidth;
            double windowhoogte = canvas.ActualHeight/2;

            //Alle punten overlopen
            for (int i = 0; i < windowbreedte; i++)
            {
                //punten.Add(new Point() { X = i, Y = windowhoogte * (1 - Math.Sin(i * (Math.PI / (windowbreedte/6))))});
                punten.Add(new Point(i,  Math.Sin(((2*Math.PI )/ b) * (i - windowbreedte)) * windowhoogte));
                //2,5 + 2,5 sin(2π / 9(x – 3))

            }

            line.Points = punten;

            //Lijn tekenen
            canvas.Children.Add(line);

        }

        public void AddFunction(IEnumerable<Point> points, Color color, string description)
        {
            if(!squaresFunctions.ContainsKey(description) && !functions.ContainsKey(description))
            {
                Polyline polyline = new Polyline();
                polyline.Stroke = new SolidColorBrush(color);
                polyline.StrokeThickness = CalculateThickness(0.005, R2.Width, R2.Height);
                PointCollection pColl = new PointCollection(points);
                polyline.Points = pColl;


                var nwFour = new Four(polyline.Points.Min(p => p.X), polyline.Points.Max(p => p.Y),
                    polyline.Points.Min(p => p.Y), polyline.Points.Max(p => p.Y));
           
                squaresFunctions.Add(description, nwFour);

                RecalculateSquare();
                GoToCenter();
                DrowCoordinates();

                R2.Children.Add(polyline);

                Label lbl = new Label();
                lbl.Content = description;
                lbl.Foreground = new SolidColorBrush(color);
                Descriptions.Children.Add(lbl);

                functions.Add(description, new Tuple<Polyline, Label>(polyline, lbl));
            }
        }

    /// <summary>
    /// Instantiates LineGraph.
    /// </summary>
    public LineGraph() {
      this.DefaultStyleKey = typeof(LineGraph);
      _lineGraph = new Polyline();

      BindBrush();
      BindStrokeThickness();
    }

        public StatisticsLinesManager()
        {
            Center = 200;
            MaxWidth = 1000;

            _WinningsStatisticsLine = new System.Windows.Shapes.Polyline
            {
                StrokeThickness = 2,
                Stroke = Brushes.Red,
                Visibility = Visibility.Collapsed
            };

            _NumberRepetitionsLine = new System.Windows.Shapes.Polyline
            {
                StrokeThickness = 2,
                Stroke = Brushes.Blue,
                Visibility = Visibility.Collapsed
            };

            _NumberRepetitions2Line = new System.Windows.Shapes.Polyline
            {
                StrokeThickness = 2,
                Stroke = Brushes.Red,
                Visibility = Visibility.Collapsed
            };
        }

 private void addBorder(object sender, RoutedEventArgs e)
 {
     try
     {
         Polyline border = new Polyline();
         string[] points = borderTextBox.Text.Split('\n');
         string[] xAndY = new string[2];
         List<Double> xOfPoint = new List<Double>();
         List<Double> yOfPoint = new List<Double>();
         for (int i = 0; i < points.Length; i++)
         {
             xAndY = points[i].Split(',');
             xOfPoint.Add(Convert.ToDouble(xAndY[0]));
             yOfPoint.Add(Convert.ToDouble(xAndY[1]));
             border.Points.Add(new Point(xOfPoint[i], yOfPoint[i]));
         }
         border.Stroke = new SolidColorBrush(Color.FromRgb(0, 0, 0));
         border.Name = "border";
         MainWindow.polylineList.Add(border);
         var mainWindowInstant = (MainWindow)App.Current.MainWindow;
         mainWindowInstant.getCanvas.Children.Add(border);
         mainWindowInstant.reprintItemList();
         borderTextBox.Clear();
     }
     catch { }
 }

        public Computing()
        {
            Result = new Moment(0);
            //Tmr = new Timer(3000);
            //Tmr.AutoReset = true;
            //Tmr.Elapsed += Tmr_Elapsed;

            InpFileName = @"D:\ballistics\ballisticwpf\config.txt";
            OutFileName = @"D:\ballistics\ballisticwpf\result.txt";

            //string InpFileName = @"C:\Users\Andrey\Documents\Visual Studio 2015\Projects\ballistics\ballisticwpf\config.txt";
            //string OutFileName = @"C:\Users\Andrey\Documents\Visual Studio 2015\Projects\ballistics\ballisticwpf\result.txt";
            Config = new Configuration(0);
            Config.ReadConfugurationFromFile(InpFileName);

            bool ExistFlag = File.Exists(OutFileName);
            if (ExistFlag)
            {
                File.Delete(OutFileName);
            }

            Positions = new PointCollection();
            Positions.Add(new Point(0, 0));

            Chart = new Polyline();
            Chart.Points = Positions;

            //BgrWork = ((BackgroundWorker)this.FindResource("bgrWork"));
            //ComplexArg = new ComplexForAsyns(Config);
        }

 protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
 {
     jolidessin = new Polyline();
     (App.Current as App).drawlist.Add(jolidessin);
     jolidessin.Stroke = this.Resources["PhoneForegroundBrush"] as Brush;
     jolidessin.StrokeThickness = (double)5;
      	        base.OnNavigatedTo(e);
 }

 public Polyline GetBodySegment(JointCollection joints, Brush brush, params JointType[] ids)
 {
     var points = new PointCollection(ids.Length);
     foreach (var t in ids)
         points.Add(GetDisplayPosition(joints[t]));
     var polyline = new Polyline { Points = points, Stroke = brush, StrokeThickness = 6 };
     return polyline;
 }

 public DataSeries()
 {
     LineSeries = new Polyline();
     LineThickness = 1;
     SeriesName = "Default Name";
     LineColor = Brushes.Black;
     Symbols = new NoneSymbols();
 }

 void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target) {
     switch (connectionId)
     {
     case 1:
     this.polyline1 = ((System.Windows.Shapes.Polyline)(target));
     return;
     }
     this._contentLoaded = true;
 }

        public PolyLineHandleGroup(MoonlightController controller, Polyline child)
            : base(controller, child)
        {
            PointCollection points = child.Points;
            for (int i=0; i<points.Count; i++)
                AddHandle(new PolyLineHandle(Controller, this, i));

            Update();
        }

 private void ConfigurePolyLine()
 {
     f_polyLine = new Polyline
     {
         StrokeThickness = (double)GraphicContent.GraphicToolProperties.Thickness,
         Stroke = new SolidColorBrush((Color)GraphicContent.GraphicToolProperties.Color),
         Effect = DropShadowEffect()
     };
 }

 private void SoundPlay(WaveOut waveOut, BinauralBeatsWaveOscillator wave, Polyline line, int leftFrequency, int rightFrequency, short amplitude)
 {
     double volumeGainFactor = 0.01;
     waveOut.Volume = (float)(amplitudeSlider.Value * volumeGainFactor);
     wave.LeftFrequency = leftFrequency;
     wave.RightFrequency = rightFrequency;
     wave.Amplitude = amplitude;
     waveOut.Play();
     waveGraphDrawing(line, wave, waveOut);
 }

 public void InitializeComponent() {
     if (_contentLoaded) {
         return;
     }
     _contentLoaded = true;
     System.Windows.Application.LoadComponent(this, new System.Uri("/EcosCab;component/Controls/ucLocomotiveSpeedSlider.xaml", System.UriKind.Relative));
     this.pnlSlider = ((System.Windows.Controls.Grid)(this.FindName("pnlSlider")));
     this.sliderBack = ((System.Windows.Shapes.Polyline)(this.FindName("sliderBack")));
     this.sliderFill = ((System.Windows.Shapes.Polyline)(this.FindName("sliderFill")));
 }

 public Polyline Create(IEnumerable<Point> points)
 {
     Polyline polyline = new Polyline
     {
         Stroke = Brush,
         StrokeThickness = _brushThickness,
         Opacity = _opacity,
         Points = new PointCollection(points)
     };
     return polyline;
 }