#1
  1. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Nov 2013
    Posts
    4
    Rep Power
    0

    Recursive tronimos


    I am fairly new to CS and in class we are working with recursive methods. I have been struggling with an assignment for several hours and am at a loss so hopefully someone here can at least point me in the right direction.


    The assignment i am working on basically is to run a program which:
    takes in 3 runtime arguments the first one being the value for n in 2^n by 2^n ( so if the first arg is 3 the board is 8 by 8).

    the second and third args are the coordinates of the missing tile as there will always be one tile missing.(so if arg2 is 1 and arg 3 is 2 then there should be no tile on the first row second column)
    it then opens a drawing panel creates the board and then uses recursion to fill the board with tronimos relative to the missing square.


    heres my code, sorry its kind of messy i've reached the point where I just change whatever i possibly can to see if it will magically work.



    Code:
    import java.awt.*;
    import java.util.*;
    public class TrominoSolver2
    {
    
       public static void main(String args[])
       {
          String arg1 = args[0];
          String arg2 = args[1];
          String arg3 = args[2];
          if (args.length > 3)
          {
             System.out.println("too many arguments.");
             System.exit(1);
          }  
          
          int size = 2;
          for (int i = Integer.parseInt(arg1); i != 1;i--)
             size = 2*size;
           
          boolean correct =  checkArgs(arg1,arg2,arg3, size);
          
          System.out.println(correct);
          int firstArg = Integer.parseInt(arg1);
          int secondArg = Integer.parseInt(arg2);
          int thirdArg = Integer.parseInt(arg3);
          
          int q = 0;
          int refX = 500;
          int refY = 500;
          double squareX = (refX - 25*(size/2))+12.5 +(25*size);
          double squareY = (refY - 25*(size/2))+12.5 +(25*size); 
          
          System.out.println("sqx: " + squareX + " sqY: " + squareY);
          System.out.println("refx: " + refX + " refY: " + refY);
         
         
          
          if (squareX < refX)
          {
             //quadrant3
             q = 1;
             System.out.println("me");
             if (squareY < refY)
             {
                //quadrant2
                q = 2;
             }
    
          }
          else
          {
             if (squareY > refY)
             {
                q = 4;
             }
             if (squareX < refX)
                {
                   q = 3;
                }
          }
          
          //if (squareX == refX && squareY == refY)
         // {
          //   q = 4;
          //}
    
          DrawingPanel board = new DrawingPanel(1000, 1000);
         
          board.setBackground(Color.WHITE);
          
          Graphics g = board.getGraphics();
    
               solve(g,squareX,squareY, refX, refY, size, firstArg,q);
                drawBoard(g, firstArg, refX,refY, size);
    
          //placeEmptySquare(g, firstArg, secondArg, thirdArg, size);
       
       
       
       }
    
    
    
       public static void drawBoard(Graphics g, int z , int refX, int refY, int size)
       {
                   
             
          System.out.println("size = "+size+" by " + size);
          for( int i = size/2; i != -size/2-1; i--)
          {
          
             g.setColor(Color.BLACK);
             //System.out.println(i);
             g.drawLine(refX + (25*i), refY - 25*(size/2), refX + (25*i), refY + 25*(size/2));
             g.drawLine(refX - (25*(size/2)), refY + 25*i, refX + (25*(size/2)), refY + 25*i);
            
          }
          
    
    
    
    
       }
    
       public static boolean checkArgs( String arg1,String arg2,String arg3,int size)
       {
          boolean correct = false;
          int firstArg = 0;
          int secondArg = 0;
          int thirdArg = 0;
          
          try 
          {
             firstArg = Integer.parseInt(arg1);
             secondArg = Integer.parseInt(arg2);
             thirdArg = Integer.parseInt(arg3);
          } 
          catch (NumberFormatException e) 
          {
             System.err.println("Argument" + " must be an integer");
             System.exit(1);
          }
          System.out.println(firstArg+" "+secondArg+" "+thirdArg);
          
          if (firstArg < 1 || firstArg > 5)
          {
             System.out.println("argument 1 must be within 1 to 5");
             System.exit(1);
          }
          
          if (secondArg >= size || secondArg < 0 || thirdArg >= size || thirdArg < 0)
          {
             System.out.println("argument 2 and 3 must be within the array and greater than 0");
             System.exit(1);
          }
    
          correct = true;
          
       
       
          return correct;
       }
       
       public static void placeTromino(Graphics g,double squareX, double squareY, int refX, int refY,int size,int n,int q)
       {
       System.out.println("wtf q is : "+q);
       if (q == 1)
       {
       g.setColor(Color.GREEN);
       g.fillRect(refX-25, refY-25, 25,50);
       g.fillRect(refX-25,refY, 50,25);
       }
       if (q==2)
       {
       g.setColor(Color.CYAN);
       g.fillRect(refX, refY - 25, 25,50);
       g.fillRect(refX-25,refY, 50,25);       
       }
       if (q==3)
       {
       g.setColor(Color.YELLOW);
       g.fillRect(refX-25, refY - 25, 50,25);
       g.fillRect(refX,refY - 25,25,50);
       
       }
       
       if (q == 4)
       {
       g.setColor(Color.RED);
       g.fillRect(refX-25, refY - 25, 25,50);
       g.fillRect(refX-25,refY-25, 50,25);
       }
       return;
       
       }
    
    
       public static void solve(Graphics g,double squareX,double squareY,int refX,int refY,int size,int n, int q)
       {
          //System.out.println("FIRST: " + q);
          System.out.println("squareX/Y: " + squareX +" " + squareY);
          
          if (size == 2)
          {
            
             placeTromino(g,squareX, squareY, refX, refY,size, n,q); 
             return;
          }
          placeTromino(g,squareX, squareY, refX, refY,size, n,q); 
    
       
    
    
    
             
             
             solve(g,squareX, squareY, refX+25*size/4, refY-25*size/4,size/2,1+n-1,q);
            
             //solve(g,refX-25, refY-25, refX-25*size/4, refY-25*size/4,size/2,n-1,q);
             //solve(g,refX-25, refY+25, refX-25*size/4, refY-25*size/4,size/2,n-1,q);
             //solve(g,refX, refY, refX+25*size/4, refY+25*size/4,size/2,n-1,q);
          
      
       
          
    
          
       }
       
       
    }
  2. #2
  3. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Nov 2013
    Posts
    4
    Rep Power
    0
    also it requires this stddraw.java which i will post here in 2 parts because it is pretty large.

    Code:
    /*************************************************************************
     *  Compilation:  javac StdDraw.java
     *  Execution:    java StdDraw
     *
     *  Standard drawing library. This class provides a basic capability for
     *  creating drawings with your programs. It uses a simple graphics model that
     *  allows you to create drawings consisting of points, lines, and curves
     *  in a window on your computer and to save the drawings to a file.
     *
     *  Todo
     *  ----
     *    -  Add support for gradient fill, etc.
     *    -  Fix setCanvasSize() so that it can only be called once.
     *
     *  Remarks
     *  -------
     *    -  don't use AffineTransform for rescaling since it inverts
     *       images and strings
     *    -  careful using setFont in inner loop within an animation -
     *       it can cause flicker
     *
     *************************************************************************/
    
    import java.awt.*;
    import java.awt.event.*;
    import java.awt.geom.*;
    import java.awt.image.*;
    import java.io.*;
    import java.net.*;
    import java.util.LinkedList;
    import java.util.TreeSet;
    import javax.imageio.ImageIO;
    import javax.swing.*;
    
    /**
     *  <i>Standard draw</i>. This class provides a basic capability for
     *  creating drawings with your programs. It uses a simple graphics model that
     *  allows you to create drawings consisting of points, lines, and curves
     *  in a window on your computer and to save the drawings to a file.
     *  <p>
     *  For additional documentation, see <a href="http://introcs.cs.princeton.edu/15inout">Section 1.5</a> of
     *  <i>Introduction to Programming in Java: An Interdisciplinary Approach</i> by Robert Sedgewick and Kevin Wayne.
     *
     *  @author Robert Sedgewick
     *  @author Kevin Wayne
     */
    public final class StdDraw implements ActionListener, MouseListener, MouseMotionListener, KeyListener {
    
        // pre-defined colors
        public static final Color BLACK      = Color.BLACK;
        public static final Color BLUE       = Color.BLUE;
        public static final Color CYAN       = Color.CYAN;
        public static final Color DARK_GRAY  = Color.DARK_GRAY;
        public static final Color GRAY       = Color.GRAY;
        public static final Color GREEN      = Color.GREEN;
        public static final Color LIGHT_GRAY = Color.LIGHT_GRAY;
        public static final Color MAGENTA    = Color.MAGENTA;
        public static final Color ORANGE     = Color.ORANGE;
        public static final Color PINK       = Color.PINK;
        public static final Color RED        = Color.RED;
        public static final Color WHITE      = Color.WHITE;
        public static final Color YELLOW     = Color.YELLOW;
    
        /**
         * Shade of blue used in Introduction to Programming in Java.
         * It is Pantone 300U. The RGB values are approximately (9, 90, 166).
         */
        public static final Color BOOK_BLUE       = new Color(  9,  90, 166);
        public static final Color BOOK_LIGHT_BLUE = new Color(103, 198, 243);
    
        /**
         * Shade of red used in Algorithms 4th edition.
         * It is Pantone 1805U. The RGB values are approximately (150, 35, 31).
         */
        public static final Color BOOK_RED = new Color(150, 35, 31);
    
        // default colors
        private static final Color DEFAULT_PEN_COLOR   = BLACK;
        private static final Color DEFAULT_CLEAR_COLOR = WHITE;
    
        // current pen color
        private static Color penColor;
    
        // default canvas size is DEFAULT_SIZE-by-DEFAULT_SIZE
        private static final int DEFAULT_SIZE = 512;
        private static int width  = DEFAULT_SIZE;
        private static int height = DEFAULT_SIZE;
    
        // default pen radius
        private static final double DEFAULT_PEN_RADIUS = 0.002;
    
        // current pen radius
        private static double penRadius;
    
        // show we draw immediately or wait until next show?
        private static boolean defer = false;
    
        // boundary of drawing canvas, 5% border
        private static final double BORDER = 0.05;
        private static final double DEFAULT_XMIN = 0.0;
        private static final double DEFAULT_XMAX = 1.0;
        private static final double DEFAULT_YMIN = 0.0;
        private static final double DEFAULT_YMAX = 1.0;
        private static double xmin, ymin, xmax, ymax;
    
        // for synchronization
        private static Object mouseLock = new Object();
        private static Object keyLock = new Object();
    
        // default font
        private static final Font DEFAULT_FONT = new Font("SansSerif", Font.PLAIN, 16);
    
        // current font
        private static Font font;
    
        // double buffered graphics
        private static BufferedImage offscreenImage, onscreenImage;
        private static Graphics2D offscreen, onscreen;
    
        // singleton for callbacks: avoids generation of extra .class files
        private static StdDraw std = new StdDraw();
    
        // the frame for drawing to the screen
        private static JFrame frame;
    
        // mouse state
        private static boolean mousePressed = false;
        private static double mouseX = 0;
        private static double mouseY = 0;
    
        // queue of typed key characters
        private static LinkedList<Character> keysTyped = new LinkedList<Character>();
    
        // set of key codes currently pressed down
        private static TreeSet<Integer> keysDown = new TreeSet<Integer>();
      
    
        // singleton pattern: client can't instantiate
        private StdDraw() { }
    
    
        // static initializer
        static { init(); }
    
        /**
         * Set the window size to the default size 512-by-512 pixels.
         * This method must be called before any other commands.
         */
        public static void setCanvasSize() {
            setCanvasSize(DEFAULT_SIZE, DEFAULT_SIZE);
        }
    
        /**
         * Set the window size to w-by-h pixels.
         * This method must be called before any other commands.
         *
         * @param w the width as a number of pixels
         * @param h the height as a number of pixels
         * @throws a IllegalArgumentException if the width or height is 0 or negative
         */
        public static void setCanvasSize(int w, int h) {
            if (w < 1 || h < 1) throw new IllegalArgumentException("width and height must be positive");
            width = w;
            height = h;
            init();
        }
    
        // init
        private static void init() {
            if (frame != null) frame.setVisible(false);
            frame = new JFrame();
            offscreenImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
            onscreenImage  = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
            offscreen = offscreenImage.createGraphics();
            onscreen  = onscreenImage.createGraphics();
            setXscale();
            setYscale();
            offscreen.setColor(DEFAULT_CLEAR_COLOR);
            offscreen.fillRect(0, 0, width, height);
            setPenColor();
            setPenRadius();
            setFont();
            clear();
    
            // add antialiasing
            RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
                                                      RenderingHints.VALUE_ANTIALIAS_ON);
            hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
            offscreen.addRenderingHints(hints);
    
            // frame stuff
            ImageIcon icon = new ImageIcon(onscreenImage);
            JLabel draw = new JLabel(icon);
    
            draw.addMouseListener(std);
            draw.addMouseMotionListener(std);
    
            frame.setContentPane(draw);
            frame.addKeyListener(std);    // JLabel cannot get keyboard focus
            frame.setResizable(false);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            // closes all windows
            // frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);      // closes only current window
            frame.setTitle("Standard Draw");
            frame.setJMenuBar(createMenuBar());
            frame.pack();
            frame.requestFocusInWindow();
            frame.setVisible(true);
        }
    
        // create the menu bar (changed to private)
        private static JMenuBar createMenuBar() {
            JMenuBar menuBar = new JMenuBar();
            JMenu menu = new JMenu("File");
            menuBar.add(menu);
            JMenuItem menuItem1 = new JMenuItem(" Save...   ");
            menuItem1.addActionListener(std);
            menuItem1.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,
                                    Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
            menu.add(menuItem1);
            return menuBar;
        }
    
    
       /*************************************************************************
        *  User and screen coordinate systems
        *************************************************************************/
    
        /**
         * Set the x-scale to be the default (between 0.0 and 1.0).
         */
        public static void setXscale() { setXscale(DEFAULT_XMIN, DEFAULT_XMAX); }
    
        /**
         * Set the y-scale to be the default (between 0.0 and 1.0).
         */
        public static void setYscale() { setYscale(DEFAULT_YMIN, DEFAULT_YMAX); }
    
        /**
         * Set the x-scale (a 10% border is added to the values)
         * @param min the minimum value of the x-scale
         * @param max the maximum value of the x-scale
         */
        public static void setXscale(double min, double max) {
            double size = max - min;
            synchronized (mouseLock) {
                xmin = min - BORDER * size;
                xmax = max + BORDER * size;
            }
        }
    
        /**
         * Set the y-scale (a 10% border is added to the values).
         * @param min the minimum value of the y-scale
         * @param max the maximum value of the y-scale
         */
        public static void setYscale(double min, double max) {
            double size = max - min;
            synchronized (mouseLock) {
                ymin = min - BORDER * size;
                ymax = max + BORDER * size;
            }
        }
    
        /**
         * Set the x-scale and y-scale (a 10% border is added to the values)
         * @param min the minimum value of the x- and y-scales
         * @param max the maximum value of the x- and y-scales
         */
        public static void setScale(double min, double max) {
            double size = max - min;
            synchronized (mouseLock) {
                xmin = min - BORDER * size;
                xmax = max + BORDER * size;
                ymin = min - BORDER * size;
                ymax = max + BORDER * size;
            }
        }
    
        // helper functions that scale from user coordinates to screen coordinates and back
        private static double  scaleX(double x) { return width  * (x - xmin) / (xmax - xmin); }
        private static double  scaleY(double y) { return height * (ymax - y) / (ymax - ymin); }
        private static double factorX(double w) { return w * width  / Math.abs(xmax - xmin);  }
        private static double factorY(double h) { return h * height / Math.abs(ymax - ymin);  }
        private static double   userX(double x) { return xmin + x * (xmax - xmin) / width;    }
        private static double   userY(double y) { return ymax - y * (ymax - ymin) / height;   }
    
    
        /**
         * Clear the screen to the default color (white).
         */
        public static void clear() { clear(DEFAULT_CLEAR_COLOR); }
        /**
         * Clear the screen to the given color.
         * @param color the Color to make the background
         */
        public static void clear(Color color) {
            offscreen.setColor(color);
            offscreen.fillRect(0, 0, width, height);
            offscreen.setColor(penColor);
            draw();
        }
    
        /**
         * Get the current pen radius.
         */
        public static double getPenRadius() { return penRadius; }
    
        /**
         * Set the pen size to the default (.002).
         */
        public static void setPenRadius() { setPenRadius(DEFAULT_PEN_RADIUS); }
        /**
         * Set the radius of the pen to the given size.
         * @param r the radius of the pen
         * @throws IllegalArgumentException if r is negative
         */
        public static void setPenRadius(double r) {
            if (r < 0) throw new IllegalArgumentException("pen radius must be nonnegative");
            penRadius = r;
            float scaledPenRadius = (float) (r * DEFAULT_SIZE);
            BasicStroke stroke = new BasicStroke(scaledPenRadius, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
            // BasicStroke stroke = new BasicStroke(scaledPenRadius);
            offscreen.setStroke(stroke);
        }
    
        /**
         * Get the current pen color.
         */
        public static Color getPenColor() { return penColor; }
    
        /**
         * Set the pen color to the default color (black).
         */
        public static void setPenColor() { setPenColor(DEFAULT_PEN_COLOR); }
    
        /**
         * Set the pen color to the given color. The available pen colors are
         * BLACK, BLUE, CYAN, DARK_GRAY, GRAY, GREEN, LIGHT_GRAY, MAGENTA,
         * ORANGE, PINK, RED, WHITE, and YELLOW.
         * @param color the Color to make the pen
         */
        public static void setPenColor(Color color) {
            penColor = color;
            offscreen.setColor(penColor);
        }
    
        /**
         * Set the pen color to the given RGB color.
         * @param red the amount of red (between 0 and 255)
         * @param green the amount of green (between 0 and 255)
         * @param blue the amount of blue (between 0 and 255)
         * @throws IllegalArgumentException if the amount of red, green, or blue are outside prescribed range
         */
        public static void setPenColor(int red, int green, int blue) {
            if (red   < 0 || red   >= 256) throw new IllegalArgumentException("amount of red must be between 0 and 255");
            if (green < 0 || green >= 256) throw new IllegalArgumentException("amount of red must be between 0 and 255");
            if (blue  < 0 || blue  >= 256) throw new IllegalArgumentException("amount of red must be between 0 and 255");
            setPenColor(new Color(red, green, blue));
        }
    
        /**
         * Get the current font.
         */
        public static Font getFont() { return font; }
    
        /**
         * Set the font to the default font (sans serif, 16 point).
         */
        public static void setFont() { setFont(DEFAULT_FONT); }
    
        /**
         * Set the font to the given value.
         * @param f the font to make text
         */
        public static void setFont(Font f) { font = f; }
  4. #3
  5. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Nov 2013
    Posts
    4
    Rep Power
    0
    Code:
     
       /*************************************************************************
        *  Drawing geometric shapes.
        *************************************************************************/
    
        /**
         * Draw a line from (x0, y0) to (x1, y1).
         * @param x0 the x-coordinate of the starting point
         * @param y0 the y-coordinate of the starting point
         * @param x1 the x-coordinate of the destination point
         * @param y1 the y-coordinate of the destination point
         */
        public static void line(double x0, double y0, double x1, double y1) {
            offscreen.draw(new Line2D.Double(scaleX(x0), scaleY(y0), scaleX(x1), scaleY(y1)));
            draw();
        }
    
        /**
         * Draw one pixel at (x, y).
         * @param x the x-coordinate of the pixel
         * @param y the y-coordinate of the pixel
         */
        private static void pixel(double x, double y) {
            offscreen.fillRect((int) Math.round(scaleX(x)), (int) Math.round(scaleY(y)), 1, 1);
        }
    
        /**
         * Draw a point at (x, y).
         * @param x the x-coordinate of the point
         * @param y the y-coordinate of the point
         */
        public static void point(double x, double y) {
            double xs = scaleX(x);
            double ys = scaleY(y);
            double r = penRadius;
            float scaledPenRadius = (float) (r * DEFAULT_SIZE);
    
            // double ws = factorX(2*r);
            // double hs = factorY(2*r);
            // if (ws <= 1 && hs <= 1) pixel(x, y);
            if (scaledPenRadius <= 1) pixel(x, y);
            else offscreen.fill(new Ellipse2D.Double(xs - scaledPenRadius/2, ys - scaledPenRadius/2,
                                                     scaledPenRadius, scaledPenRadius));
            draw();
        }
    
        /**
         * Draw a circle of radius r, centered on (x, y).
         * @param x the x-coordinate of the center of the circle
         * @param y the y-coordinate of the center of the circle
         * @param r the radius of the circle
         * @throws IllegalArgumentException if the radius of the circle is negative
         */
        public static void circle(double x, double y, double r) {
            if (r < 0) throw new IllegalArgumentException("circle radius must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*r);
            double hs = factorY(2*r);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
        /**
         * Draw filled circle of radius r, centered on (x, y).
         * @param x the x-coordinate of the center of the circle
         * @param y the y-coordinate of the center of the circle
         * @param r the radius of the circle
         * @throws IllegalArgumentException if the radius of the circle is negative
         */
        public static void filledCircle(double x, double y, double r) {
            if (r < 0) throw new IllegalArgumentException("circle radius must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*r);
            double hs = factorY(2*r);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.fill(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
    
        /**
         * Draw an ellipse with given semimajor and semiminor axes, centered on (x, y).
         * @param x the x-coordinate of the center of the ellipse
         * @param y the y-coordinate of the center of the ellipse
         * @param semiMajorAxis is the semimajor axis of the ellipse
         * @param semiMinorAxis is the semiminor axis of the ellipse
         * @throws IllegalArgumentException if either of the axes are negative
         */
        public static void ellipse(double x, double y, double semiMajorAxis, double semiMinorAxis) {
            if (semiMajorAxis < 0) throw new IllegalArgumentException("ellipse semimajor axis must be nonnegative");
            if (semiMinorAxis < 0) throw new IllegalArgumentException("ellipse semiminor axis must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*semiMajorAxis);
            double hs = factorY(2*semiMinorAxis);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.draw(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
        /**
         * Draw an ellipse with given semimajor and semiminor axes, centered on (x, y).
         * @param x the x-coordinate of the center of the ellipse
         * @param y the y-coordinate of the center of the ellipse
         * @param semiMajorAxis is the semimajor axis of the ellipse
         * @param semiMinorAxis is the semiminor axis of the ellipse
         * @throws IllegalArgumentException if either of the axes are negative
         */
        public static void filledEllipse(double x, double y, double semiMajorAxis, double semiMinorAxis) {
            if (semiMajorAxis < 0) throw new IllegalArgumentException("ellipse semimajor axis must be nonnegative");
            if (semiMinorAxis < 0) throw new IllegalArgumentException("ellipse semiminor axis must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*semiMajorAxis);
            double hs = factorY(2*semiMinorAxis);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.fill(new Ellipse2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
    
        /**
         * Draw an arc of radius r, centered on (x, y), from angle1 to angle2 (in degrees).
         * @param x the x-coordinate of the center of the circle
         * @param y the y-coordinate of the center of the circle
         * @param r the radius of the circle
         * @param angle1 the starting angle. 0 would mean an arc beginning at 3 o'clock.
         * @param angle2 the angle at the end of the arc. For example, if
         *        you want a 90 degree arc, then angle2 should be angle1 + 90.
         * @throws IllegalArgumentException if the radius of the circle is negative
         */
        public static void arc(double x, double y, double r, double angle1, double angle2) {
            if (r < 0) throw new IllegalArgumentException("arc radius must be nonnegative");
            while (angle2 < angle1) angle2 += 360;
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*r);
            double hs = factorY(2*r);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.draw(new Arc2D.Double(xs - ws/2, ys - hs/2, ws, hs, angle1, angle2 - angle1, Arc2D.OPEN));
            draw();
        }
    
        /**
         * Draw a square of side length 2r, centered on (x, y).
         * @param x the x-coordinate of the center of the square
         * @param y the y-coordinate of the center of the square
         * @param r radius is half the length of any side of the square
         * @throws IllegalArgumentException if r is negative
         */
        public static void square(double x, double y, double r) {
            if (r < 0) throw new IllegalArgumentException("square side length must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*r);
            double hs = factorY(2*r);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.draw(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
        /**
         * Draw a filled square of side length 2r, centered on (x, y).
         * @param x the x-coordinate of the center of the square
         * @param y the y-coordinate of the center of the square
         * @param r radius is half the length of any side of the square
         * @throws IllegalArgumentException if r is negative
         */
        public static void filledSquare(double x, double y, double r) {
            if (r < 0) throw new IllegalArgumentException("square side length must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*r);
            double hs = factorY(2*r);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.fill(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
    
        /**
         * Draw a rectangle of given half width and half height, centered on (x, y).
         * @param x the x-coordinate of the center of the rectangle
         * @param y the y-coordinate of the center of the rectangle
         * @param halfWidth is half the width of the rectangle
         * @param halfHeight is half the height of the rectangle
         * @throws IllegalArgumentException if halfWidth or halfHeight is negative
         */
        public static void rectangle(double x, double y, double halfWidth, double halfHeight) {
            if (halfWidth  < 0) throw new IllegalArgumentException("half width must be nonnegative");
            if (halfHeight < 0) throw new IllegalArgumentException("half height must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*halfWidth);
            double hs = factorY(2*halfHeight);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.draw(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
        /**
         * Draw a filled rectangle of given half width and half height, centered on (x, y).
         * @param x the x-coordinate of the center of the rectangle
         * @param y the y-coordinate of the center of the rectangle
         * @param halfWidth is half the width of the rectangle
         * @param halfHeight is half the height of the rectangle
         * @throws IllegalArgumentException if halfWidth or halfHeight is negative
         */
        public static void filledRectangle(double x, double y, double halfWidth, double halfHeight) {
            if (halfWidth  < 0) throw new IllegalArgumentException("half width must be nonnegative");
            if (halfHeight < 0) throw new IllegalArgumentException("half height must be nonnegative");
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(2*halfWidth);
            double hs = factorY(2*halfHeight);
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else offscreen.fill(new Rectangle2D.Double(xs - ws/2, ys - hs/2, ws, hs));
            draw();
        }
    
    
        /**
         * Draw a polygon with the given (x[i], y[i]) coordinates.
         * @param x an array of all the x-coordindates of the polygon
         * @param y an array of all the y-coordindates of the polygon
         */
        public static void polygon(double[] x, double[] y) {
            int N = x.length;
            GeneralPath path = new GeneralPath();
            path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));
            for (int i = 0; i < N; i++)
                path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
            path.closePath();
            offscreen.draw(path);
            draw();
        }
    
        /**
         * Draw a filled polygon with the given (x[i], y[i]) coordinates.
         * @param x an array of all the x-coordindates of the polygon
         * @param y an array of all the y-coordindates of the polygon
         */
        public static void filledPolygon(double[] x, double[] y) {
            int N = x.length;
            GeneralPath path = new GeneralPath();
            path.moveTo((float) scaleX(x[0]), (float) scaleY(y[0]));
            for (int i = 0; i < N; i++)
                path.lineTo((float) scaleX(x[i]), (float) scaleY(y[i]));
            path.closePath();
            offscreen.fill(path);
            draw();
        }
    
    
    
       /*************************************************************************
        *  Drawing images.
        *************************************************************************/
    
        // get an image from the given filename
        private static Image getImage(String filename) {
    
            // to read from file
            ImageIcon icon = new ImageIcon(filename);
    
            // try to read from URL
            if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {
                try {
                    URL url = new URL(filename);
                    icon = new ImageIcon(url);
                } catch (Exception e) { /* not a url */ }
            }
    
            // in case file is inside a .jar
            if ((icon == null) || (icon.getImageLoadStatus() != MediaTracker.COMPLETE)) {
                URL url = StdDraw.class.getResource(filename);
                if (url == null) throw new IllegalArgumentException("image " + filename + " not found");
                icon = new ImageIcon(url);
            }
    
            return icon.getImage();
        }
    
        /**
         * Draw picture (gif, jpg, or png) centered on (x, y).
         * @param x the center x-coordinate of the image
         * @param y the center y-coordinate of the image
         * @param s the name of the image/picture, e.g., "ball.gif"
         * @throws IllegalArgumentException if the image is corrupt
         */
        public static void picture(double x, double y, String s) {
            Image image = getImage(s);
            double xs = scaleX(x);
            double ys = scaleY(y);
            int ws = image.getWidth(null);
            int hs = image.getHeight(null);
            if (ws < 0 || hs < 0) throw new IllegalArgumentException("image " + s + " is corrupt");
    
            offscreen.drawImage(image, (int) Math.round(xs - ws/2.0), (int) Math.round(ys - hs/2.0), null);
            draw();
        }
    
        /**
         * Draw picture (gif, jpg, or png) centered on (x, y),
         * rotated given number of degrees
         * @param x the center x-coordinate of the image
         * @param y the center y-coordinate of the image
         * @param s the name of the image/picture, e.g., "ball.gif"
         * @param degrees is the number of degrees to rotate counterclockwise
         * @throws IllegalArgumentException if the image is corrupt
         */
        public static void picture(double x, double y, String s, double degrees) {
            Image image = getImage(s);
            double xs = scaleX(x);
            double ys = scaleY(y);
            int ws = image.getWidth(null);
            int hs = image.getHeight(null);
            if (ws < 0 || hs < 0) throw new IllegalArgumentException("image " + s + " is corrupt");
    
            offscreen.rotate(Math.toRadians(-degrees), xs, ys);
            offscreen.drawImage(image, (int) Math.round(xs - ws/2.0), (int) Math.round(ys - hs/2.0), null);
            offscreen.rotate(Math.toRadians(+degrees), xs, ys);
    
            draw();
        }
    
        /**
         * Draw picture (gif, jpg, or png) centered on (x, y), rescaled to w-by-h.
         * @param x the center x coordinate of the image
         * @param y the center y coordinate of the image
         * @param s the name of the image/picture, e.g., "ball.gif"
         * @param w the width of the image
         * @param h the height of the image
         * @throws IllegalArgumentException if the width height are negative
         * @throws IllegalArgumentException if the image is corrupt
         */
        public static void picture(double x, double y, String s, double w, double h) {
            Image image = getImage(s);
            double xs = scaleX(x);
            double ys = scaleY(y);
            if (w < 0) throw new IllegalArgumentException("width is negative: " + w);
            if (h < 0) throw new IllegalArgumentException("height is negative: " + h);
            double ws = factorX(w);
            double hs = factorY(h);
            if (ws < 0 || hs < 0) throw new IllegalArgumentException("image " + s + " is corrupt");
            if (ws <= 1 && hs <= 1) pixel(x, y);
            else {
                offscreen.drawImage(image, (int) Math.round(xs - ws/2.0),
                                           (int) Math.round(ys - hs/2.0),
                                           (int) Math.round(ws),
                                           (int) Math.round(hs), null);
            }
            draw();
        }
    
    
        /**
         * Draw picture (gif, jpg, or png) centered on (x, y), rotated
         * given number of degrees, rescaled to w-by-h.
         * @param x the center x-coordinate of the image
         * @param y the center y-coordinate of the image
         * @param s the name of the image/picture, e.g., "ball.gif"
         * @param w the width of the image
         * @param h the height of the image
         * @param degrees is the number of degrees to rotate counterclockwise
         * @throws IllegalArgumentException if the image is corrupt
         */
        public static void picture(double x, double y, String s, double w, double h, double degrees) {
            Image image = getImage(s);
            double xs = scaleX(x);
            double ys = scaleY(y);
            double ws = factorX(w);
            double hs = factorY(h);
            if (ws < 0 || hs < 0) throw new IllegalArgumentException("image " + s + " is corrupt");
            if (ws <= 1 && hs <= 1) pixel(x, y);
    
            offscreen.rotate(Math.toRadians(-degrees), xs, ys);
            offscreen.drawImage(image, (int) Math.round(xs - ws/2.0),
                                       (int) Math.round(ys - hs/2.0),
                                       (int) Math.round(ws),
                                       (int) Math.round(hs), null);
            offscreen.rotate(Math.toRadians(+degrees), xs, ys);
    
            draw();
        }
    
    
       /*************************************************************************
        *  Drawing text.
        *************************************************************************/
    
        /**
         * Write the given text string in the current font, centered on (x, y).
         * @param x the center x-coordinate of the text
         * @param y the center y-coordinate of the text
         * @param s the text
         */
        public static void text(double x, double y, String s) {
            offscreen.setFont(font);
            FontMetrics metrics = offscreen.getFontMetrics();
            double xs = scaleX(x);
            double ys = scaleY(y);
            int ws = metrics.stringWidth(s);
            int hs = metrics.getDescent();
            offscreen.drawString(s, (float) (xs - ws/2.0), (float) (ys + hs));
            draw();
        }
    
        /**
         * Write the given text string in the current font, centered on (x, y) and
         * rotated by the specified number of degrees  
         * @param x the center x-coordinate of the text
         * @param y the center y-coordinate of the text
         * @param s the text
         * @param degrees is the number of degrees to rotate counterclockwise
         */
        public static void text(double x, double y, String s, double degrees) {
            double xs = scaleX(x);
            double ys = scaleY(y);
            offscreen.rotate(Math.toRadians(-degrees), xs, ys);
            text(x, y, s);
            offscreen.rotate(Math.toRadians(+degrees), xs, ys);
        }
    
    
        /**
         * Write the given text string in the current font, left-aligned at (x, y).
         * @param x the x-coordinate of the text
         * @param y the y-coordinate of the text
         * @param s the text
         */
        public static void textLeft(double x, double y, String s) {
            offscreen.setFont(font);
            FontMetrics metrics = offscreen.getFontMetrics();
            double xs = scaleX(x);
            double ys = scaleY(y);
            int hs = metrics.getDescent();
            offscreen.drawString(s, (float) (xs), (float) (ys + hs));
            draw();
        }
    
        /**
         * Write the given text string in the current font, right-aligned at (x, y).
         * @param x the x-coordinate of the text
         * @param y the y-coordinate of the text
         * @param s the text
         */
        public static void textRight(double x, double y, String s) {
            offscreen.setFont(font);
            FontMetrics metrics = offscreen.getFontMetrics();
            double xs = scaleX(x);
            double ys = scaleY(y);
            int ws = metrics.stringWidth(s);
            int hs = metrics.getDescent();
            offscreen.drawString(s, (float) (xs - ws), (float) (ys + hs));
            draw();
        }
    
    
    
        /**
         * Display on screen, pause for t milliseconds, and turn on
         * <em>animation mode</em>: subsequent calls to
         * drawing methods such as <tt>line()</tt>, <tt>circle()</tt>, and <tt>square()</tt>
         * will not be displayed on screen until the next call to <tt>show()</tt>.
         * This is useful for producing animations (clear the screen, draw a bunch of shapes,
         * display on screen for a fixed amount of time, and repeat). It also speeds up
         * drawing a huge number of shapes (call <tt>show(0)</tt> to defer drawing
         * on screen, draw the shapes, and call <tt>show(0)</tt> to display them all
         * on screen at once).
         * @param t number of milliseconds
         */
        public static void show(int t) {
            defer = false;
            draw();
            try { Thread.sleep(t); }
            catch (InterruptedException e) { System.out.println("Error sleeping"); }
            defer = true;
        }
    
        /**
         * Display on-screen and turn off animation mode:
         * subsequent calls to
         * drawing methods such as <tt>line()</tt>, <tt>circle()</tt>, and <tt>square()</tt>
         * will be displayed on screen when called. This is the default.
         */
        public static void show() {
            defer = false;
            draw();
        }
    
        // draw onscreen if defer is false
        private static void draw() {
            if (defer) return;
            onscreen.drawImage(offscreenImage, 0, 0, null);
            frame.repaint();
        }
    
    
       /*************************************************************************
        *  Save drawing to a file.
        *************************************************************************/
    
        /**
         * Save onscreen image to file - suffix must be png, jpg, or gif.
         * @param filename the name of the file with one of the required suffixes
         */
        public static void save(String filename) {
            File file = new File(filename);
            String suffix = filename.substring(filename.lastIndexOf('.') + 1);
    
            // png files
            if (suffix.toLowerCase().equals("png")) {
                try { ImageIO.write(onscreenImage, suffix, file); }
                catch (IOException e) { e.printStackTrace(); }
            }
    
            // need to change from ARGB to RGB for jpeg
            // reference: http://archives.java.sun.com/cgi-bin/wa?A2=ind0404&L=java2d-interest&D=0&P=2727
            else if (suffix.toLowerCase().equals("jpg")) {
                WritableRaster raster = onscreenImage.getRaster();
                WritableRaster newRaster;
                newRaster = raster.createWritableChild(0, 0, width, height, 0, 0, new int[] {0, 1, 2});
                DirectColorModel cm = (DirectColorModel) onscreenImage.getColorModel();
                DirectColorModel newCM = new DirectColorModel(cm.getPixelSize(),
                                                              cm.getRedMask(),
                                                              cm.getGreenMask(),
                                                              cm.getBlueMask());
                BufferedImage rgbBuffer = new BufferedImage(newCM, newRaster, false,  null);
                try { ImageIO.write(rgbBuffer, suffix, file); }
                catch (IOException e) { e.printStackTrace(); }
            }
    
            else {
                System.out.println("Invalid image file type: " + suffix);
            }
        }
    
    
        /**
         * This method cannot be called directly.
         */
        public void actionPerformed(ActionEvent e) {
            FileDialog chooser = new FileDialog(StdDraw.frame, "Use a .png or .jpg extension", FileDialog.SAVE);
            chooser.setVisible(true);
            String filename = chooser.getFile();
            if (filename != null) {
                StdDraw.save(chooser.getDirectory() + File.separator + chooser.getFile());
            }
        }
    
    
       /*************************************************************************
        *  Mouse interactions.
        *************************************************************************/
    
        /**
         * Is the mouse being pressed?
         * @return true or false
         */
        public static boolean mousePressed() {
            synchronized (mouseLock) {
                return mousePressed;
            }
        }
    
        /**
         * What is the x-coordinate of the mouse?
         * @return the value of the x-coordinate of the mouse
         */
        public static double mouseX() {
            synchronized (mouseLock) {
                return mouseX;
            }
        }
    
        /**
         * What is the y-coordinate of the mouse?
         * @return the value of the y-coordinate of the mouse
         */
        public static double mouseY() {
            synchronized (mouseLock) {
                return mouseY;
            }
        }
    
    
        /**
         * This method cannot be called directly.
         */
        public void mouseClicked(MouseEvent e) { }
    
        /**
         * This method cannot be called directly.
         */
        public void mouseEntered(MouseEvent e) { }
    
        /**
         * This method cannot be called directly.
         */
        public void mouseExited(MouseEvent e) { }
    
        /**
         * This method cannot be called directly.
         */
        public void mousePressed(MouseEvent e) {
            synchronized (mouseLock) {
                mouseX = StdDraw.userX(e.getX());
                mouseY = StdDraw.userY(e.getY());
                mousePressed = true;
            }
        }
    
        /**
         * This method cannot be called directly.
         */
        public void mouseReleased(MouseEvent e) {
            synchronized (mouseLock) {
                mousePressed = false;
            }
        }
    
        /**
         * This method cannot be called directly.
         */
        public void mouseDragged(MouseEvent e)  {
            synchronized (mouseLock) {
                mouseX = StdDraw.userX(e.getX());
                mouseY = StdDraw.userY(e.getY());
            }
        }
    
        /**
         * This method cannot be called directly.
         */
        public void mouseMoved(MouseEvent e) {
            synchronized (mouseLock) {
                mouseX = StdDraw.userX(e.getX());
                mouseY = StdDraw.userY(e.getY());
            }
        }
    
    
       /*************************************************************************
        *  Keyboard interactions.
        *************************************************************************/
    
        /**
         * Has the user typed a key?
         * @return true if the user has typed a key, false otherwise
         */
        public static boolean hasNextKeyTyped() {
            synchronized (keyLock) {
                return !keysTyped.isEmpty();
            }
        }
    
        /**
         * What is the next key that was typed by the user? This method returns
         * a Unicode character corresponding to the key typed (such as 'a' or 'A').
         * It cannot identify action keys (such as F1
         * and arrow keys) or modifier keys (such as control).
         * @return the next Unicode key typed
         */
        public static char nextKeyTyped() {
            synchronized (keyLock) {
                return keysTyped.removeLast();
            }
        }
    
        /**
         * Is the keycode currently being pressed? This method takes as an argument
         * the keycode (corresponding to a physical key). It can handle action keys
         * (such as F1 and arrow keys) and modifier keys (such as shift and control).
         * See <a href = "http://download.oracle.com/javase/6/docs/api/java/awt/event/KeyEvent.html">KeyEvent.java</a>
         * for a description of key codes.
         * @return true if keycode is currently being pressed, false otherwise
         */
        public static boolean isKeyPressed(int keycode) {
            synchronized (keyLock) {
                return keysDown.contains(keycode);
            }
        }
    
    
        /**
         * This method cannot be called directly.
         */
        public void keyTyped(KeyEvent e) {
            synchronized (keyLock) {
                keysTyped.addFirst(e.getKeyChar());
            }
        }
    
        /**
         * This method cannot be called directly.
         */
        public void keyPressed(KeyEvent e) {
            synchronized (keyLock) {
                keysDown.add(e.getKeyCode());
            }
        }
    
        /**
         * This method cannot be called directly.
         */
        public void keyReleased(KeyEvent e) {
            synchronized (keyLock) {
                keysDown.remove(e.getKeyCode());
            }
        }
    
    
    
    
        /**
         * Test client.
         */
        public static void main(String[] args) {
            StdDraw.square(.2, .8, .1);
            StdDraw.filledSquare(.8, .8, .2);
            StdDraw.circle(.8, .2, .2);
    
            StdDraw.setPenColor(StdDraw.BOOK_RED);
            StdDraw.setPenRadius(.02);
            StdDraw.arc(.8, .2, .1, 200, 45);
    
            // draw a blue diamond
            StdDraw.setPenRadius();
            StdDraw.setPenColor(StdDraw.BOOK_BLUE);
            double[] x = { .1, .2, .3, .2 };
            double[] y = { .2, .3, .2, .1 };
            StdDraw.filledPolygon(x, y);
    
            // text
            StdDraw.setPenColor(StdDraw.BLACK);
            StdDraw.text(0.2, 0.5, "black text");
            StdDraw.setPenColor(StdDraw.WHITE);
            StdDraw.text(0.8, 0.8, "white text");
        }
    
    }
  6. #4
  7. No Profile Picture
    Registered User
    Devshed Newbie (0 - 499 posts)

    Join Date
    Nov 2013
    Posts
    4
    Rep Power
    0
    can anyone help me?

IMN logo majestic logo threadwatch logo seochat tools logo