Esempio n. 1
0
        /// <summary>
        /// Initialize a new empty instance of the <c>Graphmatic.Interaction.Plotting.Graph</c> class from serialized XML data.
        /// </summary>
        /// <param name="xml">The XML data to use for deserializing this Resource.</param>
        public Graph(XElement xml)
        {
            UnresolvedResources = new Dictionary <Guid, PlottableParameters>();
            Resources           = new Dictionary <IPlottable, PlottableParameters>();
            Parameters          = new GraphParameters(xml.Element("GraphParameters"));
            XElement contents = xml.Element("Content");

            foreach (XElement content in contents.Elements())
            {
                XElement plottable = content.Elements()
                                     .Where(x => x.Name != "PlottableParameters")
                                     .First();
                PlottableParameters parameters = new PlottableParameters(content.Element("PlottableParameters"));
                if (plottable.Name == "Reference")
                {
                    UnresolvedResources.Add(Guid.Parse(plottable.Attribute("ID").Value), parameters);
                }
                else
                {
                    IPlottable resource = plottable.Deserialize <IPlottable>();
                    Resources.Add(resource, parameters);
                    if (resource is GraphKey)
                    {
                        Key = resource as GraphKey;
                    }
                    else if (resource is GraphAxis)
                    {
                        Axes = resource as GraphAxis;
                    }
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Plots this IPlottable onto a given graph. The specific method of plotting will depend on the implementation of the
        /// IPlottable.
        /// </summary>
        /// <param name="graph">The Graph to plot this IPlottable onto.</param>
        /// <param name="graphics">The GDI+ drawing surface to use for plotting this IPlottable.</param>
        /// <param name="graphSize">The size of the Graph on the screen. This is a property of the display rather than the
        /// graph and is thus not included in the graph's parameters.</param>
        /// <param name="plotParams">The parameters used to plot this IPlottable.</param>
        /// <param name="resolution">The plotting resolution to use. Using a coarser resolution may make the plotting
        /// process faster, and is thus more suitable when the display is being resized or moved.</param>
        public void PlotOnto(Graph graph, Graphics g, Size graphSize, PlottableParameters plotParams, PlotResolution resolution)
        {
            int originX, originY;

            graph.ToImageSpace(graphSize, 0, 0, out originX, out originY);

            PlotGridLinesOnto(graph, g, graphSize, plotParams, originX, originY);
            PlotAxesOnto(g, graphSize, plotParams, originX, originY);
        }
Esempio n. 3
0
 /// <summary>
 /// Adds a resource to this Graph with the given drawing parameters.
 /// </summary>
 /// <param name="plottable">The <c>IPlottable</c> to add to the graph.</param>
 /// <param name="parameters">The parameters to use for plotting the object.</param>
 public void Add(IPlottable plottable, PlottableParameters parameters)
 {
     if (Resources.ContainsKey(plottable))
     {
         throw new InvalidOperationException("The Graph already contains this IPlottable.");
     }
     else
     {
         Resources.Add(plottable, parameters);
         OnUpdate();
     }
 }
Esempio n. 4
0
 /// <summary>
 /// Plots the main axis lines onto the graph, not including the grid lines.
 /// </summary>
 /// <param name="graphics">The GDI+ drawing surface to use for plotting this IPlottable.</param>
 /// <param name="graphSize">The size of the Graph on the screen. This is a property of the display rather than the
 /// graph and is thus not included in the graph's parameters.</param>
 /// <param name="plotParams">The parameters used to plot this IPlottable.</param>
 /// <param name="originX">The X position of the origin on the screen.</param>
 /// <param name="originY">The Y position of the origin on the screen.</param>
 private void PlotAxesOnto(Graphics graphics, Size graphSize, PlottableParameters plotParams, int originX, int originY)
 {
     using (Pen axisPen = new Pen(plotParams.PlotColor))
     {
         if (originY >= 0 && originY < graphSize.Height)
         {
             graphics.DrawLine(axisPen, 0, originY, graphSize.Width, originY);
         }
         if (originX >= 0 && originX < graphSize.Width)
         {
             graphics.DrawLine(axisPen, originX, 0, originX, graphSize.Height);
         }
     }
 }
Esempio n. 5
0
        /// <summary>
        /// Plots this IPlottable onto a given graph. The specific method of plotting will depend on the implementation of the
        /// IPlottable.
        /// </summary>
        /// <param name="graph">The Graph to plot this IPlottable onto.</param>
        /// <param name="graphics">The GDI+ drawing surface to use for plotting this IPlottable.</param>
        /// <param name="graphSize">The size of the Graph on the screen. This is a property of the display rather than the
        /// graph and is thus not included in the graph's parameters.</param>
        /// <param name="plotParams">The parameters used to plot this IPlottable.</param>
        /// <param name="resolution">The plotting resolution to use. Using a coarser resolution may make the plotting
        /// process faster, and is thus more suitable when the display is being resized or moved.</param>
        public void PlotOnto(Graph graph, Graphics graphics, Size graphSize, PlottableParameters plotParams, PlotResolution resolution)
        {
            using (Brush brush = new SolidBrush(plotParams.PlotColor))
            {
                float currentY = graphSize.Height;
                int   offset   = 5;

                foreach (IPlottable plot in graph.Reverse())
                {
                    if (plot is Resource) // only plot Resources, so we don't plot the key on the key
                    {
                        PlottableParameters parameters = graph[plot];
                        Resource            resource   = plot as Resource;
                        string name     = resource.Name;
                        SizeF  textSize = graphics.MeasureString(name, SystemFonts.DefaultFont);
                        currentY -= textSize.Height + offset;
                        float resourceX = graphSize.Width - offset - textSize.Width;
                        graphics.DrawString(name, SystemFonts.DefaultFont, brush, resourceX, currentY);

                        using (Pen resourcePen = new Pen(parameters.PlotColor)) // plot in the color of the resource
                        {
                            if (resource is DataSet)
                            { // draw a cross for a data set
                                resourcePen.Width = DataSet.DataPointPenWidth;
                                graphics.DrawLine(resourcePen,
                                                  new PointF(resourceX - DataSet.DataPointCrossSize - 5, currentY - DataSet.DataPointCrossSize + textSize.Height / 2),
                                                  new PointF(resourceX + DataSet.DataPointCrossSize - 5, currentY + DataSet.DataPointCrossSize + textSize.Height / 2));
                                graphics.DrawLine(resourcePen,
                                                  new PointF(resourceX - DataSet.DataPointCrossSize - 5, currentY + DataSet.DataPointCrossSize + textSize.Height / 2),
                                                  new PointF(resourceX + DataSet.DataPointCrossSize - 5, currentY - DataSet.DataPointCrossSize + textSize.Height / 2));
                            }
                            else if (resource is Equation)
                            { // draw a line for an equation
                                resourcePen.Width = Equation.EquationPenWidth;
                                graphics.DrawLine(resourcePen,
                                                  new PointF(resourceX - 2, currentY + textSize.Height / 2),
                                                  new PointF(resourceX - 15, currentY + textSize.Height / 2));
                            }
                        }
                    }
                }
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Plots grid lines onto the graph.
        /// </summary>
        /// <param name="graphics">The GDI+ drawing surface to use for plotting this IPlottable.</param>
        /// <param name="graphSize">The size of the Graph on the screen. This is a property of the display rather than the
        /// graph and is thus not included in the graph's parameters.</param>
        /// <param name="plotParams">The parameters used to plot this IPlottable.</param>
        /// <param name="originX">The X position of the origin on the screen.</param>
        /// <param name="originY">The Y position of the origin on the screen.</param>
        private void PlotGridLinesOnto(Graph graph, Graphics graphics, Size graphSize, PlottableParameters plotParams, int originX, int originY)
        {
            using (Pen majorPen = new Pen(plotParams.PlotColor.ColorAlpha(0.25)))
                using (Pen minorPen = new Pen(plotParams.PlotColor.ColorAlpha(0.15)))
                    using (Brush valueBrush = new SolidBrush(plotParams.PlotColor.ColorAlpha(0.5)))
                    {
                        // the increment, in pixels, of each grid space
                        double incrementX = HorizontalType.AxisTypeGridScale() * GridSize / graph.Parameters.HorizontalPixelScale,
                               incrementY = VerticalType.AxisTypeGridScale() * GridSize / graph.Parameters.VerticalPixelScale;

                        // draw the variable names onto the axis
                        graphics.DrawString(graph.Parameters.VerticalAxis.ToString(), SystemFonts.DefaultFont, valueBrush, (int)originX, 2);
                        graphics.DrawString(graph.Parameters.HorizontalAxis.ToString(), SystemFonts.DefaultFont, valueBrush, (int)graphSize.Width - 16, (int)originY);

                        // the unit suffix of the grid labels, for example the little circle for degrees
                        string horizontalAxisSuffix = HorizontalType.AxisTypeExtension();
                        string verticalAxisSuffix   = VerticalType.AxisTypeExtension();

                        // the axis label scale for the numbers along each axis
                        // for example, axes plotted in degree mode are scaled such that 2*pi is displayed
                        // as 360 degrees instead
                        double horizontalAxisScale = GridSize * HorizontalType.AxisTypeLabelScale() * HorizontalType.AxisTypeGridScale();
                        double verticalAxisScale   = GridSize * VerticalType.AxisTypeLabelScale() * VerticalType.AxisTypeGridScale();

                        // the remainder of the code in this method plots the gridlines from the origin outward.
                        // this is potentially not the most efficient method of doing it, but it avoids floating-
                        // point rounding errors resulting in axis labels like 2.00000000000017 without adding in
                        // even more horrible code.
                        // some of this code looks redundant, and it is. However as drawing the grid lines is a
                        // (surprisingly) CPU intensive operation this method needs to be as fast as possible as
                        // the grid is drawn every time the graph is

                        double value = originX;
                        int    index = 0;
                        // plot horizontal grid lines from the origin to the right of the page
                        while (value < graphSize.Width)
                        {
                            bool major = index % MajorInterval == 0;
                            if (major)
                            {
                                graphics.DrawLine(majorPen,
                                                  (int)value, 0, (int)value, graphSize.Height);
                                graphics.DrawString(
                                    String.Format("{0:0.####}{1}", index * horizontalAxisScale, horizontalAxisSuffix),
                                    SystemFonts.DefaultFont,
                                    valueBrush, (int)value, (int)originY);
                            }
                            else
                            {
                                graphics.DrawLine(minorPen,
                                                  (int)value, 0, (int)value, graphSize.Height);
                            }
                            value += incrementX; index++;
                        }

                        value = originX; index = 0;
                        // plot hoz grid from origin to left of page
                        while (value >= 0)
                        {
                            bool major = index % MajorInterval == 0;
                            if (major)
                            {
                                graphics.DrawLine(majorPen,
                                                  (int)value, 0, (int)value, graphSize.Height);
                                graphics.DrawString(
                                    String.Format("{0:0.####}{1}", index * horizontalAxisScale, horizontalAxisSuffix),
                                    SystemFonts.DefaultFont,
                                    valueBrush,
                                    (int)value, (int)originY);
                            }
                            else
                            {
                                graphics.DrawLine(minorPen,
                                                  (int)value, 0, (int)value, graphSize.Height);
                            }
                            value -= incrementX; index++;
                        }

                        value = originY; index = 0;
                        // plot vertical grid lines from origin to bottom of page
                        while (value < graphSize.Height)
                        {
                            bool major = index % MajorInterval == 0;
                            if (major)
                            {
                                graphics.DrawLine(majorPen,
                                                  0, (int)value, graphSize.Width, (int)value);
                                graphics.DrawString(
                                    String.Format("{0:0.####}{1}", index * verticalAxisScale, verticalAxisSuffix),
                                    SystemFonts.DefaultFont,
                                    valueBrush,
                                    (int)originX, (int)value);
                            }
                            else
                            {
                                graphics.DrawLine(minorPen,
                                                  0, (int)value, graphSize.Width, (int)value);
                            }
                            value += incrementY; index++;
                        }

                        value = originY; index = 0;
                        // plot vert grid from origin to top of page
                        while (value >= 0)
                        {
                            bool major = index % MajorInterval == 0;
                            if (major)
                            {
                                graphics.DrawLine(majorPen,
                                                  0, (int)value, graphSize.Width, (int)value);
                                double vertical = graph.Parameters.VerticalPixelScale * index;
                                graphics.DrawString(
                                    String.Format("{0:0.####}{1}", index * verticalAxisScale, verticalAxisSuffix),
                                    SystemFonts.DefaultFont,
                                    valueBrush,
                                    (int)originX, (int)value);
                            }
                            else
                            {
                                graphics.DrawLine(minorPen,
                                                  0, (int)value, graphSize.Width, (int)value);
                            }
                            value -= incrementY; index++;
                        }
                    }
        }