WIDGG'S RESEARCH

New results

2012-04-23T20:33:00.000-04:00

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

2012-04-18T16:46:00.001-04:00

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, ...

2011-11-08T20:07:00.000-05:00

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

2011-11-07T12:58:00.000-05:00

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

2011-11-06T21:23:00.001-05:00

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!

2011-11-04T18:34:00.000-04:00

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

2011-10-30T22:43:00.000-04:00

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.

Learn to code | Codecademy

2011-10-29T13:19:00.000-04:00

Today's post is about a website I planned to talk about, bu totally forgot! It's called Codecademy and it's actually a very nice tutorial to teach kids, from 7 to 77, how to handle basic principles in source code.

It shows how to code in Javascript. And in the last years, mostly with HTML5, Javascript is getting even more important. And there's a rule on the Internet about Javascript: If something can be done in Javascript, eventually, someone will do it. And it's actually true. Just take a look at Google Docs. Also, by choosing Javascript, you don't have to think about compilers or on which OS you are. You can jump directly in the fun part.

The tutorial starts by asking your name and you just have to write it as a string like "Widgg". Then, gradually, you are introduce to various concepts like variables, conditions, loops and so on. The only problem that I had with the tutorial is that the syntax in Javascript requires semicolons at the end of each statement, but that was not explicitly mentioned in the tutorial. Or I just did not find it.

I did that tutorial a while ago, so maybe they corrected it. But even with that small problem, it's actually a really good starts for anyone who want to start programming or are just curious.

Paper Review: Alan Turing and the Origins of Complexity

2011-10-13T22:40:00.000-04:00

It's the first time I'm doing a post like this one. I don't really know how to approach this paper review or even if it should be considered a paper review. So, first here's the basic information about that paper.

Abstract:

The 75th anniversary of Turing's seminal paper and his centennial year anniversary occur in 2011 and 2012, respectively. It is natural to review and assess Turing's contributions in diverse fields in the light of new developments that his thoughts has triggered in many scientific communities. Here, the main idea is to discuss how the work of Turing allows us to change our views on the foundations of Mathematics, much like quantum mechanics changed our conception of the world of Physics. Basic notions like computability and universality are discussed in a broad context, making special emphasis on how the notion of complexity can be given a precise meaning after Turing, i.e., not just qualitative but also quantitative. Turing's work is given some historical perspective with respect to some of his precursors, contemporaries and mathematicians who took up his ideas farther.

Author:

Dr. Miguel Angel Martín-Delgado

Link:

Alan Turing and the Origins of Complexity

I decided to talk about that paper because it's about the work of a great man, Alan Turing, without whom, the world would be so different, at so many levels that it's hard to understand the impact he had. As mention in the abstract, he gave us a better understanding of complicated Mathematical concepts. In WWII, he helped breaking the naval Enigma machine used by Nazis to communicate.

But the main reason that I decided to write a post about this paper is that it covers subjects that most computer scientists should be aware of. It doesn't matter if the proofs are not understood, but it's very important to get the foundation of computer science and to know what are the limitations of computers. Even if you already know this material, it's always good to read it again. Particularly if it's been a while.

First, Alan Turing introduce what he called the "a-machine" for automatic machine. That machine is now called a Turing machine. To know what a Turing machine is, take a look at this video:

It might be hard to understand, but a machine like this can reproduce everything a computer can do. Here, we're not talking about speed, but the capacity to compute the same result. The most important Turing machine is a Universal Turing machine, i.e. a machine that can simulate any other Turing machine. Such a machine requires two inputs: a program and input data. Then the machine follow the instruction of the program, according to the input data, and produce an output.

This is exactly like a computer. You have the hardware (the machine), when it starts, it loads an operating system (the program) and you start typing on your keyboard, moving the mouse, receiving data from an internet connection (the input data). And in exchange, you get outputs in the form of images shown on your screen, data sent to a server or a document printed (an output).

Turing also showed the limitation of his machine. For example, that machine would not be able to compute the square root of two because the computation would never stop. If the machine cannot stop, it's considered non-computable. But, if we put a limit to the computation such as a maximum number of decimals, then it's computable because the machine will know when it's done.

Then, if something can be computed, how hard is it to compute it ? How much time and how much space ? Time, so given an input of size N, how much steps a Turing machine will need to solve it. Space, how much place on the tape (see the video above) is needed. On a Turing machine, the tape is considered as "infinite" but in practice, computers don't have infinite space and it takes time to do any operations. The paper covers the common complexity classes and problems related to these, specially the well know P vs. NP.

The paper also talk about the famous Halting Problem, i.e. there's no way to find whether a computer will eventually halt. A proof of the Halting Problem is given in the paper by using Cantor's diagonal method. That method can be used to show that even if there's an infinite number of natural numbers N, the cardinality (the size) of the set of real numbers R is greater than the cardinality of N. A concept that is weird the first time you read about it (I remember how surprised I was when I saw a proof for that) but very important to understand the foundation of Mathematics.

Have fun reading this paper!

more smoke

2011-10-05T11:04:00.000-04:00

So, yesterday I presented some smoke textures that I created. I continued to work on it and after altering some values, I managed to create some new interesting smoke textures. These textures look cleaner than those made yesterday. I made sure that the background would be closer to black and it helps to see the curves made by the smoke.

Here's some of these outputs:

When the process would be easier to control, with well defined functions to distribute the points, I will be able to generate as much smoke textures as I want. Might put a package of a hundred of them on Renderosity.

smoke textures

2011-10-04T21:43:00.000-04:00

Back on creating textures. First, I finished the first version of that new renderer. Might still have some bug, but in general, it's done.

One of the objectives that we had with this new tool that we created was to create some smoke. A bit similar to this one:

The picture above is called Smoke Art, so creating images using smoke. This one is not generated by any computer. Other Smoke Art are listed there: http://www.bablotech.com/2008/12/14/20-amazing-smoke-art-pictures/, and some of them are really amazing.

With our new method, we try to reproduce such piece of art, but completely random. We don't try to recreate a scene or anything. Just create random smoke effects.

There's many ways to do such images, the most popular is probably with particles. You use thousands or millions of points and let them behave like smoke. But this approach is heavy to run and it's mostly for animation. For static images like ours, it's not very interesting to manage that amount of points to finally find the right image.

Our method still consists of placing points and some information of associated with points on the plane to partition it. We are still using the layers to create the effects and it works really well with smoke. So here's some of my favorite that I created today:

We still have some work to do to really control that new technique. And also some experimentation to be sure that the behavior is more stable. One thing that we might try is adding a bit of color to it instead of working in gray. But not drastic colors like red or green. Little variation from gray, but enough to see that there's more.

Please leave any comment or question that you have about these textures.

Changed my profil logo...

2011-09-30T14:57:00.000-04:00

... just for the fun of doing it.

I had an idea last night about a simple drawing:

But hey... it's very simple and it includes a bit my passion for mathematics without being that obvious... but I don't think it's very complicated to understand! And more important... it's better than just my nickname written in green :)

research news

2011-09-30T01:21:00.002-04:00

I don't have new stuff to show right now, but I've been busy in the last week. I'm currently implementing a more dynamic version of my renderer. CUDA is very nice, but when you need to add quickly new modules or do some rapid tweaks, it's not the best solution. So, for now the plan is to render to have a slower renderer that would be easier to change and adapt. When we're sure of the features that we really want to keep and we'll know the full limitation of our system, an implementation in CUDA would be possible.

One of the reason to change the renderer is that I needed some C++ features like virtual functions, which is very useful for designing rapidly a new system. I think there's some language that allows to create virtual function in CUDA or OpenCL by simply adding some hidden piece of code.

If it doesn't exist, here's how I'd do it:

First, in CUDA, there's no function pointers. But if we take a look at how polymorphism works, it's really just a way to disguise procedural code. Actually, the whole object oriented programming scheme is just a way to disguise procedural code by hiding some information to the programmer so (s)he doesn't have to worry about it. Just like many other languages do (Java is the most popular about that one because it hides a lot of security features like buffer overflows done during the execution to avoid major problems).

So, if we have:

class A
{
private:
int value;
public:
A(void);
virtual ~A(void);
virtual void test(T param1, U param2);
};

Then this piece of code is actually converted into something that look basically like this:

// prototypes
struct class_A;
void __class_A_constructor(struct class_A *this);
void __class_A_destructor(struct class_A *this);
void __class_A_test(struct class_A *this, T param1, U param2);
struct class_A_virtual_table
{
void (*class_A_destructor)(struct class_A *this);
void (*class_A_test)(struct class_A *this, T param1, U param2);
};

// create a single instance of the virtual table and assign the values for the function pointersstruct class_A_virtual_table class_A_virtual_table_only_instance_needed =
{
  __class_A_destructor,
  __class_A_test
};
struct class_A
{
class_A_virtual_table *VT;
int value;
};
void __class_A_constructor(struct class_A *this)
{
  this->value = 0; // or some other default value
  this->VT = &class_A_virtual_table_only_instance_needed;
}
void __class_A_destructor(struct class_A *this)
{
// stuff to destroy
}
void __class_A_test(struct class_A *this, T param1, U param2)
{
// stuff to test
}
// virtual functions
void virtual_class_A_destructor(struct class_A *this)
{
  this->VT.class_A_destructor(this);
}
void virtual_class_A_test(struct class_A*this, T param1, U param2)
{
  this->VT.class_A_test(this, param1, param2);
}

And then, with a subclass B, we have:

class B: public A
{
private:
double value;
public:
B(void);
~B(void);
void test(T param1, U param2); // version of test but for class B
void function_in_B(void);
};

int main(void)
{
B b;
A *a = &b;
a->test(1, 2); // let way that type T and U are integers...
b.function_in_B();
}

Then, all of this become:

struct class_B
{
struct class_A super;
double value;
};
// prototypes for class B
void __class_B_constructor(struct class_B *this);
void __class_B_destructor(struct class_B *this);
void __class_B_test(struct class_B *this, T param1, U param2);
void __class_B_function_in_B(struct class_B *this);
// virtual table for B, with the virtual functions for B
struct class_A_virtual_table class_B_virtual_table_only_instance_needed =
{
  __class_B_destructor,
  __class_B_test
};
void __class_B_constructor(struct class_B *this)
{
__class_B_constructor(&(this->super));
  this->VT = &class_B_virtual_table_only_instance_needed; // replace the virtual table
this->value = 0.0; // or some other default value
}
void __class_B_destructor(struct class_B *this)
{
// stuff to destroy in B
__class_A_destructor(&(this->super)); // then, destroy the stuff in the parent
}
void __class_B_test(struct class_B *this, T param1, U param2)
{
// stuff to test, but for B
}
void __class_B_function_in_B(struct class_B *this)
{
// whatever that function does!
}
int main(void)
{
struct class_B b;
  __class_B_constructor(&b);
struct class_A *a = &(b.super); // the address of the parent in struct class_B
  virtual_class_A_test(a, 1, 2);
   __class_B_function_in_B(&b);
  __class_B_destructor(&b);
}

So, as you can see, polymorphism is using function pointers to create the illusion that the right function is called each time.

But, without any function pointers, we need to recreate that illusion. So, one way that can be done in CUDA/OpenCL, is to add a unique ID for each class. And each instance of that class will have that ID assigned in the constructor. So:

enum CLASS_IDS { CLASS_A_ID, CLASS_B_ID, ..., CLASS_X_ID };
struct class_A
{
int ID;
int value;
};
void __class_A_constructor(struct class_A *this)
{
this->ID = CLASS_A_ID;
  this->value = 0; // or some other default value
}
struct class_B
{
struct class_A super;
double value;
};
void __class_B_constructor(struct class_B *this)
{
  __class_A_constructor(&(this->super)); // always call the parent constructor first!
this->ID = CLASS_B_ID; // overwrite the ID
  this->value = 0.0; // or some other default value
}

Finally, write the virtual functions like this:

void virtual_class_A_destructor(struct class_A *this)
{
switch(this->ID)
{
case CLASS_A_ID:
__class_A_destructor(this);
break;
case CLASS_B_ID:
__class_B_destructor((class_B*)this);
break;
// ...
case CLASS_X_ID:
__class_X_destructor((class_X*)this);
break;
};
}

So, with a switch statement, it's possible to replace the virtual table. So, a compiler that would be able to take C++ code and convert it in CUDA/OpenCL would be able to do polymorphism with that approach. It's much more slower than a function pointer, but the result of the computation would be the same.

I think that such compilers exist already, but I never used one of them. But it's probably using a method similar to the one above to emulate the virtual tables.

And for those of you who didn't know how polymorphism worked, now you have a better idea of the process the compiler has to do to convert classes and their virtual functions in machine bytecode. So, I hoped that post helps a bit for that. Otherwise, there's a couple of resources available on the web that would clearly describe that process.

If any of you know a (free if possible) compiler that convert basic C++ code in CUDA or OpenCL, but also has integrated some of the features of those languages like the synchronization between threads of the same bloc and atomic operations, I'd really like to see that and use it eventually. It must work on Linux!

first pattern

2011-08-25T13:48:00.000-04:00

So, yesterday I mentioned two steps that we need to work on to finish the hierarchy project. And one of them is to work on patterns or structures to show what is possible to do with that product.

Today, I managed to to a first structure, a flower. Very simple to do. Just needed some adjustment first, but I got that result in few minutes. So here it is:

Naturally, I just showed the final product. I had other images created before I managed to do the right effect that I wanted. I think that this is a nice preview of what that product can do.

Let me know what you think about that output!

Hierarchy textures

2011-08-24T15:00:00.000-04:00

So, it's been a while. I was so busy at SIGGRAPH that I never had the time to share anything.

In this post, I'm showing you some of the last textures I've been working on. These are build as a hierarchy. We use again our variation of the Voronoi diagram to create weird shapes. But this time, instead of using simply one level, we introduce many levels.

On the first level, again, the Voronoi cells are computed and once we know in which cell we are, if that cell has a sub-level, we can then continue the visit in the structure into that sub-level. Each level has can have a small or big influence on the final color of the pixel.

So, here's some outputs:

One of the first output made. It has two cells on the first level. One is the circle-like shape in the middle and then the rest. In the "rest", there's a sub level with a simple small division of the plane in two.

Exactly as the previous one, but here, there's a sub-level in the circle-like shape. As you can see, the fact that there's a new sub-level only affects the part where that sub-level is.

The actual first output that I got with the hierarchy.

In the next images, I start playing with colors inside the cells. Naturally, all of these images where made from random point distribution.

In these images, I simply played with the hierarchy. Each cell has a random chance to get a sub-level and so on. Until a maximal depth was reached. In some of them, I played also with the feature that at each level, you can influence the final color by accumulating a value.

Finally, there's two big step to do before we consider that project finished. First, we want to investigate various patterns. So, how can we do a particular shape for a cell. For this part, we don't need the hierarchy because we know it works. When we are able to control properly the patterns, we will be able to used them at various level.

Second, we want to be more dynamic for the color. Right now, each cell use a function f:[0;1]->[0;1] to control its value that will influence all the other levels. But those functions are a bit static. I can add more, but it will never be enough. So we turn to use something like the shaders in OpenGL. Literally, each cell could have its own function (coded in CUDA-C) and that function would be used to control the contribution of that cell and its sub-level to the final color of the pixel.

SIGGRAPH

2011-08-05T23:24:00.000-04:00

This week, I will be at SIGGRAPH in Vancouver. I will try to share some of the stuff I will see on the blog. I hope to be able to talk about the last stuffs in procedural texturing and rendering.

Twin Pictures DEMO

2011-08-04T12:46:00.000-04:00

I decided to put a demo on the market of Twin Pictures. In that free version, the only difference with the paid version is that you cannot change the pictures. But all the other effects are there.

Here's the link: https://market.android.com/details?id=com.blogspot.widgg_research.twin_demo

If you like it, you will definitely like the full version where you can change the images!

Twin Pictures video

2011-07-29T23:38:00.000-04:00

So here's a small video to show you Twin Pictures.

&lt;p&gt;&amp;lt;br /&amp;gt; &amp;lt;br /&amp;gt; Sorry about the bad quality and my voice, it's my first video... and I'm not the most eloquent speaker.&lt;/p&gt;

upgrades on Twin Pictures

2011-07-28T21:52:00.000-04:00

So today I published a new version of Twin Pictures. I added some interesting features.

First, for the second image, you can choose instead to use the first image in negative. So, just like the default settings with the Android logo, it creates a really great effect. You can really enjoy the dueling process for the two images with the negative option.

Here's an example with the Mortal Kombat Logo:

I also added new ways to split the screen for the images:

Random: the original method, no real structure, it's spinning around at various speed
Symmetry: this method splits the screen in two. So you see equally part of image 1 and image 2 at all time.
Asymmetry: this method can look symmetrical on certain point of view, but not on the part shared by the images. At some point, you will not see one of the image.
Symmetrical Yin Yang: this one is inspired by some pictures I showed in a previous post. The screen is split in two, but there's no axis of symmetry.
Asymmetrical Yin Yang: just like asymmetry above, it splits the screen, but not necessary equally and without an axis of symmetry.

It's also possible to set the brightness. The minimum is 50% and by default it's at 100%.

Next upgrade:

I'm looking at options for the part of the screen where the images intersect. For now, there's a very small change between the images. But it's enough to be a rough one (but it will be an option). So, i'm planning 5-6 options just to give more choice to the users with the visual aspect.

https://market.android.com/details?id=com.blogspot.widgg_research.twin

A new live-wallpaper

2011-07-26T11:28:00.001-04:00

Recently, I showed images about grouping points together to create a different kind of Voronoi diagram (see Merging Voronoi).

The case with two groups is very interesting because it splits the plane in two parts. I was first intrigued by what it would look like animated and then I imagined that if each group is associated with an image. It's possible to show parts of the first image where its group is visible and part of the second image where the second group is.

So I came up with a very simple live-wallpaper. All you need to do is select two images and let the animation do the rest. This is much more easier to use than the Weird Voronoi (Pro) with all the functions.

Here's some outputs:

(this one is the default, when you first start the live-wallpaper)

Here's the link and the QR code:

https://market.android.com/details?id=com.blogspot.widgg_research.twin

Weird Voronoi Pro (news and possible improvement)

2011-07-18T16:53:00.000-04:00

So first, after playing around with all the functions. I found my favorite configuration yet (but I might found a better one... who knows).

field	value
Select a ratio, R =	(d1*d2)/(d3^2)
x = f(R)	f(R) = tan(R*pi/4)
y = f(x)	f(R) = R(0.5[!] + 0.5)
z = f(y)	f(R) = R^2
c = f(z)	f(R) = R

And for the improvements, one option is to at least double the number of steps. But I will wait for some comments about this. As you can see, in the above configuration, I don't even need the last one.

Also, I'm still looking for more functions to offer a larger variety of transition in the [0;1] range. Particularly functions that might reach both limits more than once in the [0;1] of the input. This will create more disturbance inside one cell alone!

This week, I will start writing some documentation, to explain all of this and to present the choices available later to develop your own function with GLSL.

Weird Voronoi Pro

2011-07-16T23:04:00.004-04:00

Finally, I published my professional version of my live-wallpaper. Currently (while I'm writing those words), the live-wallpaper is not available on the Market, BUT NOW IT'S AVAILABLE. I think there's a delay before a paid apps is officially available (I hope it's not too long).

The big changes compared with the free version is the number of functions. First, you can choose a "ratio" as a basic value. For each pixel, before determining its color, the three closest points (according to the distance function used, not necessary the straight line) are found. Let d1, d2 and d3 be those distances. In the free version, the only ratio that exists is d1/d2. Which is the basic one used to draw Voronoi diagram. The background used on this blog is drawn with that ratio. Remember that where there's a Voronoi's edge, it means that two points are a the same distance, so d1/d2 = 1. If the pixel is right on a point, then d1/d2 = 0.

But in this new version, you have access to other ratio, like d1/d3, d2/d3 and (d1*d2)/(d3*d3). You, currently, have 11 choices for this. And the ratio influence the shape of the cells. For the color, only ratio using d1 and d2 make sense. All the other creates weird interaction. But some people might like it.

Second, the functions. For now, the function used to compute the distribution of the color consist of 4 steps. Let R be the ratio, then you have:

x = f(R)
y = f(x)
z = f(y)
c = f(z)

where 'c' is the value used for the color. For each step, you can choose among 55 functions (but let say 54, because if you choose f(R) = 1, then you remove a lot of choices). The default function is f(R) = R.
So, if we consider all possible choices (and ignore those that opposed each other), you have 54^4 possibles functions with 11 ratios. Therefore, you have 93 millions functions available to you.

NOTE that all function are f:[0,1] -> [0,1]. So, by restraining to this interval, it's easier to control at each steps.

Among the functions, there's some that use [?] and [!], two values between 0 and 1. These are values controlled elsewhere in the computation.

[?] is a random value that changes for each frame rendered. This value is not stable so it creates effects that some time might look like lightnings.
[!] on the other hand is more stable. It's a wave that follow the positive values of a sine. Therefore, it goes from 0 to 1 and then from 1 to 0. It can be used to have a regular effects over the color distribution. By default, it takes 4 seconds to have a full cycle, but it's possible to change the speed.

Here's the qr code and the direct link:

https://market.android.com/details?id=com.blogspot.widgg_research.WVP

Here's some screenshots:

The settings for the function. From the settings, click on "Functions" then "Cell and Color functions". You can see the selection of the ratio first followed by the four steps of functions.

I also post an update for the [!] feature. First, I was using the function sin(pi * t) where t is in [0;1]. But I forgot that this function is not continuous on the first derivative. This mean that at some point, the transition was not very fluid. It was following an half-circle and going fast on the 0 and took a lot of time around the 1.

Therefore, I changed it to cos(2*pi*t) * 0.5 + 0.5. With this, the function is still in the [0;1] range but the transition is very smooth. There's no drastic, unaesthetic, changes. All of this because the this function is continuous on the first derivative.

merging voronoi

2011-07-08T21:04:00.001-04:00

Here we are playing again with the Voronoi diagram (VD). We wanted to see what happen when sites are merged together (MVD, merged VD).

VD partitions the plane in cells where each of these cell represents the closest part of the plane to a particular site. So, if you have sites on a map of various fast food restaurants, the Voronoi diagram tells you which one is physically the closest to your location.

But imagine that we want to consider all restaurant from a particular chain as one entity. We want to know the influence or the domination of a particular chain.

The following images are in pair. The first one is the influence of a chain of restaurant and the second is the actual VD that everyone knows. Cells with the same color represents a chain of restaurant.

In the images, you can see some brighter points (particularly in the first two images), this is the actual location of the site (or restaurant for in our example).

And just like the VD is well known for its role in texture synthesis, we hope to find a way to use the MVD to create some interesting results.

As for the diagram itself, we don't really know what to do with it or how to interpret it. VD has a dual graph called the Delaunay Triangulation. But what would be the dual graph of MVD ? Where do we put the edges ? That's an open question.

More texture synthesis

2011-07-04T22:31:00.000-04:00

In this post, I present some new result that we really like. Again, it's a variation of the Voronoi diagram. You can observe the Voronoi cells interacting with each other. The colors help to see clearly the cells. And because of the few number of color, some cells might share the same color but are not related at all.

Here's some of the results:

This method, if it produces the result we're expecting, can be used to create texture by simply specifying some parameters or an artist can use a program with that method implemented to place some control points and control other parameters.

Again, all these images can be computed with CUDA because each pixel is unique.

mosaic

2011-06-27T16:03:00.000-04:00

Yesterday I mentioned using images as a source for the points and orientations. And I managed to do something.

First, the original image (a South Park version of myself, before I lose some weight):

And here's the various mosaic:

I used various effects to control the orientation in the cell. Plus I tried a random point selection, except for the first output.

Which one do you prefer ?

Naturally, to produce the output, I'm still using CUDA. I didn't used any data structure to optimize, so it can be computed a bit faster.