Posts tagged experiences

This was an interesting piece of code from a long time mentor and friend. He’s just started to learn Java some time ago, and has written this program to demonstrate how to draw an Ellipse.

He’s about 60 years of age. Has been a long time Turbo C-2.0 programmer. Mostly he develops small graphics programs to demonstrate some engineering drawing and mechanics concepts.

import java.awt.*; // Requisite files od JAVA
import java.awt.event.*;
//import java.awt.geom.*;
import javax.swing.*;
//import java.math.*;
//import java.util.*;
  //Projest name and the following class name should be same
public class leenaTrial1 extends JFrame {
        JFrame frame = new JFrame("Applet");
        JPanel drawingArea = new JPanel(); // Drawing Area is named
        JButton b1; // Defines action Button
        int mouse_i = 1;  // Counter for action

        public void run() {
                frame.setSize(1000, 500); // Frame size is defined
                final Container content = getContentPane();
                content.setBackground(Color.lightGray);
                // color of frame or container is defined
                content.setLayout(new FlowLayout());

                drawingArea.setPreferredSize(new Dimension(750, 700));
                // Size of draw area is defined & color in the next line

                drawingArea.setBackground(Color.black);
                content.add(drawingArea);
                b1 = new JButton("Next Step"); // b1 is button for the next step
                content.add(b1);

                b1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent event) {
                        Graphics g = drawingArea.getGraphics();
                        Font font20 =new Font("TimesRoman",Font.PLAIN,20);
                        Font f0nt14=new Font("TimesRoman",Font.PLAIN,14);
                        g.setFont(font20);
                        int r1 = 250, r2 = 150, x0 = 375, y0 = 415;
                        // r1, r2 semi-major & semi-minor axex, x0,y0 center of circles
                        double inc = 0.005; // increment 
                        int x1, y1, x2, y2; // Two ends of a line

                        // inner circle in 
                        if(mouse_i == 1) {
                                g.setColor(Color.white);
                                //g.drawOval(w, w, x, y);           // top, left, width, height
                                g.drawString("Step 1: Draw inner circle with the radius equal to semi-minor axis of the ellipse.", 20, 20);
                                ovalByPixels(x0,y0,r2,r2,1,Color.blue);
                     }

                        // outer circle
                         if(mouse_i == 2) {
                                g.setColor(Color.white);
                                g.drawString("Step 2: Draw outer circle with the radius equal to semi-major axis of the ellipse.", 20, 35);
                                ovalByPixels(x0,y0,r1,r1,1,Color.red); // Color spesified by name
                        }

                        // twelve lines
                         if(mouse_i == 3) {
                                g.setColor(Color.white);
                                g.drawString("Step 3: Divide the circles in twelve parts.", 20, 50);
                                for(int k = 0; k < 6; k++) {
                                        double cos = Math.cos(k*2*Math.PI/12);
                                        double sin = Math.sin(k*2*Math.PI/12);
                                        double f1 = 1.06 ; // numbers are printed out side of larger circle
                                        double f2 = 0.9 ; // numbers are printed in side of smaller circle
                                        x1 = x0 + (int)(r1*cos); // x1,y1 are on outer circle on one end of diameter
                                        y1 = y0 - (int)(r1*sin);
                                        x2 = x0 - (int)(r1*cos); // x2,y2 are on outer circle at other end of diameter
                                        y2 = y0 + (int)(r1*sin);
                                        lineByPixels(x1, y1, x2, y2,5,new Color(255,100,100)); // 5 is delay value
                                        // Color spesified by values of three colors
                                        g.drawString("a" + Integer.toString(k+1),  x0-10+ (int)(f1*r1*cos), y0+10 - (int)(f1*r1*sin));
                                        g.drawString("a" + Integer.toString(k+7),  x0-10 - (int)(f1*r1*cos), y0+10 + (int)(f1*r1*sin));
                                        g.drawString("b" + Integer.toString(k+1),  x0 -10+ (int)(f2*r2*cos), y0+10 - (int)(f2*r2*sin));
                                        g.drawString("b" + Integer.toString(k+7),  x0 -10- (int)(f2*r2*cos), y0+10 + (int)(f2*r2*sin));
                                        delay(500);        // call delay function         
                                }
                        }

                         if(mouse_i == 4) { // Step 4     * * * * * * * * * * *
                                g.setColor(Color.white);
                                g.drawString("Step 4: From inner circle points, draw horizontal lines and from corresponding points ", 20, 70);
                                g.drawString("         on the outer circle, draw vertical lines. Cutting points are points on Ellipse.", 20, 85);
                                Color cr = new Color(255,200,100);
                                for(int k = 0; k <= 11; k++) {
                                        //int x1,x2,y1,y2;
                                        x1 = x0 + (int)(r1*Math.cos((2*Math.PI/12)*k)); // point on outer circle
                                        y1 = y0 - (int)(r1*Math.sin((2*Math.PI/12)*k));
                                        x2 = x0 + (int)(r2*Math.cos((2*Math.PI/12)*k)); //points on inner circle
                                        y2 = y0 - (int)(r2*Math.sin((2*Math.PI/12)*k));
                                        int x1L = x0 + (int)(1.2*r1*Math.cos((2*Math.PI/12)*k)); // point on outer circle
                                        int y2L = y0 - (int)(0.9*r2*Math.sin((2*Math.PI/12)*k));
                                        g.setColor(Color.green);
                                        if(k==3 || k==9){
                                                lineByPixels(x0-20, y2, x0+20, y2,5,cr );}// 5 is delay value
                           //g.drawLine( x0-20, y2, x0+20, y2);}
                                        else{
                                                lineByPixels(x2, y2, x1L, y2,5,new Color(255,100,200));}
                                                //g.drawLine(x2, y2, x1L, y2);} // horizontal line
                                        g.setColor(Color.yellow);
                                        if(k==0 || k==6){
                                                lineByPixels(x1, y0-20, x1,  y0+20,5,new Color(100,100,200));}
                                                //g.drawLine(x1, y0-20, x1,  y0+20);}// Vertical line
                                        else {
                                                lineByPixels(x1, y1, x1, y2L,5,new Color(100,255,100));}
                                                //g.drawLine(x1, y1, x1, y2L);}// vertical line
                                        delay(500); // call delay function         
                                        g.setColor(Color.white);
                                        g.drawOval(x1-3, y2-3, 6, 6); // Box (top, left, width, height
                    delay(500);
                                }
                        }

                        if(mouse_i == 5) {
                                g.setColor(Color.white);
                                g.drawString("Step 5: Draw a smooth curve connecting the twelve cutting points.", 20, 100);
                                g.setColor(Color.RED);
                                for(double i = 0; i < 2*(3.1415926); i=i+inc) {
                                        g.drawLine((int)(x0+r1*Math.cos(i)), (int)(y0-r2*Math.sin(i)), (int)(x0+(r1+1)*Math.cos(i)), (int)(y0-(r2+1)*Math.sin(i)));
                                        delay(1); // calls delay function

                                } // Ellipse drawing is complete

                                g.drawString("Ellipse by Concentric Circles, by Dr. Vasant D. Barve", 20, 680);
                                g.drawString("DONE!", 670, 350);
                        }
                        mouse_i++;
                 }
                });

                pack();
                setVisible(true);
        }
    // This is delay procedure  
        public void delay(int dt1)
        {
                try {
                        Thread.sleep(dt1);
                }
                catch (InterruptedException e) {
                }
        } // Delay procedure ends

    // This is Oval (circle or ellipse) by pixel procedure   * * * * * * * * * * * * * * *      
        public void ovalByPixels(float x0, float y0, float r1, float r2, int dt, Color objColor)
        {   // Center of circle at x0,y0 Radius r dt delay after each pixel counterclckwise
                Graphics g = drawingArea.getGraphics();
                double rm = Math.max(r1, r2); // Greater of the two picked up
                for(double i = 0; i < 2*(3.1415926); i=i+1/rm) {
                        double x1 = x0+ r1*Math.cos(i);
                        double y1 = y0+r2*Math.sin(i);
                        double x2 = x0+(r1+1)*Math.cos(i);
                        double y2 = y0+(r2+1)*Math.sin(i);
                        g.setColor(objColor);
                        g.drawLine((int)x1, (int)y1, (int)x2, (int)y2);
                        delay(dt); // call delay function    
                }
        } // OvalByPixels procedure Ends

//       lineByPixels Procedure starts              * * * * * *  * * * * *
        public void lineByPixels(int x1, int y1, int x2, int y2, int dt,Color objCol ) {
                // Line starts at (x1,y1) & ends at (x2,y2) each point is drawn as short line of one pixel length
                Graphics g = drawingArea.getGraphics();
                //g.setColor(Color.white); 
                g.setColor(objCol);

                int L= (int) Math.sqrt(Math.pow(x2-x1,2)+Math.pow(y2-y1,2));
            // length of line is found
                double th=Math.atan2(y2-y1,x2-x1); // inclination of line with x axis
               for(int i=0; i<=L-1; i=i+1)
            { g.drawLine((int) (x1+i*Math.cos(th)), (int) (y1+i*Math.sin(th)),(int) (x1+(i+1)*Math.cos(th)), (int) (y1+(i+1)*Math.sin(th)));
          delay(dt);    //delay introduced to see line being drawn    
            }
        } // lineByPixels Procedure Ends

        // Paint graphics starts                     * * * * * * * * *
        public void paint(Graphics g) {
                super.paint(g);
        } // Paint graphics Ends

        public static void main(String[] args) {
                leenaTrial1 ecc = new leenaTrial1(); // here the function is called
                ecc.run();
        }
}