calculating not perfect circles

Question

I want to create a genrator of "not perfect circles", circles that are a bit twisted and more random, but still look a bit like circle or maybe a cloud.

This is what I mean by not perfect circles:

I want to create a function that gets the maximum and minimum scale of the "not perfect circle" and gets all of its points. I know the formula of a circle: X^2+Y^2=R^2 but I cant think of a way to make it a bit more random. Anyone has any ideas?

Edit: trying to draw a perfect circle with points but it wont work:

    for (int step = 0; step < 300; ++step) {
         double t = step / 300 * 2 * Math.PI;
         c.drawPoint(300+(float)(33 * Math.cos(t)), 300+(float)(33 * Math.sin(t)), p);
    }

Edit 2:

    for (int step = 0; step < 20; ++step) {
          double t = step / 20.0 * 2 * Math.PI; 
          double imperfectR = 50.0+randInt(10, 50);
          //I do it here?
          points[step]=new PointF();
          points[step].set((300+(float)(imperfectR  * Math.cos(t))), 300+(float)(imperfectR  * Math.sin(t)));
          if(step==0){
                pp.moveTo(points[step].x, points[step].y);
          }
          else
                pp.quadTo(points[step-1].x, points[step-1].y,points[step].x, points[step].y);

    } 

Edit 3:

double t=0;
for (int i = 0; i < points.length/4; i++) {
        if(t==1){
            t=0;
        }
        t+=0.10;
        double imperfectR=0.5*((2*points[i+1].y)+(-points[i].y+points[i+2].y)*t+(2*points[i].y-5*points[i+1].y+4*points[i+2].y-points[i+3].y)*(t*t)+((-points[i].y+3*points[i+1].y-3*points[i+2].y+points[i+3].y)*(t*t*t)));
        newPoints[i].set((300+(float)(imperfectR  * Math.cos(t))), 300+(float)(imperfectR  * Math.sin(t)));
        t+=0.10;
        imperfectR=0.5*((2*points[i+1].y)+(-points[i].y+points[i+2].y)*t+(2*points[i].y-5*points[i+1].y+4*points[i+2].y-points[i+3].y)*(t*t)+((-points[i].y+3*points[i+1].y-3*points[i+2].y+points[i+3].y)*(t*t*t)));
        newPoints[i+1].set((300+(float)(imperfectR  * Math.cos(t))), 300+(float)(imperfectR  * Math.sin(t)));
        t+=0.10;
        imperfectR=0.5*((2*points[i+1].y)+(-points[i].y+points[i+2].y)*t+(2*points[i].y-5*points[i+1].y+4*points[i+2].y-points[i+3].y)*(t*t)+((-points[i].y+3*points[i+1].y-3*points[i+2].y+points[i+3].y)*(t*t*t)));
        newPoints[i+2].set((300+(float)(imperfectR  * Math.cos(t))), 300+(float)(imperfectR  * Math.sin(t)));
        t+=0.10;
        imperfectR=0.5*((2*points[i+1].y)+(-points[i].y+points[i+2].y)*t+(2*points[i].y-5*points[i+1].y+4*points[i+2].y-points[i+3].y)*(t*t)+((-points[i].y+3*points[i+1].y-3*points[i+2].y+points[i+3].y)*(t*t*t)));
        newPoints[i+3].set((300+(float)(imperfectR  * Math.cos(t))), 300+(float)(imperfectR  * Math.sin(t)));
        if(i==0){
            pp.moveTo(newPoints[i].x, newPoints[i].y);
        }
        pp.lineTo(newPoints[i].x, newPoints[i].y);
        pp.lineTo(newPoints[i+1].x, newPoints[i+1].y);
        pp.lineTo(newPoints[i+2].x, newPoints[i+2].y);
        pp.lineTo(newPoints[i+3].x, newPoints[i+3].y);

}
pp.close();

Answer 1

An alternative equation for a circle which is a bit easier to draw is one of its parametric forms:

x = R * cos(t);
y = R * sin(t);

where R is the nominal radius and t is a parameter between 0 and 2 * pi. So, you can draw points on the circumference a 'perfect' circle like this:

for (int step = 0; step < NSTEPS; ++step) {
  double t = step / (double) NSTEPS * 2 * pi;
  drawPoint(R * cos(t), R * sin(t));
}

You can make the circle 'imperfect' by adding on a random amount to the circle's radius, as suggested by @nikis:

for (int step = 0; step < NSTEPS; ++step) {
  double t = step / (double) NSTEPS * 2 * pi;
  double imperfectR = R + randn();  // Normally distributed random
  drawPoint(imperfectR * cos(t), imperfectR * sin(t));
}

However, this is probably going to give you very spiky shape, since there is nothing to make the radius at step and step + 1 similar. Without losing generality, you can rewrite the code above as:

for (int step = 0; step < NSTEPS; ++step) {
  double t = step / (double) NSTEPS * 2 * pi;
  double imperfectR = f(t);
  drawPoint(imperfectR * cos(t), imperfectR * sin(t));
}

Where f(t) is some function generating the radius for parameter t. Now, you can choose absolutely any function for t, but you probably want to choose something which is continuous over the circle, i.e. there is no point where f(t) changes value suddenly.

There are lots of choices here. The example that I suggested above was to suggest using a sum of cosine functions:

double f(double t) {
  double f = 0;
  for (int i = 0; i < N; ++i) {
    f += A[i] * cos(i * t + w[i]);
  }
  return f;
}

where A and w are randomly-selected values; A[0] should be set to R. The point here is that the cosine function has a period of 2 * pi, so f(alpha) = f(alpha + 2 * pi), satisfying the requirement of being continuous.

However, this is far from the only choice. You could maybe choose something like a sum of Gaussian kernels, which places 'bumps' centered at w[i] with a spread of sigma[i] on the circumference of the circle:

double f(double t) {
  double f = 0;
  for (int i = 0; i < N; ++i) {
    f += A[i] * exp(-Math.pow(t-w[i], 2) / sigma[i]);
  }
  return f;
}

(this doesn't quite work, it doesn't handle the wrap-around of t)

You will need to play around and see what function and what sorts of randomly-selected values give you the shape you are looking for.