【问题标题】:I'm trying to write a recursive java program to create the Serpinski triangle我正在尝试编写一个递归 java 程序来创建谢尔宾斯基三角形
【发布时间】:2014-12-03 04:24:29
【问题描述】:

我遇到的问题是输出 png 只在左下角显示递归,我不知道为什么。有人可以指点我正确的方向吗,对于凌乱的 cmets 感到抱歉。 谢谢。

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import javax.imageio.ImageIO;

public class Assignment12 {
static int WIDTH = 0;
static int HEIGHT = 0;
static ArrayList<Double> points = new ArrayList<Double>();

public static void main(String[] args) {
    if (args.length == 0) {
        WIDTH = 800;
        HEIGHT = 693;
    } else {
        Integer W = Integer.valueOf(args[0]);
        Integer H = Integer.valueOf(args[0]);
        WIDTH = W;
        HEIGHT = H;
    }
    // DONE //*********stuff to do ***********create the final ordered pairs
    // of the biggest triangle
    // done// *********stuff to do *********** set the values of the ordered
    // pairs
    // to the dimensions of the rectangle
    final double topX = WIDTH / 2;
    final double topY = 0;
    final double leftX = 0;
    final double leftY = HEIGHT - 1;
    final double rightX = WIDTH - 1;
    final double rightY = HEIGHT - 1;
    sierpinski(topX, topY, leftX, leftY, rightX, rightY);
    // ##############jeffs code#########
    // BufferedImage creates memory space for storing image data
    BufferedImage img = new BufferedImage(WIDTH, HEIGHT,
            BufferedImage.TYPE_INT_RGB);
    // Graphics2D provides a canvas on which to draw shapes, text, other
    // images
    Graphics2D g2d = img.createGraphics();
    // *********stuff to do *********** do the back ground stuffs
    // Clear background to white
    g2d.setColor(Color.white);
    g2d.fillRect(0, 0, WIDTH, HEIGHT);
    // start drawing lines in the correct color.
    // Red line from where to where?
    g2d.setColor(Color.red);
    for (int i = 0; i < points.size(); i = i + 4) {
        g2d.drawLine(points.get(i).intValue(),
                points.get(i + 1).intValue(), points.get(i + 2).intValue(),
                points.get(i + 3).intValue());
    }
    // g2d.drawLine(0, 0, WIDTH - 1, HEIGHT - 1);
    // done// *********stuff to do *********** initialize the recursive
    // function to
    // done// *********stuff to do *********** get rid of these oval things
    // there
    // just for reference,
    // Draw some random ovals
    // for (int i = 0; i < 100; i++) {
    // g2d.setColor(new Color((float) Math.random(),
    // (float) Math.random(), (float) Math.random()));
    // g2d.fillOval((int) (Math.random() * WIDTH),
    // (int) (Math.random() * HEIGHT), (int) (Math.random() * 50),
    // (int) (Math.random() * 50));
    // }
    // Finalize the canvas
    g2d.dispose();
    // Write the image out as a PNG-format file
    try {
        ImageIO.write(img, "png", new File("out.png"));
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// *********stuff to do *********** create the recursive function for the
// triangles
private static void sierpinski(double topX, double topY, double leftX,
        double leftY, double rightX, double rightY) {
    // base case area of the triangle reaches x
    // (Ax(By-Cy)+Bx(Cy-Ay)+Cx(Ay-By))/2
    if (((leftX * (topY - rightY)) + (topX * (rightY - leftY)) + (rightX * (leftY - topY)) / 2) > 10) {// <--
        // that 10 should be a static value or just pulled directly from
        // args
        // start recursive for all three respective points
        double leftMidX = (topX + leftX) / 2;
        double leftMidY = (topY + leftY) / 2;
        double rightMidX = (topX + rightX) / 2;
        double rightMidY = (topY + rightY) / 2;
        // ***these are just called topMid for convenience. they are the mid
        // point values to the bottom line of the triangle.
        double botMidX = (leftX + rightX) / 2;
        double botMidY = (leftY + rightY) / 2;
        // top ... top stays the same
        sierpinski(topX, topY, leftMidX, leftMidY, rightMidX, rightMidY);
        // left
        sierpinski(leftMidX, leftMidY, leftX, leftY, botMidX, botMidY);
        // right
        sierpinski(rightMidX, rightMidY, botMidX, botMidY, rightX, rightY);
    } else {
        points.add(topX);
        points.add(topY);
        points.add(rightX);
        points.add(rightY);
        points.add(topX);
        points.add(topY);
        points.add(leftX);
        points.add(leftY);
        points.add(leftX);
        points.add(leftY);
        points.add(rightX);
        points.add(rightY);
        // draw the lines
        // g2d.drawLine(topX, topY, rightX, rightY);// right
        // g2d.drawLine(topX, topY, leftX, leftY);// left
        // g2d.drawLine(leftX, leftY, rightX, rightY);// bot
    }
}

}

【问题讨论】:

    标签: java recursion bufferedimage graphics2d fractals


    【解决方案1】:

    要绘制谢尔宾斯基三角形,请正确计算点。下面的代码在这里演示了它。可以在@ github 找到更详细的示例。

    作为参考,您可以查看计算三角形点的不同方法(计算帕斯卡三角形并使用其中奇数值的位置作为谢尔宾斯基三角形的点)@ github

    import java.awt.Color;
    import java.awt.Graphics2D;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.IOException;
    import java.util.ArrayList;
    import javax.imageio.ImageIO;
    import java.util.List;
    
    public class Sierpinski
    { 
        public static int WIDTH  = 800;
        public static int HEIGHT = 693;
        public static List<Double> points = new ArrayList<>();
    
        public static void main(String[] args)
        {
            if (0 != args.length)
            {
                WIDTH  = Integer.valueOf(args[0]);
                HEIGHT = Integer.valueOf(args[0]);
            }
            // DONE //*********stuff to do ***********create the final ordered pairs
            // of the biggest triangle
            // done// *********stuff to do *********** set the values of the ordered
            // pairs
            // to the dimensions of the rectangle
            final double topX   = WIDTH / 2;
            final double topY   = 0;
            final double leftX  = 0;
            final double leftY  = HEIGHT - 1;
            final double rightX = WIDTH  - 1;
            final double rightY = HEIGHT - 1;
            sierpinski(topX, topY, leftX, leftY, rightX, rightY);
            // ##############jeffs code#########
            // BufferedImage creates memory space for storing image data
            BufferedImage img = new BufferedImage(WIDTH, HEIGHT,
                                                  BufferedImage.TYPE_INT_RGB);
            // Graphics2D provides a canvas on which to draw shapes, text, other
            // images
            Graphics2D g2d = img.createGraphics();
            // *********stuff to do *********** do the back ground stuffs
            // Clear background to white
            g2d.setColor(Color.white);
            g2d.fillRect(0, 0, WIDTH, HEIGHT);
            // start drawing lines in the correct color.
            // Red line from where to where?
            g2d.setColor(Color.red);
            for (int i = 0; i < points.size(); i = i + 4)
            {
                g2d.drawLine(
                              points.get(i).intValue(),
                              points.get(i + 1).intValue(), 
                              points.get(i + 2).intValue(),
                              points.get(i + 3).intValue());
            }
            // Finalize the canvas
            g2d.dispose();
            // Write the image out as a PNG-format file
            try
            {
                ImageIO.write(img, "png", new File("out.png"));
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    
        /**
         * Triangle base = (Ax(By-Cy)+Bx(Cy-Ay)+Cx(Ay-By))/2
         * @return base for the triangle
         */
        public static double base(
                                    double topX  , double topY  ,
                                    double leftX , double leftY , 
                                    double rightX, double rightY )
        {
            return (  (topX  * (rightY - leftY)) 
                    + (rightX* (leftY  - topY))
                    + (leftX * (topY   - rightY ))) / 2;
        }
        // *********stuff to do *********** create the recursive function for the
        // triangles
        private static void sierpinski(
                                        double topX  , double topY  ,
                                        double leftX , double leftY , 
                                        double rightX, double rightY )
        {
            if (10 < base(topX, topY, leftX, leftY, rightX, rightY))
            {// <--
                // that 10 should be a static value or just pulled directly from
                // args
                // start recursive for all three respective points
                /**
                 *
                double leftMidX  = (topX + leftX ) / 2;
                double leftMidY  = (topY + leftY ) / 2;
                double rightMidX = (topX + rightX) / 2;
                double rightMidY = (topY + rightY) / 2;
                 */
                double leftMidX  = leftX + (topX   - leftX) / 2;
                double leftMidY  = topY  + (leftY  - topY ) / 2;
                double rightMidX = topX  + (rightX - topX ) / 2;
                double rightMidY = leftMidY                  ;
                // ***these are just called topMid for convenience. they are the mid
                // point values to the bottom line of the triangle.
                double botMidX = topX  ;
                double botMidY = leftY ;
                /*
                double botMidX = (leftX + rightX) / 2;
                double botMidY = (leftY + rightY) / 2;
                */
                // top ... top stays the same
                sierpinski(topX, topY, leftMidX, leftMidY, rightMidX, rightMidY);
                // left
                sierpinski(leftMidX, leftMidY, leftX, leftY, botMidX, botMidY);
                // right
                sierpinski(rightMidX, rightMidY, botMidX, botMidY, rightX, rightY);
            }
            else
            {
                points.add(topX);
                points.add(topY);
                points.add(rightX);
                points.add(rightY);
                points.add(topX);
                points.add(topY);
                points.add(leftX);
                points.add(leftY);
                points.add(leftX);
                points.add(leftY);
                points.add(rightX);
                points.add(rightY);
            }
        }
    }
    

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2015-10-24
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      相关资源
      最近更新 更多