A Simple Procedural Texture Algorithm – More Results and Code

spots

In a previous post I explained a simple algorithm for generating textures. Below are some more examples of the kinds of textures that the algorithm can generate, as well as how the different parameters influence the result. You can also download the code.

Continue reading “A Simple Procedural Texture Algorithm – More Results and Code”

Python Image Code

I use this code to illustrate many of the tutorials on this site, and the articles I write for Dev.Mag. Ideally, I would like to package the code so that it is the minimal necessary for the particular tutorial; however, a lot of the code is reused, so that it becomes difficult to maintain. Instead, I distribute it all together. That way, new updates and extensions can be found in one place.

The current version includes classes and functions for:

  • easy-syntax 2D and 3D arrays (for example, you can use grid[1:20:2, 2:3:20] to access the pixels in every second column (starting with column 1 and ending before column 20) and every third row (starting from row 2 and ending before row 20) (docs);
  • general image utility function (docs);
  • perlin noise (docs, tutorial);
  • poisson-disk sampling (docs, tutorial);
  • texture generation algorithms (docs, tutorial);
  • quadtrees (docs, tutorial part1 and part 2);
  • classes for generating random points (1D and 2D) from arbitrary distributions (docs, tutorial);
  • functions for blending between images (for smooth transitions between regions in seamless tile sets) [see blend_demo.py, tutorial];  and
  • functions for image quilting (under construction).
A few notes:
  • The code is not optimised, and in general convenience and clarity takes precedence over speed. This code is not suitable for many applications where speed is important.
  • The code will change often. At this stage I do not try to make it backwards compatible.

Download

Python Image Code v0.6

python_image_code_v0_6.zip (593 KB)

Requires PIL (Python Image Library).

This version includes some of the dependencies that accidentally got left behind in the previous version.

5 Tips for Prototyping Slow Algorithms

2054205239_334a519d0e

(Photo by  Darren Hester)

Some algorithms take a long time to return their results. Whether it is because the algorithm has to operate on a huge data set, or because it has combinatorial complexity; every time you run it you have to wait minutes or even hours for the thing to finish, making errors very expensive.

This post gives some advice on how to prototype slow algorithms with as little frustration as possible. We assume that this algorithm is being implemented experimentally – that is, you will tweak it and change it often before it is finished (it is not the kind of algorithm you type in straight from a text book). For example, I used the ideas outlined here while playing with the texture generating algorithm of the previous post.

Continue reading “5 Tips for Prototyping Slow Algorithms”

A Simple Procedural Texture Algorithm

texture

I am playing around with generating textures and decided to post some preliminary results. The algorithm used to create these images is simple to implement, but slow. Here is how it works:

1. Generate White Noise

Start off with white noise (grayscale only – colour is much too slow).

2. Blend with random neighbourhood pixels

Generate a new image from the old one. Every pixel in the new image is a blend between the corresponding pixel in the other image, and a randomly selected pixel in a square window around that pixel. Every point in that window can be selected with a probability that is defined in a square matrix.

This matrix determines how the texture will turn out; it is unfortunately a bit hard to guess how the texture will look given the matrix, in the general case, without some mathematical analysis.

3. Repeat

Repeat the above step. The more you repeat, the smoother the result is. The images below were created by repeating the step 50 times. On my computer, generating a 128 by 128 tile takes about 10 minutes (Python implementation).

4. Convert Grayscale to RGB

Normalise the image, and map to a gradient.

texture1 texture2 texture7
texture4 texture6 texture3
texture8 texture9 texture10

Some example textures are shown above.

 

Questions

There are some things that I still want to investigate:

  • Is there a way to significantly speed up the algorithm?
  • Is there an intuitive way to linkthe matrix with the result?
  • What are the effects of starting with something other than white noise?

Code

The code is currently too messy to release. I have built it on top of the code that was released for the Quadtrees article, so that is a good starting point if you do not want to wait. Otherwise, keep an eye out, I should post some code soon.

Generating Random Numbers with Arbitrary Distributions

For many applications, detailed statistical models are overkill. Instead, we can get away with a rough description of the distribution – not in mathematical formula form, but just as a graph with a few sample points.

For example, when trying to model the traffic around a school, you might know that the graph looks something like this:

school

The input is the number of minutes before the first bell rings, and the output the number of children dropped off at that time. You know that most kids are brought before the bell rings, and that the closer to the bell, the more kids are being brought every minute. Only a few kids are late.

This tutorial describes how to generate random numbers that can generate a distribution described by an arbitrary (piece-wise linear) curve, as the one above.

Continue reading “Generating Random Numbers with Arbitrary Distributions”

60 Ways to make Game Maker projects more maintainable

Game Maker is a great tool; it is especially suited for rapid development and small projects. However, as a project becomes bigger, it becomes more difficult to find things, easier to break it, and generally harder to work on. This is of course true for any production environment, and there are many things you can do to tame the beast of scale. Here are 60 things to make Game Maker projects more maintainable.

Continue reading “60 Ways to make Game Maker projects more maintainable”