HowTo:Turn a continuous function into a stepped function - Revision history

Jr: change deprecated 'source' tags to 'syntaxhighlight'.

2026-06-04T15:44:54Z

change deprecated 'source' tags to 'syntaxhighlight'.

SharkD: moved HowTo:Turn a function into a stepped function to HowTo:Turn a continuous function into a stepped function: be more specific

2010-07-26T16:40:40Z

moved HowTo:Turn a function into a stepped function to HowTo:Turn a continuous function into a stepped function: be more specific

SharkD: change int to floor

2008-07-01T02:03:57Z

change int to floor

SharkD: /* Viewing the results */

2008-06-24T02:28:28Z

Viewing the results

SharkD: /* Viewing the results */

2008-06-24T02:28:06Z

Viewing the results

SharkD: /* Creating the stepped function */

2008-06-24T02:27:27Z

Creating the stepped function

SharkD: /* Creating the stepped function */ copy-edit

2008-06-24T02:27:09Z

Creating the stepped function: copy-edit

SharkD: /* The initial function */ copy-edit

2008-06-24T02:25:27Z

The initial function: copy-edit

SharkD: /* The initial function */ copy-edit

2008-06-24T02:24:55Z

The initial function: copy-edit

SharkD: /* Overview */ copy-edit

2008-06-24T02:23:52Z

Overview: copy-edit

@@ Line 7: / Line 7: @@
 Before you can create a stepped function, you have to define the function the stepped function is based upon. For this example we will create a function that is used as a pattern in a pigment. Let's define a simple gradient that extends along the vector, <tt>x + y</tt>.
-<source lang=pov>#declare ThePattern = function(x, y, z) { x + y }</source>
+<syntaxhighlight lang=pov>#declare ThePattern = function(x, y, z) { x + y }</syntaxhighlight>
 This is equivalent to a gradient pattern. We could also have used this:
-<source lang=pov>#declare ThePattern = function { pattern { gradient x + y } };</source>
+<syntaxhighlight lang=pov>#declare ThePattern = function { pattern { gradient x + y } };</syntaxhighlight>
 Now that we've defined the initial function we can create the stepped function.
@@ Line 19: / Line 19: @@
 The basic idea behind creating a stepped function is to evaluate the original function in such a way that the values get rounded somehow. We determine how and how much a function gets rounded by specifying how many steps, or intervals, we want for every unit of POV space. We then multiply the function by this number, round it to the nearest integer, and divide the function by the same number you multiplied it by. Let's say we wanted three steps. Then, we would multiply the whole function by three, round it to the nearest integer, and divide by three.
-<source lang=pov>#declare SteppedPattern = function { floor(3 * ThePattern(x, y, z)) / 3 };</source>
+<syntaxhighlight lang=pov>#declare SteppedPattern = function { floor(3 * ThePattern(x, y, z)) / 3 };</syntaxhighlight>
 Let's interpolate across ten steps instead of three. In this case, do as follows.
-<source lang=pov>#declare SteppedPattern = function { floor(10 * ThePattern(x, y, z)) / 10 };</source>
+<syntaxhighlight lang=pov>#declare SteppedPattern = function { floor(10 * ThePattern(x, y, z)) / 10 };</syntaxhighlight>
 ==Viewing the results==
@@ Line 29: / Line 29: @@
 The next step is to render the image. For that we will use the following scene which contains our initial function and the stepped version applied to two boxes on a blue background.
-<source lang=pov>
+<syntaxhighlight lang=pov>
 #default { finish { ambient 1 } }
 background { rgb z * 0.5 }
@@ Line 62: / Line 62: @@
    translate x * 1.1
+}
-</source>
+</syntaxhighlight>
 The result should look something like this:

@@ Line 19: / Line 19: @@
 The basic idea behind creating a stepped function is to evaluate the original function in such a way that the values get rounded somehow. We determine how and how much a function gets rounded by specifying how many steps, or intervals, we want for every unit of POV space. We then multiply the function by this number, round it to the nearest integer, and divide the function by the same number you multiplied it by. Let's say we wanted three steps. Then, we would multiply the whole function by three, round it to the nearest integer, and divide by three.
-<source lang=pov>#declare SteppedPattern = function { int(3 * ThePattern(x, y, z)) / 3 };</source>
+<source lang=pov>#declare SteppedPattern = function { floor(3 * ThePattern(x, y, z)) / 3 };</source>
 Let's interpolate across ten steps instead of three. In this case, do as follows.
-<source lang=pov>#declare SteppedPattern = function { int(10 * ThePattern(x, y, z)) / 10 };</source>
+<source lang=pov>#declare SteppedPattern = function { floor(10 * ThePattern(x, y, z)) / 10 };</source>
 ==Viewing the results==
@@ Line 35: / Line 35: @@
 #declare ThePattern = function { x + y };
-#declare SteppedPattern = function { int(10 * ThePattern(x, y, z)) / 10 };
+#declare SteppedPattern = function { floor(10 * ThePattern(x, y, z)) / 10 };
 // Original pattern:

@@ Line 64: / Line 64: @@
 </source>
-The results should look something like this:
+The result should look something like this:
 [[Image:Stepped function pattern.png|left]]
 <br style="clear:all;"/>
 The pattern on the left is the original, smooth pattern. The pattern on the right is the same pattern, rounded to ten intervals.

@@ Line 27: / Line 27: @@
 ==Viewing the results==
-The next step is to render the image. For that we will use the following scene which contains our initial function and our stepped function.
+The next step is to render the image. For that we will use the following scene which contains our initial function and the stepped version applied to two boxes on a blue background.
 <source lang=pov>

@@ Line 21: / Line 21: @@
 <source lang=pov>#declare SteppedPattern = function { int(3 * ThePattern(x, y, z)) / 3 };</source>
-Let's interpolate across ten steps instead of three. In this case, we would do as follows.
+Let's interpolate across ten steps instead of three. In this case, do as follows.
 <source lang=pov>#declare SteppedPattern = function { int(10 * ThePattern(x, y, z)) / 10 };</source>

← Older revision	Revision as of 16:40, 26 July 2010
(No difference)

@@ Line 13: / Line 13: @@
 <source lang=pov>#declare ThePattern = function { pattern { gradient x + y } };</source>
-Now that we've created the initial function we can create a stepped function.
+Now that we've defined the initial function we can create the stepped function.
 ==Creating the stepped function==

@@ Line 5: / Line 5: @@
 ==The initial function==
-Before you can create a stepped function, you have to create the function it is based upon first. For this example we will create a function that is used as a pattern in a pigment. Let's define a simple gradient that extends along the vector, <tt>x + y</tt>.
+Before you can create a stepped function, you have to define the function the stepped function is based upon. For this example we will create a function that is used as a pattern in a pigment. Let's define a simple gradient that extends along the vector, <tt>x + y</tt>.
 <source lang=pov>#declare ThePattern = function(x, y, z) { x + y }</source>

@@ Line 1: / Line 1: @@
 ==Overview==
-Normally, functions are evaluated so that they transition smoothly from start to finish with no apparent pixelation. However, sometimes you want functions to evaluate in such a way such that the interpolation steps are apparent, or visible. For instance, maybe you are rendering the graph of a function and you want make it obvious to the viewer what the intervals are. In these cases you want to create a stepped function.
+Normally, functions are evaluated so that they transition smoothly from start to finish with no apparent pixelation. However, sometimes you want functions to evaluate in such a way such that the interpolation between steps is apparent. For instance, maybe you are rendering the graph of a function and you want to make it obvious to the viewer what the function's intervals are. In this case you want to use a stepped function.
 ==The initial function==