Example #1
0
 /// <summary>
 ///     Handles the zoom on the chart
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void GraphVisualiser_MouseWheel(object sender, MouseEventArgs e)
 {
     try
     {
         Chart chart = sender as Chart;
         if (chart != null)
         {
             if (e.Location.X >= 0 && e.Location.X <= chart.Size.Width &&
                 e.Location.Y >= 0 && e.Location.Y <= chart.Size.Height)
             {
                 GraphVisualiser.HandleZoom(sender, e, 0);
             }
         }
     }
     catch
     {
     }
 }
Example #2
0
        /// <summary>
        ///     Constructor
        /// </summary>
        public GraphView()
        {
            InitializeComponent();

            AllowDrop  = true;
            DragEnter += GraphView_DragEnter;
            DragDrop  += GraphView_DragDrop;

            Functions = new List <Function>();

            TrainPosition = new TrainPosition();

            DockAreas = DockAreas.Document;

            GraphVisualiser.InitializeChart();

            foreach (TabPage tabPage in tabControl1.TabPages)
            {
                tabPage.MouseEnter += (s, e) => tabPage.Focus();
            }
        }
Example #3
0
        /// <summary>
        ///     Displays the graph
        /// </summary>
        /// <returns></returns>
        public void Display()
        {
            Util.DontNotify(() =>
            {
                GraphVisualiser.Reset();
                String name = null;

                // Computes the expected end to display
                double expectedEndX = 0;
                Dictionary <Function, Graph> graphs = new Dictionary <Function, Graph>();
                foreach (Function function in Functions)
                {
                    InterpretationContext context = new InterpretationContext(function);
                    if (function.FormalParameters.Count == 1)
                    {
                        Parameter parameter = (Parameter)function.FormalParameters[0];
                        Graph graph         = function.CreateGraph(context, parameter, null);
                        if (graph != null)
                        {
                            expectedEndX = Math.Max(expectedEndX, graph.ExpectedEndX());
                            graphs.Add(function, graph);
                        }
                    }
                }

                double expectedEndY = 0;
                Dictionary <Function, Surface> surfaces = new Dictionary <Function, Surface>();
                foreach (Function function in Functions)
                {
                    InterpretationContext context = new InterpretationContext(function);
                    if (function.FormalParameters.Count == 2)
                    {
                        Surface surface = function.CreateSurface(context, null);
                        if (surface != null)
                        {
                            expectedEndX = Math.Max(expectedEndX, surface.ExpectedEndX());
                            expectedEndY = Math.Max(expectedEndY, surface.ExpectedEndY());
                            surfaces.Add(function, surface);
                        }
                    }
                }

                try
                {
                    int maxX     = Int32.Parse(Tb_MaxX.Text);
                    expectedEndX = Math.Min(expectedEndX, maxX);
                }
                catch (Exception)
                {
                }

                // Creates the graphs
                foreach (KeyValuePair <Function, Graph> pair in graphs)
                {
                    Function function = pair.Key;
                    Graph graph       = pair.Value;

                    if (function != null && graph != null)
                    {
                        EfsProfileFunction efsProfileFunction = new EfsProfileFunction(graph);
                        if (function.Name.Contains("Gradient"))
                        {
                            GraphVisualiser.AddGraph(new EfsGradientProfileGraph(GraphVisualiser, efsProfileFunction,
                                                                                 function.FullName));
                        }
                        else
                        {
                            GraphVisualiser.AddGraph(new EfsProfileFunctionGraph(GraphVisualiser, efsProfileFunction,
                                                                                 function.FullName));
                        }

                        if (name == null)
                        {
                            name = function.Name;
                        }
                    }
                }

                // Creates the surfaces
                foreach (KeyValuePair <Function, Surface> pair in surfaces)
                {
                    Function function = pair.Key;
                    Surface surface   = pair.Value;

                    if (surface != null)
                    {
                        EfsSurfaceFunction efsSurfaceFunction = new EfsSurfaceFunction(surface);
                        GraphVisualiser.AddGraph(new EfsSurfaceFunctionGraph(GraphVisualiser, efsSurfaceFunction,
                                                                             function.FullName));
                        if (name == null)
                        {
                            name = function.Name;
                        }
                    }
                }

                Train train = new Train(GraphVisualiser);
                train.InitializeTrain(TrainPosition.GetDistance(), TrainPosition.GetSpeed(), TrainPosition.GetUnderReadingAmount(), TrainPosition.GetOverReadingAmount());
                GraphVisualiser.AddGraph(train);
                GraphVisualiser.Annotations.Add(train.TrainLineAnnotation);
                GraphVisualiser.Annotations.Add(train.TrainAnnotation);

                if (name != null)
                {
                    try
                    {
                        double val = double.Parse(Tb_MinX.Text);
                        GraphVisualiser.SetMinX(val);
                    }
                    catch (Exception)
                    {
                    }

                    try
                    {
                        double val = double.Parse(Tb_MaxX.Text);
                        GraphVisualiser.SetMaxX(val);
                    }
                    catch (Exception)
                    {
                    }

                    if (Cb_AutoYSize.Checked)
                    {
                        GraphVisualiser.SetMaxY(double.NaN);
                    }
                    else
                    {
                        double height;
                        if (double.TryParse(Tb_MaxY.Text, out height))
                        {
                            GraphVisualiser.SetMaxY(height);
                        }
                        else
                        {
                            GraphVisualiser.SetMaxY(double.NaN);
                        }
                    }

                    GraphVisualiser.SetMinY2(double.NaN);
                    GraphVisualiser.SetMaxY2(double.NaN);
                    double top, bottom;
                    if (double.TryParse(Tb_MinGrad.Text, out bottom))
                    {
                        GraphVisualiser.SetMinY2(bottom);
                    }
                    if (double.TryParse(Tb_MaxGrad.Text, out top))
                    {
                        GraphVisualiser.SetMaxY2(top);
                    }

                    GraphVisualiser.DrawGraphs(expectedEndX);
                }
            });
        }