Beispiel #1
0
        private void VProfileView_Paint(object sender, PaintEventArgs e)
        {
            if (!e.ClipRectangle.IsEmpty)
            {
                e.Graphics.SmoothingMode     = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;

                var captionSize    = e.Graphics.MeasureString(Caption, captionFont);
                var axisLblMaxSize = e.Graphics.MeasureString(Zmax.ToString(), axisLblFont);

                float graphBorderLeft = axisLblMaxSize.Width + axisTickSize + axisLblMaxSize.Height;
                float graphBorderTop  = captionSize.Height + axisLblMaxSize.Height + axisTickSize;

                graphBorder = new RectangleF(graphBorderLeft, graphBorderTop,
                                             this.Width - graphBorderLeft - axisTickSize - axisLblMaxSize.Width / 2 - axisLblMaxSize.Height,
                                             this.Height - graphBorderTop - axisLblMaxSize.Height - axisTickSize);


                float zscale = graphBorder.Height / Convert.ToSingle(Math.Abs(Zmax - Zmin));
                float tscale = graphBorder.Width / Convert.ToSingle(Math.Abs(Tmax - Tmin));
                float sscale = graphBorder.Width / Convert.ToSingle(Math.Abs(Smax - Smin));

                e.Graphics.DrawRectangle(axisPen, graphBorder.Left, graphBorder.Top, graphBorder.Width, graphBorder.Height);

                e.Graphics.DrawString(Caption, captionFont, captionBrush,
                                      graphBorder.Left + graphBorder.Width / 2 - captionSize.Width / 2,
                                      graphBorder.Top - captionSize.Height - axisLblMaxSize.Height);

                float z, z1;
                float x = graphBorder.Left;

                string lbl     = "Z, m";
                var    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.TranslateTransform(
                    graphBorder.Left - axisTickSize - axisLblMaxSize.Width - lblSize.Height,
                    graphBorder.Top + graphBorder.Height / 2 - lblSize.Width / 2);
                e.Graphics.RotateTransform(-90);
                e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush, 0, 0);
                e.Graphics.RotateTransform(90);
                e.Graphics.TranslateTransform(
                    graphBorder.Left - axisTickSize - axisLblMaxSize.Width - lblSize.Height,
                    -(graphBorder.Top + graphBorder.Height / 2 - lblSize.Width / 2));


                float zStep = Convert.ToSingle(ZStep);
                z = zStep;
                float za;
                while (z <= Zmax - zStep / 2)
                {
                    za = graphBorder.Top + z * zscale;
                    e.Graphics.DrawLine(axisPen, x, za, x - axisTickSize, za);
                    lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F00}", z);
                    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);

                    e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                          x - axisTickSize - lblSize.Width,
                                          za - lblSize.Height / 2);

                    z += zStep;
                }

                lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F00}", Zmin);
                lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                      x - axisTickSize - lblSize.Width,
                                      graphBorder.Top - lblSize.Height / 2);

                lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F00}", Zmax);
                lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                      x - axisTickSize - lblSize.Width,
                                      graphBorder.Bottom - lblSize.Height / 2);

                for (int i = 0; i < tsp.Length; i++)
                {
                    z = graphBorder.Top + Convert.ToSingle(tsp[i].Z * zscale);

                    if (i < tsp.Length - 1)
                    {
                        z1 = graphBorder.Top + Convert.ToSingle(tsp[i + 1].Z * zscale);
                        e.Graphics.DrawLine(tPen,
                                            graphBorder.Left + Convert.ToSingle(tsp[i].T - Tmin) * tscale, z,
                                            graphBorder.Left + Convert.ToSingle(tsp[i + 1].T - Tmin) * tscale, z1);

                        e.Graphics.DrawLine(sPen,
                                            graphBorder.Left + Convert.ToSingle(tsp[i].S - Smin) * sscale, z,
                                            graphBorder.Left + Convert.ToSingle(tsp[i + 1].S - Smin) * sscale, z1);
                    }
                }

                for (int i = 0; i < tsTicks; i++)
                {
                    x = graphBorder.Left + i * graphBorder.Width / tsTicks;

                    lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F01}", Tmin + i * tStep);
                    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                    e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                          x - lblSize.Width / 2, graphBorder.Top - axisTickSize - lblSize.Height);

                    lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F01}", Smin + i * sStep);
                    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                    e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                          x - lblSize.Width / 2, graphBorder.Bottom + axisTickSize);

                    e.Graphics.DrawLine(axisPen,
                                        x, graphBorder.Top,
                                        x, graphBorder.Top - axisTickSize);

                    e.Graphics.DrawLine(axisPen,
                                        x, graphBorder.Bottom,
                                        x, graphBorder.Bottom + axisTickSize);
                }

                lbl     = "t, °C";
                lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.DrawString(lbl, axisLblFont, tempBrush,
                                      graphBorder.Right - lblSize.Width / 2,
                                      graphBorder.Top - axisTickSize - lblSize.Height);

                lbl     = "s, PSU";
                lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.DrawString(lbl, axisLblFont, styBrush,
                                      graphBorder.Right - lblSize.Width / 2,
                                      graphBorder.Bottom + axisTickSize);
            }
        }
Beispiel #2
0
        private void VerticalSoundPropagationPlot_Paint(object sender, PaintEventArgs e)
        {
            if (!e.ClipRectangle.IsEmpty)
            {
                e.Graphics.SmoothingMode     = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;

                var captionSize    = e.Graphics.MeasureString(Caption, captionFont);
                var axisLblMaxSize = e.Graphics.MeasureString(Zmax.ToString(), axisLblFont);

                float graphBorderLeft = axisLblMaxSize.Width + axisTickSize + axisLblMaxSize.Height;
                float graphBorderTop  = captionSize.Height + axisLblMaxSize.Height + axisTickSize;

                graphBorder = new RectangleF(graphBorderLeft, graphBorderTop,
                                             this.Width - graphBorderLeft - axisTickSize - axisLblMaxSize.Width / 2 - axisLblMaxSize.Height,
                                             this.Height - graphBorderTop - axisLblMaxSize.Height - axisTickSize);


                float zscale = graphBorder.Height / Convert.ToSingle(Math.Abs(Zmax - Zmin));

                e.Graphics.DrawRectangle(axisPen, graphBorder.Left, graphBorder.Top, graphBorder.Width, graphBorder.Height);

                e.Graphics.DrawString(Caption, captionFont, captionBrush,
                                      graphBorder.Left + graphBorder.Width / 2 - captionSize.Width / 2,
                                      graphBorder.Top - captionSize.Height - axisLblMaxSize.Height);

                string lbl     = "Z, m";
                var    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.TranslateTransform(
                    graphBorder.Left - axisTickSize - axisLblMaxSize.Width - lblSize.Height,
                    graphBorder.Top + graphBorder.Height / 2 - lblSize.Width / 2);
                e.Graphics.RotateTransform(-90);
                e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush, 0, 0);
                e.Graphics.RotateTransform(90);
                e.Graphics.TranslateTransform(
                    graphBorder.Left - axisTickSize - axisLblMaxSize.Width - lblSize.Height,
                    -(graphBorder.Top + graphBorder.Height / 2 - lblSize.Width / 2));

                float z;
                float zStep = Convert.ToSingle(zstep);
                float x     = graphBorder.Left;
                z = zStep;

                float za;
                while (z <= Zmax - zStep / 2)
                {
                    za = graphBorder.Top + z * zscale;
                    e.Graphics.DrawLine(axisPen, x, za, x - axisTickSize, za);
                    lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F00}", z);
                    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);

                    e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                          x - axisTickSize - lblSize.Width,
                                          za - lblSize.Height / 2);

                    z += zStep;
                }

                lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F00}", Zmin);
                lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                      x - axisTickSize - lblSize.Width,
                                      graphBorder.Top - lblSize.Height / 2);

                lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F00}", Zmax);
                lblSize = e.Graphics.MeasureString(lbl, axisLblFont);
                e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                      x - axisTickSize - lblSize.Width,
                                      graphBorder.Bottom - lblSize.Height / 2);



                int nView = zcoordinates.Count;
                if (nView > 0)
                {
                    float viewWidth     = graphBorder.Width / nView;
                    float viewHalfWidth = viewWidth / 2.0f;
                    float viewCenter;
                    float frontZcoordinate;
                    float dir = Convert.ToSingle(direction);

                    double[] zcoords = new double[zcoordinates.Count];
                    double[] zmaxs   = new double[zmaxPoints.Count];
                    double[] cspeeds = new double[speeds.Count];
                    string[] vnames  = new string[zcoordinates.Count];

                    zcoordinates.Values.CopyTo(zcoords, 0);
                    zmaxPoints.Values.CopyTo(zmaxs, 0);
                    speeds.Values.CopyTo(cspeeds, 0);
                    zcoordinates.Keys.CopyTo(vnames, 0);

                    float zLowLimit = graphBorder.Bottom;

                    for (int view = 0; view < zcoords.Length; view++)
                    {
                        lbl = string.Format(CultureInfo.InvariantCulture, "{0}, v={1:F02} m/s",
                                            vnames[view], cspeeds[view]);

                        lblSize = e.Graphics.MeasureString(lbl, axisLblFont);

                        viewCenter = graphBorder.Left + viewWidth * (view + 1) - viewHalfWidth;

                        e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                              viewCenter - lblSize.Width / 2,
                                              graphBorder.Top - lblSize.Height);

                        e.Graphics.DrawLine(axisPen, graphBorder.Left + viewWidth * (view + 1), graphBorder.Top,
                                            graphBorder.Left + viewWidth * (view + 1), graphBorder.Bottom);


                        if (zmaxs[view] > 0)
                        {
                            lbl     = string.Format(CultureInfo.InvariantCulture, "{0:F02} m", zmaxs[view]);
                            lblSize = e.Graphics.MeasureString(lbl, axisLblFont);

                            zLowLimit = graphBorder.Top + Convert.ToSingle(zmaxs[view]) * zscale;

                            if (zLowLimit > graphBorder.Bottom)
                            {
                                e.Graphics.DrawString(lbl, axisLblFont, captionBrush,
                                                      graphBorder.Left + viewWidth * view + lblSize.Height, graphBorder.Top + lblSize.Height);
                            }
                            else
                            {
                                e.Graphics.DrawLine(frontPen,
                                                    graphBorder.Left + viewWidth * view, zLowLimit,
                                                    graphBorder.Left + viewWidth * (view + 1), zLowLimit);

                                e.Graphics.DrawString(lbl, axisLblFont, captionBrush,
                                                      graphBorder.Left + viewWidth * view + lblSize.Height, zLowLimit + lblSize.Height / 2);
                            }
                        }


                        if (timer.IsRunning)
                        {
                            frontZcoordinate = graphBorder.Top + Convert.ToSingle(zcoords[view] * zscale);
                            frontZcoordinate = frontZcoordinate > graphBorder.Bottom ? graphBorder.Bottom : frontZcoordinate;
                            frontZcoordinate = frontZcoordinate < graphBorder.Top ? graphBorder.Top : frontZcoordinate;

                            int   frontAlpha = 255;
                            float fst;
                            float fnd;
                            for (int i = 0; i < frontSegments - 1; i++)
                            {
                                fst = frontZcoordinate - dir * i * frontSegmentSize;
                                fnd = frontZcoordinate - dir * (i + 1) * frontSegmentSize;

                                fst = fst > zLowLimit ? zLowLimit : fst;
                                fst = fst < graphBorder.Top ? graphBorder.Top : fst;
                                fnd = fnd > zLowLimit ? zLowLimit : fnd;
                                fnd = fnd < graphBorder.Top ? graphBorder.Top : fnd;

                                e.Graphics.DrawLine(new Pen(Color.FromArgb(frontAlpha, frontColor), fronPenWidth),
                                                    viewCenter, fst,
                                                    viewCenter, fnd);

                                frontAlpha -= dAlpha;
                            }
                        }
                    }

                    lbl     = string.Format(CultureInfo.InvariantCulture, "t = {0:F02} s", t);
                    lblSize = e.Graphics.MeasureString(lbl, axisLblFont);

                    e.Graphics.DrawString(lbl, axisLblFont, axisLblBrush,
                                          graphBorder.Left + graphBorder.Width / 2.0f - lblSize.Width / 2,
                                          graphBorder.Bottom);
                }
            }
        }