Java：根据添加的行数均匀分布行的公式，分为 4 个象限

Question

问题： 嘿，我正在编写 Java 代码，以在尺寸为 400x400 的画布上创建一种由直线组成的抛物线星形。有人能帮我吗？这个图表应该是这样的，下面我将向您提供到目前为止我得到的代码：

我的Java代码： 导入 codedraw.CodeDraw; 导入codedraw.Palette；

公共类 TryOutTwo { 公共静态无效主（字符串[] args）{

    CodeDraw myDrawObj = new CodeDraw(400,  400);
    //add range?
    int numlinesQuadrant = 2;
    int xSpacing = 200 / (numlinesQuadrant);
    int ySpacing = 200 / (numlinesQuadrant);

    for (int i = 0; i < numlinesQuadrant; i++) {
        boolean isEven = (i % 2 == 0);
                int startX = 200 + (i * xSpacing);
                int startY = 200 + (i * ySpacing);
                int endX = 200 - (i * xSpacing);
                int endY = 200 + (i * ySpacing);
                myDrawObj.setColor(Palette.GREEN);
                if (isEven) {
                    myDrawObj.drawLine(200, startY, endX, 200);
                } else {
                    myDrawObj.drawLine(startX, 200, 200, endY);
                }
                int startX2 = 200 + (i * xSpacing);
                int startY2 = 200 + (i * ySpacing);
                int endX2 = 200 + (i * xSpacing);
                int endY2 = 200 + (i * ySpacing);
                myDrawObj.setColor(Palette.CYAN);
                if (isEven) {
                    myDrawObj.drawLine(200, startY2, endX2, 200);
                } else {
                    myDrawObj.drawLine(endX2,200,200,endY2);
                    }
                int startX3 = 200 - (i * xSpacing);
                int startY3 = 200 - (i * ySpacing);
                int endX3 = 200 - (i * xSpacing);
                int endY3 = 200 - (i * ySpacing);
                myDrawObj.setColor(Palette.ORANGE);
                if (isEven) {
                    myDrawObj.drawLine(200, startY3, endX3, 200);
                } else {
                    myDrawObj.drawLine(startX3, 200, 200, endY3);
                }
                int startX4 = 200 + (i * xSpacing);
                int startY4 = 200 - (i * ySpacing);
                int endX4 = 200 + (i * xSpacing);
                int endY4 = 200 - (i * ySpacing);
                myDrawObj.setColor(Palette.MAGENTA);
                if (isEven) {
                    myDrawObj.drawLine(200, startY4, endX4, 200);
                } else {
                    myDrawObj.drawLine(startX4, 200, 200, endY4);
                }
        }

    myDrawObj.setColor(Palette.BLACK);
    myDrawObj.setLineWidth(2);
    myDrawObj.drawLine(0, 200, 400, 200);
    myDrawObj.drawLine(200, 0, 200, 400);

    myDrawObj.show();
}

}

此外，这是我的任务描述（如果有帮助的话）： 这是我需要做的：

• 修改

  main

  方法，实现以下功能：
  • 生成与图中相似的图像。程序的每次运行都应该生成一个图像。
  • 图像大小应为 400×400 像素，点 P（x = 0，y = 0）位于左上角。使用

    CodeDraw myDrawObj = new CodeDraw(400, 400)

    创建绘图窗口。

• 附加说明：

  • 引入一个类型为

    numLinesQuadrant

    的变量

    int

    来确定每个象限的线数。每个轴上线条端点之间的间距应取决于此变量。无需从命令行输入。
  • 利用单个循环绘制整个图像。
  • 使用

    myDrawObj.setColor(Palette.GREEN)

    和类似方法将绘图颜色设置为绿色、青色、品红色或橙色。
  • 循环结束后，在图像中心绘制一条黑色水平线和垂直线，均为 2 像素粗 (

    myDrawObj.setLineWidth(2)

    )。

• 顺便说一句，我正在使用“CodeDraw”文档：https://krassnig.github.io/CodeDrawJavaDoc/v4.0.x/codedraw/CodeDraw.html

我似乎无法找出沿轴均匀分布每条线的起点和终点的公式。当我添加更多行时，它会变得混乱。每个象限中有两种类型的线。 4个坐标中的2个需要灵活计算，另外两个可以保持不变。至少我这么认为。为了让它们相应地移动并均匀分布，我需要一个可靠的公式，但由于某种原因我无法弄清楚。

Answer 1

这是一个

JavaFX

版本。

关键是按比例移动线条。

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
 
public class App extends Application {
 
    double viewWidth = 500.0;
    double viewHeight = 500.0;
    double minX = 0.0;
    double midX = viewWidth / 2.0;
    double maxX = viewWidth;
    double minY = 0;
    double midY = viewHeight / 2.0;
    double maxY = viewHeight;
    double loopMax = 20.0;
    
    
    public static void main(String[] args) {
        launch(args);
    }
 
    @Override
    public void start(Stage primaryStage) {
        primaryStage.setTitle("Drawing Operations Test");
        Group root = new Group();
        Canvas canvas = new Canvas(viewWidth, viewHeight);
        GraphicsContext gc = canvas.getGraphicsContext2D();
        
        root.getChildren().add(canvas);
        primaryStage.setScene(new Scene(root));
        primaryStage.show();
        
        drawAxisX(gc);
        drawAxisY(gc);
        double fraction = 0;
        for(int i = 1; i <= loopMax ; i++)
        {
            drawShape(gc, fraction);
            System.out.println(fraction);
            fraction = i / loopMax;
        }
        
    }

    private void drawAxisX(GraphicsContext gc) {
        gc.setFill(Color.BLACK);
        gc.setStroke(Color.BLACK);
        gc.setLineWidth(5);
        gc.strokeLine(minX, midY, maxX, midY);        
    }
    
     private void drawAxisY(GraphicsContext gc) {
        gc.setFill(Color.BLACK);
        gc.setStroke(Color.BLACK);
        gc.setLineWidth(5);
        gc.strokeLine(midX, minY, midX, maxY);        
    }
     
     private void drawShape(GraphicsContext gc,double fraction)
     {
        gc.setFill(Color.GREEN);
        gc.setStroke(Color.GREEN);
        gc.setLineWidth(1);
        gc.strokeLine(minX + (midX * fraction), midY, midX, minY + (midY * (1 - fraction))); //upper /
        
        
        gc.setFill(Color.ORANGE);
        gc.setStroke(Color.ORANGE);
        gc.strokeLine(minX + (midX * fraction), midY, midX, maxY - (midY * (1 - fraction)));
        
        gc.setFill(Color.VIOLET);
        gc.setStroke(Color.VIOLET);
        gc.strokeLine(maxX - (midX * fraction), midY, midX, maxY - (midY * (1 - fraction)));
        
        gc.setFill(Color.CYAN);
        gc.setStroke(Color.CYAN);
        gc.strokeLine(maxX - (midX * fraction), midY, midX, minY + (midY * (1 - fraction)));        
     }
}

输出