Java 检测线'；s交叉口

我试图解决这个问题：在屏幕上画随机线，然后在所有线的交点处创建点。我的解决方案是：我用小点来构建线条，而不是创建真正的线条。每个“行”都是一个名为Pointe的类的实例。我将每个线实例的所有坐标存储在它自己的数组中。为了检测交点，我编写了函数collide（）来比较每条线存储的坐标。如果距离这是一个简单的数学问题。每一条直线上有两个点，你可以用这两个点得到直线方程，如下所示 如果你有两条不同直线的方程，你可以找到它们相交的点，G（x）=F（x）

---

关于

我现在不可能在这里使用处理脚本。处理与Java非常相似，只需稍作更改，这样的脚本就可以作为Java小程序运行

然而，你的方法在很多方面都值得怀疑

draw

方法中的第一个调用实际上应该是

void draw()
{
    background(0xFFFFFF);
    ...
}

为了清除背景。如果你没有这样做，那么你看到的任何东西都与你实际拥有的“状态”无关

当前，您正在将点的坐标（移动后）存储在存储的

位置\u

数组中。但是这个数组的内容不用于绘制，而仅用于距离计算

最重要的是：这个动画应该运行多长时间？它运行的时间越长，您需要的内存就越多。您总是在存储新的点坐标

因此，最终，每个人都可以——在最好的情况下——猜测你想要实现什么。我猜大概是这样的，但考虑到我对处理的知识有限，而且我想与您最初发布的内容至少保持一点相似性，这仍然是执行得很差，可能应该以不同的方式解决

import processing.core.PApplet;

public class ScribblingTest extends PApplet
{
    class Pointe
    {
        int x;
        int y;
        int speedX;
        int speedY;
        float size = 2;
        int c = color(random(255), random(255), random(255));

        Pointe(int xPosition, int yPosition, int speed_X, int speed_Y)
        {
            x = xPosition;
            y = yPosition;
            speedX = (int)(random(speed_X));
            speedY = (int)(random(speed_Y));
        }

        Pointe(Pointe other)
        {
            x = other.x;
            y = other.y;
            speedX = other.speedX;
            speedY = other.speedY;
            c = other.c;
        }


        void move()
        {
            x = x + speedX;
            y = y + speedY;
            if (x > 600)
            {
                x = 0;
            }
            if (y > 600)
            {
                y = 0;
            }
            if (x < 0)
            {
                x = 600;
            }
            if (y < 0)
            {
                y = 600;
            }
        }

        void display()
        {
            noStroke();
            fill(c);
            ellipse(x, y, size, size);
        }

        int getX()
        {
            return x;
        }

        int getY()
        {
            return y;
        }

        boolean collide(int[] a)
        {
            for (int i = 1; i < a.length; i = i + 2)
            {
                int distance = (int)(dist(x, y, a[i - 1], a[i]));
                if (distance < 20)
                {
                    return true;
                }
            }
            return false;
        }
    }

    int number = 20;
    int maxSteps = 300;
    int currentStep = 0;
    Pointe[][] points = new Pointe[number][maxSteps];

    public void setup()
    {
        size(600, 600);
        background(255);
        for (int i = 0; i < number; i++)
        {
            points[i] = new Pointe[maxSteps];
            points[i][0] = new Pointe(
                (int)(random(600)), 
                (int)(random(600)), 
                (int)(random(-6, 6)), 
                (int)(random(-6, 6)));
        }
    }


    public void draw()
    {
        background(0xFFFFFF);

        int currentIndex = currentStep % maxSteps;
        int nextIndex = (currentStep + 1) % maxSteps;
        for (int i = 0; i < number; i++)
        {
            Pointe currentP = points[i][currentIndex];
            Pointe nextP = new Pointe(currentP);
            nextP.move();

            boolean collides = false;
            for (int j=0; j<number; j++)
            {
                if (i != j)
                {
                    for (int k=0; k<maxSteps; k++)
                    {
                        Pointe otherP = points[j][k];
                        if (otherP != null)
                        {
                            float d = dist(nextP.x, nextP.y, otherP.x, otherP.y);
                            if (d < 20)
                            {
                                collides = true;
                                break;
                            }
                        }
                    }
                    if (collides)
                    {
                        break;
                    }
                }
            }
            if (collides)
            {
                nextP.size = 10;
            }
            else
            {
                nextP.size = 2;
            }

            points[i][nextIndex] = nextP;
        }

        for (int i = 0; i < number; i++)
        {
            for (int j=0; j<maxSteps; j++)
            {
                Pointe p = points[i][j];
                if (p != null)
                {
                    p.display();
                }
            }
        }
        currentStep++;


    }

}

import processing.core.PApplet；
公共类ScribblingTest扩展了PApplet
{
类点
{
int x；
int-y；
int speedX；
国际快速；
浮点数=2；
int c=颜色（随机（255）、随机（255）、随机（255））；
点E（点X位置，点Y位置，点速度X，点速度Y）
{
x=x位置；
y=位置；
速度X=（int）（随机（速度X））；
速度=（int）（随机（速度Y））；
}
点（点其他）
{
x=其他。x；
y=其他。y；
speedX=其他。speedX；
speedY=other.speedY；
c=其他。c；
}
无效移动（）
{
x=x+speedX；
y=y+速度；
如果（x>600）
{
x=0；
}
如果（y>600）
{
y=0；
}
if（x<0）
{
x=600；
}
if（y<0）
{
y=600；
}
}
无效显示（）
{
仰泳（）；
填充（c）；
椭圆（x，y，大小，大小）；
}
int getX（）
{
返回x；
}
int getY（）
{
返回y；
}
布尔碰撞（int[]a）
{
对于（int i=1；i对于（int j=0；jj）你的问题是什么？“我的解决方案：我用小点来构造线，而不是创建真正的线”-这听起来并不是一个解决方案，而是一个新问题的来源。你这样做的具体原因是什么？澄清不应作为答案添加，而应添加评论或编辑原始问题。（在中再次提出同样的问题也不会有帮助）显然，这个问题或你的意图还不够清楚。嗨，马可，我使用点是因为我想在以后创作涂鸦（不仅仅是线条）。非常感谢你花时间帮我解决这个问题。实际上我现在没有java，所以我无法测试你的程序。但我不想清除背景，因为我想在屏幕上画点，就像你在白板上涂鸦而不擦除它一样。我会测试这个java小程序，让你知道。应该只有很少的modif将其转换回处理脚本所需的ICT（例如，
（int）
必须转换为
int
，实际上只是一些小东西）。我明白您不清除背景的意图，但例如，当您调整窗口大小时，您以前绘制的所有内容无论如何都将丢失。。。
import processing.core.PApplet;

public class ScribblingTest extends PApplet
{
    class Pointe
    {
        int x;
        int y;
        int speedX;
        int speedY;
        float size = 2;
        int c = color(random(255), random(255), random(255));

        Pointe(int xPosition, int yPosition, int speed_X, int speed_Y)
        {
            x = xPosition;
            y = yPosition;
            speedX = (int)(random(speed_X));
            speedY = (int)(random(speed_Y));
        }

        Pointe(Pointe other)
        {
            x = other.x;
            y = other.y;
            speedX = other.speedX;
            speedY = other.speedY;
            c = other.c;
        }


        void move()
        {
            x = x + speedX;
            y = y + speedY;
            if (x > 600)
            {
                x = 0;
            }
            if (y > 600)
            {
                y = 0;
            }
            if (x < 0)
            {
                x = 600;
            }
            if (y < 0)
            {
                y = 600;
            }
        }

        void display()
        {
            noStroke();
            fill(c);
            ellipse(x, y, size, size);
        }

        int getX()
        {
            return x;
        }

        int getY()
        {
            return y;
        }

        boolean collide(int[] a)
        {
            for (int i = 1; i < a.length; i = i + 2)
            {
                int distance = (int)(dist(x, y, a[i - 1], a[i]));
                if (distance < 20)
                {
                    return true;
                }
            }
            return false;
        }
    }

    int number = 20;
    int maxSteps = 300;
    int currentStep = 0;
    Pointe[][] points = new Pointe[number][maxSteps];

    public void setup()
    {
        size(600, 600);
        background(255);
        for (int i = 0; i < number; i++)
        {
            points[i] = new Pointe[maxSteps];
            points[i][0] = new Pointe(
                (int)(random(600)), 
                (int)(random(600)), 
                (int)(random(-6, 6)), 
                (int)(random(-6, 6)));
        }
    }


    public void draw()
    {
        background(0xFFFFFF);

        int currentIndex = currentStep % maxSteps;
        int nextIndex = (currentStep + 1) % maxSteps;
        for (int i = 0; i < number; i++)
        {
            Pointe currentP = points[i][currentIndex];
            Pointe nextP = new Pointe(currentP);
            nextP.move();

            boolean collides = false;
            for (int j=0; j<number; j++)
            {
                if (i != j)
                {
                    for (int k=0; k<maxSteps; k++)
                    {
                        Pointe otherP = points[j][k];
                        if (otherP != null)
                        {
                            float d = dist(nextP.x, nextP.y, otherP.x, otherP.y);
                            if (d < 20)
                            {
                                collides = true;
                                break;
                            }
                        }
                    }
                    if (collides)
                    {
                        break;
                    }
                }
            }
            if (collides)
            {
                nextP.size = 10;
            }
            else
            {
                nextP.size = 2;
            }

            points[i][nextIndex] = nextP;
        }

        for (int i = 0; i < number; i++)
        {
            for (int j=0; j<maxSteps; j++)
            {
                Pointe p = points[i][j];
                if (p != null)
                {
                    p.display();
                }
            }
        }
        currentStep++;


    }

}