C++ OpenGL如何随机绘制非重叠圆

我已经画了一些随机放置的圆，但是每次运行程序时我都想要不同数量的圆。所以问题是我如何在随机时间调用函数

我还需要他们有凹凸效果，但不能安排他们随机圆

最后，我需要圆不重叠，我该怎么做

下面是到目前为止我的部分代码

void circle(){
    double r=50;
    int dx, dy;
    dx=rand()%350;
    dy=rand()%250;
    glLineWidth(1);
    glEnable(GL_LINE_SMOOTH);
    glBegin(GL_LINES);
    double i=1.0;
    double j=0.0;
    for (double y=r; y>=-r; y=y-1) {
        i=i-0.01;
        j=j+0.01;
        //glColor3f(i, i, i);
        glColor3f(j, j, j);
        glVertex2f(-sqrt(r*r-y*y)+dx, y+dy);
        glVertex2f(sqrt(r*r-y*y)+dx, y+dy);
    }


    glEnd();

}

void display(void){

    glClear(GL_COLOR_BUFFER_BIT);
    srand((unsigned)time(0));
    circle();
    circle();
    circle();


    glEnd();
    glFlush();
}

---

如何在随机时间调用函数

这是一种方法：

if (rand() % someNumber == 0)
 callFunc();

我还需要他们有凹凸效果，但不能安排他们随机圆。 我不明白你的意思

最后，我需要圆不重叠，我该怎么做

首先，您需要在结构中创建圆，并将它们存储在集合中。假设您的结构如下所示：

struct Circle {
 float x, y, raduis;
}

std::vector<Circle> circles;

Circle c;
do {
 bool canExit = true;
 c.x = rand()*350;
 c.y = rand()*250;
 c.radius = 50;

 for (int i = 0; i < circles.size(); i++) {
  float dx = (circles[i].x - c.x);
  float dy = (circles[i].y - c.y);
  floar radii = circles[i].radius + c.radius;
  if (dx*dx + dy*dy < (radii*radii) ) {
   canExit = false;
   break;
  }
 }

while(canExit == false);

circles.push_back(c);

像这样的收藏：

struct Circle {
 float x, y, raduis;
}

std::vector<Circle> circles;

Circle c;
do {
 bool canExit = true;
 c.x = rand()*350;
 c.y = rand()*250;
 c.radius = 50;

 for (int i = 0; i < circles.size(); i++) {
  float dx = (circles[i].x - c.x);
  float dy = (circles[i].y - c.y);
  floar radii = circles[i].radius + c.radius;
  if (dx*dx + dy*dy < (radii*radii) ) {
   canExit = false;
   break;
  }
 }

while(canExit == false);

circles.push_back(c);

std:：向量圆；

然后，创建可能如下所示：

struct Circle {
 float x, y, raduis;
}

std::vector<Circle> circles;

Circle c;
do {
 bool canExit = true;
 c.x = rand()*350;
 c.y = rand()*250;
 c.radius = 50;

 for (int i = 0; i < circles.size(); i++) {
  float dx = (circles[i].x - c.x);
  float dy = (circles[i].y - c.y);
  floar radii = circles[i].radius + c.radius;
  if (dx*dx + dy*dy < (radii*radii) ) {
   canExit = false;
   break;
  }
 }

while(canExit == false);

circles.push_back(c);

圈c；
做{
bool canExit=true；
c、 x=rand（）*350；
c、 y=rand（）*250；
c、 半径=50；
对于（int i=0；i

---

当然，这是唯一可能的方法，希望它能为您工作，祝您好运。

我如何在随机时间调用函数

这是一种方法：

if (rand() % someNumber == 0)
 callFunc();

我还需要他们有凹凸效果，但不能安排他们随机圆。 我不明白你的意思

最后，我需要圆不重叠，我该怎么做

首先，您需要在结构中创建圆，并将它们存储在集合中。假设您使用这样的结构：

struct Circle {
 float x, y, raduis;
}

std::vector<Circle> circles;

Circle c;
do {
 bool canExit = true;
 c.x = rand()*350;
 c.y = rand()*250;
 c.radius = 50;

 for (int i = 0; i < circles.size(); i++) {
  float dx = (circles[i].x - c.x);
  float dy = (circles[i].y - c.y);
  floar radii = circles[i].radius + c.radius;
  if (dx*dx + dy*dy < (radii*radii) ) {
   canExit = false;
   break;
  }
 }

while(canExit == false);

circles.push_back(c);

像这样的收藏：

struct Circle {
 float x, y, raduis;
}

std::vector<Circle> circles;

Circle c;
do {
 bool canExit = true;
 c.x = rand()*350;
 c.y = rand()*250;
 c.radius = 50;

 for (int i = 0; i < circles.size(); i++) {
  float dx = (circles[i].x - c.x);
  float dy = (circles[i].y - c.y);
  floar radii = circles[i].radius + c.radius;
  if (dx*dx + dy*dy < (radii*radii) ) {
   canExit = false;
   break;
  }
 }

while(canExit == false);

circles.push_back(c);

std:：向量圆；

然后，创建可能如下所示：

struct Circle {
 float x, y, raduis;
}

std::vector<Circle> circles;

Circle c;
do {
 bool canExit = true;
 c.x = rand()*350;
 c.y = rand()*250;
 c.radius = 50;

 for (int i = 0; i < circles.size(); i++) {
  float dx = (circles[i].x - c.x);
  float dy = (circles[i].y - c.y);
  floar radii = circles[i].radius + c.radius;
  if (dx*dx + dy*dy < (radii*radii) ) {
   canExit = false;
   break;
  }
 }

while(canExit == false);

circles.push_back(c);

圈c；
做{
bool canExit=true；
c、 x=rand（）*350；
c、 y=rand（）*250；
c、 半径=50；
对于（int i=0；i

当然，这是唯一可能的方法，希望它对你有用，祝你好运。

简单的方法 选择一个随机数并迭代就足够了。这会导致圆重叠

int min_circles = 10;
int max_circles = 100;

int amount = min_circles + rand()%(max_circles-min_circles+1);

for (int i = 0; i < amount; i++) 
  circle();

int min_圆圈=10；
int max_圆=100；
int amount=min\u circles+rand（）%（max\u circles-min\u circles+1）；
对于（int i=0；i

非重叠 这不是一件小事，也是一个有趣的研究课题。你可以有几种方法来解决这个问题，例如：

天真的一代 存储所有以前添加的圆位置，如果您尝试添加新的圆位置，只需检查上一个位置是否重叠。如果重叠，请选择另一个位置。如果连续多次失败，请停止

缓和 你也可以考虑把所有的圆圈当作一个点与弹簧相连的系统，反复迭代几次，这样弹簧就会互相排斥，从而符合不重叠的规则。

泊松圆盘抽样 您可以在internet上阅读有关实施泊松圆盘采样的内容。该算法生成平面上点的均匀随机分布，使它们彼此保持一定距离。然后仅使用这些点作为圆心。

简单方法 选择一个随机数并迭代就足够了。这会导致圆重叠

int min_circles = 10;
int max_circles = 100;

int amount = min_circles + rand()%(max_circles-min_circles+1);

for (int i = 0; i < amount; i++) 
  circle();

int min_圆圈=10；
int max_圆=100；
int amount=min\u circles+rand（）%（max\u circles-min\u circles+1）；
对于（int i=0；i

非重叠 这不是一件小事，也是一个有趣的研究课题。你可以有几种方法来解决这个问题，例如：

天真的一代 存储所有以前添加的圆位置，如果您尝试添加新的圆位置，只需检查上一个位置是否重叠。如果重叠，请选择另一个位置。如果连续多次失败，请停止

缓和 你也可以考虑把所有的圆圈当作一个点与弹簧相连的系统，反复迭代几次，这样弹簧就会互相排斥，从而符合不重叠的规则。

泊松圆盘抽样 你可以在互联网上阅读有关实施泊松圆盘采样的内容。该算法在平面上生成点的均匀随机分布，使它们彼此保持一定距离。然后仅使用这些点作为圆心