Recently I’ve been playing around quite a bit with Processing.org, and one of the things that I often want to do is add a bit of noise to variables that represent positions, sizes, colours, etc. Most of the Processing functions that actually draw something (like lines, ellipses, etc) take their arguments in the form of floats, but most floating number operations in Java/Groovy return BigDecimal data types so we have to use casts a lot. Also, there’s no concise way to get a floating random number in a certain range that can be either negative or positive, so in order to randomly nudge a number up or down we end up with something like:

myNoisyNumber  = (float) (myNumber - 10) + (random.nextFloat() * 20)

which is not exactly concise. If we want to call a Processing function that takes several such variables as arguments, then it gets worse:

// draw a slightly-random ellipse
ellipse(  
(float)(x-10)+(random.nextFloat()*20),  
(float)(y-10)+(random.nextFloat()*20),  
(float)(size-5)+(random.nextFloat()*10),  
(float)(size-5)+(random.nextFloat()*10)
)

Thinking about a Groovy solution to the problem I remembered reading about the meta-programming features that let us dynamically add methods to core Java classes at runtime. So here’s my solution – let’s modify the Integer, Float and BigDecimal classes to include an extra method, jiggle(), that will add or subtract a bit of random variation to the number and return it as a float. Here is the magic code, that must be called at runtime (the setup() method of a processing applet does the job very nicely):

Float.metaClass.jiggle = { def amount ->  
    double rand = random.nextFloat() * amount  
    if (random.nextBoolean()){  
        rand = rand * -1  
    }  
    return (Float) delegate + rand  
}

Integer.metaClass.jiggle = { def amount ->  
    double rand = random.nextFloat() * amount  
    if (random.nextBoolean()){  
        rand = rand * -1  
    }  
    return (Float) delegate + rand  
}

BigDecimal.metaClass.jiggle = { def amount ->  
    double rand = random.nextFloat() * amount  
    if (random.nextBoolean()){  
        rand = rand * -1  
    }  
    return (Float) delegate + rand  
}

The jiggle() method (actually it is a closure) itself is pretty straightforward. We take random number, scale it by the argument, invert it half the time, add it to the number, and cast the result to a Float before returning it.

Two things are of interest here; firstly, we need to have a Random object called random in the scope where this code is run (we could get round this by creating a new Random object inside the closure, but I find it easier for debugging to have a single Random object for the whole sketch, making it easy to reproduce). Secondly, when we want to refer to the object to which the closure belongs (i.e. the Integer, Float or BigDecimal) we use delegate.

Having run this little snippet, our little ellipse example becomes much more concise:

ellipse(x.jiggle(10),y.jiggle(10),size.jiggle(5),size.jiggle(5))

and since we have ensured that all our new methods return Floats, we can happily through any type of number we like into the mix and be sure that the jiggled number will come out OK. We can even make use of Groovy’s everything-is-an-object syntax to do cool stuff like:

ellipse(10.jiggle(5), 5.5.jiggle(20), 100.jiggle(3.1415), 0.7.jiggle(0.002))