Increasing Ellipses loop (Mandala)

[Chrisir]

do you want to avoid that the ellipses overlap?? Yes or no?

[humano]

Yes i do, I want a fluent growing but with a really full center and a really light outer part, more or less as here

With just one loop, if center is full, external part is not as light as I wanted, and if external part is light, center is not as full as I wanted, that is why I have drawn more loops, but then you see those unwanted cuts between them. So which type of function can grow like this?

[Chrisir]

@humano

with a really full center and a really light outer part

I did this above with sin.

Did you try?

[humano]

Do you mean this?

i was thinking more about this, but clean

[Chrisir]

more random?

size (2000, 1000);

float a=2.11;

ellipseMode(CENTER);
noFill();
strokeWeight(1);

int i=0;

for (int j=1; j<1500; j+=random(a, a+a*4) ) {
  ellipse(500, 500, j, j);
  a = sin(radians(i))*14;
  i+=1.0;
  point(i, a);
  println(a);
}
println("done");

[humano]

Not random, with a slow growing at the beginning and a fast one at the end, as you can see on the picture , but somethig continous

They could be three parts, the center, the middle and the outer part, but at least I need to avoid cuts between them, maybe lnowing values of every part

[Chrisir]

here you can press a key to go from
color to b/w

and space to restart

int i =0;
int i2 = 0;

// extension
PVector xM=new PVector(22, 22),
  yM=new PVector(22, 22);

ArrayList<Ell> list = new ArrayList();

boolean first=true;

// ----------------------------------------------------------------------------------------------

void setup() {
  size (1900, 999);
  //  frameRate(1);
  fill();
}

void draw() {
  background(111);
  ellipseMode(CENTER);

  if (!keyPressed) {
    for (int k=list.size()-1; k>=0; k-- ) {
      // fill();
      Ell el=list.get(k);
      el.display();
      //   noLoop();
    }
  } else {
    noFill();
    for (Ell el : list) {
      el.display();
    }
  }
}

// --------------------------------------------------------------------------

void keyPressed() {
  if (key==' ') {
    i =0;
    i2 = 0;
    list.clear();
    first=true;
    xM=new PVector(22, 22);
    yM=new PVector(22, 22);
    fill();
  }
}

void fill() {
  //for (int i=0; i<400; i=i+5) {
  ellipseAdd(random(width/2-10, width/2+10), random(240, 260),
    i+random(25), i+random(25),
    color(random(255), random(255), random(255)));
  i=i+5;
  // }
  i2++;

  if (i2 < 100)
    fill();
}

// --------------------------------------------------------------------------

void ellipseAdd(float x_, float y_,
  float radX_, float radY_,
  color col_) {
  //
  list.add(new Ell( x_, y_,
    radX_, radY_,
    col_));

  if (first) {
    first=false;
    xM.x= x_-radX_/2-1;
    xM.y= x_+radX_/2+1;

    yM.x= y_-radY_/2-1;
    yM.y= y_+radY_/2+1;
    list.remove(0);
  }
}

// ===========================================================================

class Ell {

  float x, y, radX, radY;

  color col;

  Ell(float x_, float y_,
    float radX_, float radY_,
    color col_) {
    //
    x=x_;
    y=y_;

    radX=radX_;
    radY=radY_;

    col=col_;

    if (x-radX/2-1>=xM.x) {
      while (x-radX/2-1>=xM.x)
        radX+=1;
    }
    if (x+radX/2+1 <= xM.y) {
      while (x+radX/2+1<=xM.y)
        radX+=1;
    }

    // ----

    if (y-radY/2-1>=yM.x) {
      while (y-radY/2-1>=yM.x)
        radY+=1;
    }
    if (y+radY/2+1 <= yM.y) {
      while (y+radY/2+1<=yM.y)
        radY+=1;
    }
    //if (radY<yM) {
    //  radY=yM+1;
    //}

    xM.x= x-radX/2-1;
    xM.y= x+radX/2+1;

    yM.x= y-radY/2-1;
    yM.y= y+radY/2+1;
  }

  void display() {
    fill(col);
    if (keyPressed)
      noFill();

    ellipse(x, y, radX, radY);
  }
}

[Chrisir]

@humano

a slow growing at the beginning and a fast one at the end, as you can see on the picture , but somethig continous

that’s exactly what my sin-Sketch does

[humano]

Well, your sketch is amazing! absolutely beatiful! Thank you so much for your help.
But actuallly I was thinking about something as this:

size (1000, 1000);
background(255,255,255);
ellipseMode(CENTER);
noFill();
strokeWeight(1);

for (int j=0,a=0; j<200; j+=1+a) {
  //stroke(255,0,0);
  ellipse(500,500, j, j);
  a=a+1;
  //println(a);
}

for (int k=210, b=20; k<400; k+=2+b){
  //stroke(0,0,255);
  ellipse(500,500, k,k);
  b=b+2;
  println(b);
} 

for (int l=424, c=36; l<600; l+=3+c){
//stroke(0,122,0);
ellipse(500,500, l,l);
c=c+3;
}


println("done");