Beispiel #1
0
 /********************************************************************************
  *
  * Method: DrawYAxis
  *
  * Arguments: PictureBox p, bool need_it_for_line, bool need_it_for_quadratic,
  *            bool need_it_for_cubic, bool need_it_for_circle
  *
  * Return Type: void
  *
  * Purpose: Draws X Axis conditionally, depending on the coordinates.
  *
  * *******************************************************************************/
 private void DrawYAxis(PictureBox p, bool need_it_for_line, bool need_it_for_quadratic, bool need_it_for_cubic, bool need_it_for_circle)
 {
     if (need_it_for_line == true)
     {
         p = Playing_Field;
         Graphics lg = Playing_Field.CreateGraphics();
         lg.DrawLine(myWhitePen, (Playing_Field.Width / 2), 0,
                     (Playing_Field.Width / 2), Playing_Field.Height);
     }
     else
     {
         p = Playing_Field;
         Graphics lg = Playing_Field.CreateGraphics();
         lg.DrawLine(myWhitePen, (Playing_Field.Width / 2) - 150, 0,
                     (Playing_Field.Width / 2) - 150, Playing_Field.Height);
     }
     if (need_it_for_quadratic == true)
     {
         p = QuadraticPlayingField;
         Graphics qg = QuadraticPlayingField.CreateGraphics();
         qg.DrawLine(myWhitePen, (QuadraticPlayingField.Width / 2), 0,
                     (QuadraticPlayingField.Width / 2), QuadraticPlayingField.Height);
     }
     else
     {
         p = QuadraticPlayingField;
         Graphics qg = QuadraticPlayingField.CreateGraphics();
         qg.DrawLine(myWhitePen, (QuadraticPlayingField.Width / 2) - 150, 0,
                     (QuadraticPlayingField.Width / 2) - 150, QuadraticPlayingField.Height);
     }
     if (need_it_for_cubic == true)
     {
         p = CubicPlayingField;
         Graphics cubic_g = CubicPlayingField.CreateGraphics();
         cubic_g.DrawLine(myWhitePen, (CubicPlayingField.Width / 2), 0,
                          (CubicPlayingField.Width / 2), CubicPlayingField.Height);
     }
     else
     {
         p = CubicPlayingField;
         Graphics cubic_g = CubicPlayingField.CreateGraphics();
         cubic_g.DrawLine(myWhitePen, (CubicPlayingField.Width / 2) - 150, 0,
                          (CubicPlayingField.Width / 2) - 150, CubicPlayingField.Height);
     }
     if (need_it_for_circle == true)
     {
         p = CirclePlayingField;
         Graphics cg = CirclePlayingField.CreateGraphics();
         cg.DrawLine(myWhitePen, (CirclePlayingField.Width / 2), 0,
                     (CirclePlayingField.Width / 2), CirclePlayingField.Height);
     }
     else
     {
         p = CirclePlayingField;
         Graphics cg = CirclePlayingField.CreateGraphics();
         cg.DrawLine(myWhitePen, (CirclePlayingField.Width / 2) - 150, 0,
                     (CirclePlayingField.Width / 2) - 150, CirclePlayingField.Height);
     }
 }
Beispiel #2
0
        /********************************************************************************
         *
         * Method: DrawCubic
         *
         * Arguments: float a, float b, float c, float d
         *
         * Return Type: void
         *
         * Purpose: Draws a curve with specific coordinates through the plane.
         *
         * *******************************************************************************/
        void DrawCubic(float a, float b, float c, float d)
        {
            Graphics g         = CubicPlayingField.CreateGraphics();
            Pen      cubic_pen = new Pen(Color.Green);

            int standard_origin_x = QuadraticPlayingField.Width / 2;
            int standard_origin_y = QuadraticPlayingField.Height / 2;

            int origin_x = standard_origin_x;
            int origin_y = standard_origin_y;


            Point[] points = new Point[9];
            int     index  = 0;

            for (int x = -240; x <= 240; x += 60)
            {
                int   relative_x = x / 60;
                float y          = 50 * ((a * (relative_x * relative_x * relative_x)) + (b * relative_x * relative_x) + (c * relative_x) + d);
                points[index++] = new Point(origin_x + x, (int)(origin_y - y));
                Console.WriteLine(" x: " + x + " y: " + y);
            }
            g.DrawCurve(cubic_pen, points);
        }
Beispiel #3
0
        /********************************************************************************
         *
         * Method: CalculateEquationsBtn_Click
         *
         * Arguments: object sender, EventArgs e
         *
         * Return Type: void
         *
         * Purpose: Handles button click events and display a graph or an error.
         *
         * *******************************************************************************/
        private void CalculateEquationsBtn_Click(object sender, EventArgs e)
        {
            Graphics   lg           = Playing_Field.CreateGraphics();
            Graphics   qg           = QuadraticPlayingField.CreateGraphics();
            Graphics   cubic_g      = CubicPlayingField.CreateGraphics();
            Graphics   cg           = CirclePlayingField.CreateGraphics();
            SolidBrush paintItBlack = new SolidBrush(Color.Black);

            if ((LineMTextBox.Text != "" &&
                 (Regex.IsMatch(LineMTextBox.Text, @"^\d+$") || Regex.IsMatch(LineMTextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (LineBTextBox.Text != "" &&
                 (Regex.IsMatch(LineBTextBox.Text, @"^\d+$") || Regex.IsMatch(LineBTextBox.Text, @"^[-+]?\d+\.?\d*$"))))
            {
                lg.FillRectangle(paintItBlack, 0, 0, Playing_Field.Width, Playing_Field.Height);
                float m_for_Line = (float)Convert.ToDouble(LineMTextBox.Text);
                float b_for_Line = (float)Convert.ToDouble(LineBTextBox.Text);

                bool need_Y_for_line = b_for_Line != 0;
                bool need_X_for_line = b_for_Line < 0 || m_for_Line < 0;

                DrawXAxis(Playing_Field, need_X_for_line, false, false, false);
                DrawYAxis(Playing_Field, need_Y_for_line, false, false, false);
                DrawTicks(Playing_Field, need_X_for_line, need_Y_for_line);
                DrawLine(m_for_Line, b_for_Line, need_X_for_line, need_Y_for_line);
            }
            if ((QuadraticATextBox.Text != "" && (Regex.IsMatch(QuadraticATextBox.Text, @"^\d+$") || Regex.IsMatch(QuadraticATextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (QuadraticBTextBox.Text != "" && (Regex.IsMatch(QuadraticBTextBox.Text, @"^\d+$") || Regex.IsMatch(QuadraticBTextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (QuadraticCTextBox.Text != "" && (Regex.IsMatch(QuadraticCTextBox.Text, @"^\d+$") || Regex.IsMatch(QuadraticCTextBox.Text, @"^[-+]?\d+\.?\d*$"))))
            {
                qg.FillRectangle(paintItBlack, 0, 0, QuadraticPlayingField.Width, QuadraticPlayingField.Height);

                float a = (float)Convert.ToDouble(QuadraticATextBox.Text.ToString());
                float b = (float)Convert.ToDouble(QuadraticBTextBox.Text.ToString());
                float c = (float)Convert.ToDouble(QuadraticCTextBox.Text.ToString());

                bool need_Y_for_quad = true;
                bool need_X_for_quad = a < 0 || b < 0 || c < 0;

                // y = ax2 + bx + c
                // Create pens.
                Pen redPen = new Pen(Color.Red);
                DrawXAxis(QuadraticPlayingField, false, need_X_for_quad, false, false);
                DrawYAxis(QuadraticPlayingField, false, need_Y_for_quad, false, false);
                DrawTicks(QuadraticPlayingField, need_X_for_quad, need_Y_for_quad);
                // Draw curve to screen.
                DrawQuadratic(a, b, c);
            }
            if ((CubicATextBox.Text != "" && (Regex.IsMatch(CubicATextBox.Text, @"^\d+$") || Regex.IsMatch(CubicATextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (CubicBTextBox.Text != "" && (Regex.IsMatch(CubicBTextBox.Text, @"^\d+$") || Regex.IsMatch(CubicBTextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (CubicCTextBox.Text != "" && (Regex.IsMatch(CubicCTextBox.Text, @"^\d+$") || Regex.IsMatch(CubicCTextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (CubicDTextBox.Text != "" && (Regex.IsMatch(CubicDTextBox.Text, @"^\d+$") || Regex.IsMatch(CubicDTextBox.Text, @"^[-+]?\d+\.?\d*$"))))
            {
                cubic_g.FillRectangle(paintItBlack, 0, 0, CubicPlayingField.Width, CubicPlayingField.Height);

                float cubicA = (float)Convert.ToDouble(CubicATextBox.Text);
                float cubicB = (float)Convert.ToDouble(CubicBTextBox.Text);
                float cubicC = (float)Convert.ToDouble(CubicCTextBox.Text);
                float cubicD = (float)Convert.ToDouble(CubicDTextBox.Text);

                bool need_Y_for_Cubic = true;
                bool need_X_for_Cubic = true;

                DrawXAxis(CubicPlayingField, false, false, need_X_for_Cubic, false);
                DrawYAxis(CubicPlayingField, false, false, need_Y_for_Cubic, false);
                DrawTicks(CubicPlayingField, need_X_for_Cubic, need_Y_for_Cubic);
                // Draw curve to screen.
                DrawCubic(cubicA, cubicB, cubicC, cubicD);
            }
            if ((HCircleTextBox.Text != "" && (Regex.IsMatch(HCircleTextBox.Text, @"^\d+$") || Regex.IsMatch(HCircleTextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                (KCircleTextBox.Text != "" && (Regex.IsMatch(KCircleTextBox.Text, @"^\d+$") || Regex.IsMatch(KCircleTextBox.Text, @"^[-+]?\d+\.?\d*$"))) &&
                RCircleTextBox.Text != "" && (Regex.IsMatch(RCircleTextBox.Text, @"^\d+$") || Regex.IsMatch(RCircleTextBox.Text, @"^[-+]?\d+\.?\d*$")))
            {
                cg.FillRectangle(paintItBlack, 0, 0, CirclePlayingField.Width, CirclePlayingField.Height);

                float h = (float)Convert.ToDouble(HCircleTextBox.Text);
                float k = (float)Convert.ToDouble(KCircleTextBox.Text);
                float r = (float)Convert.ToDouble(RCircleTextBox.Text);

                bool need_Y_for_circle = k < 0;
                bool need_X_for_circle = h < 0;

                DrawXAxis(CirclePlayingField, false, false, false, need_X_for_circle);
                DrawYAxis(CirclePlayingField, false, false, false, need_Y_for_circle);
                DrawTicks(CirclePlayingField, need_X_for_circle, need_Y_for_circle);
                DrawCircle(h, k, r, need_X_for_circle, need_Y_for_circle);
            }
            //else
            //{
            //    DisplayError("other");
            //}
        }