New results

We submitted a paper to EGSR (Eurographics Symposium on Rendering), and still waiting to see if the paper is accepted or not.


In the mean time, here's a little result. We used a Perlin sum, to sum up the first four images, to create the last one. The output is very interesting.


Here's the octaves:

Here's the output (also used as the new backgroud for this blog):

Note that each octave is different, which is different to Perlin noises. But if we wanted, we could have used the exact approach described by Perlin.


In future post, I'll give more detail about the method used to create these textures. All images are tileable. Eventually, a GPU version of this framework should be implemented. Either as a fragment shader or on CUDA/OpenCL.

Shader Toy

I know it's been a while since I posted something, and I will post some new results soon.


If you're interested to play with the fragment shader in WebGL, here's a wonderful link: Shader Toy.


Plus, the Khronos Group is working on to define a JavaScript binding to the Khronos OpenCL with WebCL, which is a very good thing.

Rocks, Marbles, Stones, ...

Still working on Hierarchy, and the outputs a getting better and better. Our next step is to create a mini-GUI, nothing fancy, but with enough functionality, to do some points placement by hand to see if we can reproduce some interesting patterns.

In the mean time, the other part of our research is about algorithms to place these points (and other related information) to create automatically some interesting textures. We are now looking to do some rocky textures, like marble. Mostly the marble tiles. We are particularly interested in the veins that you can observe on those tile that create such complex textures.

And we have a big challenge with those veins because our tool is mostly about cellular textures and veins are rarely in the form of cells. Our approach is to actually play with veins that are completely traverse the texture, this way, we can create cells and division on the plane.

But still, we managed to produce some interesting outputs:

Let me know what you think about those images!

Twitter account

Here's my twitter account: @widgg.

I usually tweet about funny stuffs like jokes and just thoughts that I have and want to share. Not necessary related to my research. But naturally, when there's a new post on this blog, I share the link.

It's actually the best way to contact me if you have any question or suggestion... or just want to talk about geek, research or any funny stuff.

Caustics

Here's another result. Here, we are trying to create some caustics, those reflection that you can see at the bottom of a pool caused by the sunlight and the surface of the water. We already have very nice outputs that can be achieved simply by distributing points and orientations. We used a poisson-disk sampling for the points.

Here's some of the outputs:

Like this, it doesn't seam very useful or look like caustics. But these kind of images can be used to add information on a surface. One trick is to use an image like this and a texture, for example the bottom of the pool, and when it's time to draw them, for each pixel, you compare the color on the caustic image and on the texture and you take the highest value for the red, green and blue. This way, you can alter a simple texture with and image like this.

Plus, the method that we use can be converted into an animation very easily. All you need to do is to move around the points and their orientations a little bit at each frame. This way, you have a fluid animation that will never loop on itself.

Actually, there's already something that you can use to see a caustic effect. My live-wallpaper, Weird Voronoi Pro, that I presented here a few months ago can produce an animation like this that won't loop. My favorite configuration (that I show here) creates a simple caustics with a little variation of intensity.

My clouds are so fluffy, you're gonna die!

Today I'm showing some cloud textures that I managed to create with a simple algorithm using a Poisson-disk sampling process to distribute some points. What is nice with this process to distribute point is that it's very portable and efficient. It can even be done in parallel on the GPU (with CUDA or OpenCL), this paper actually shows one way to do it: Efficient Maximal Poisson-disk Sampling.

The rendering process for now is done completely on the CPU because we are still in a phase where we need to be able to add, change or remove some part quite fast to adjust the renderer to our needs. It's a bit harder to do that on the GPU. But when we will be completely sure of the product that we want, we will adapt it to the GPU, probably with OpenCL for portability reasons.

So here some of these outputs:

There's still a little bit of work to do to remove some isolated points that we can see in some images. I might have some idea to solve this, just need to implement it. So, let me know what you think about those images.

Point Distribution

News from my research. Right now, we have a very good tool to create textures. But because we are not artists, we have to develop algorithms that use that tool to create textures automatically. To create textures with our tool, we have to place points and orientations on the plane, therefore, the main purpose of our algorithms is to place these points.

To create interesting textures, we have to find methods to place the points. One of the most popular method consists of selecting a minimal distance d and then, for each new potential point, test with the previous point if the minimal distance is at least d. If it is, the point is added to the set, otherwise, it's rejected. To determine how this process terminates, you can either put a maximal number of points or a maximal number of consecutive failure. For more information, you can take a look at Poisson Disk Sampling for more information and for the description of a more efficient algorithm to produce the point set.

But, while investigating those process, we noticed that our tool, with the points and orientations, can be used to determined the distance between two points. We use the orientation to create different distance functions and the minimal distance is considered according to these functions. So, we end up sometimes with pair of points closer than the minimal distance, but not according to the distance function.

Here's some point distribution with the orientation parallel to the z-axis. In this case, it creates a point distribution similar to the Poisson Disk Sampling described above.

But, if we start changing the orientations randomly, we have point distributions that are much less regular:

With this method, we can see that creating a random night sky is not that difficult.

It's also possible to manage point distribution with clusters. A basic method to do clusters is first to place clusters centers, just like distributing points (by choosing an orientation and a distance function), but without any minimal distance (but it's possible to have one). Then, for each point that you want to add to the point set, you first look for the closest center. Just like before, you test that new point with all the previous points already in the point set. If the point can be added, you assign a minimal distance to that point using the distance between that point and its center. The minimal distance can be the distance itself, but for better result, you can use the square or the square root of that distance.

Here's some result of cluster point distribution:

So now that we have methods to distribute points that also use our tool, we are now able to generate textures. We plan to first use these point distribution to create textures such as caustics, clouds and random abstract images.