.. _net.sf.openfx.SeNoise:

SeNoise node
============

.. raw:: html

   <!-- Do not edit this file! It is generated automatically by Natron itself. -->

*This documentation is for version 1.0 of SeNoise (net.sf.openfx.SeNoise).*

Description
-----------

Generate noise.

Inputs
------

+--------+-------------+----------+
| Input  | Description | Optional |
+========+=============+==========+
| Source |             | Yes      |
+--------+-------------+----------+
| Mask   |             | Yes      |
+--------+-------------+----------+

Controls
--------

.. tabularcolumns:: |>{\raggedright}p{0.2\columnwidth}|>{\raggedright}p{0.06\columnwidth}|>{\raggedright}p{0.07\columnwidth}|p{0.63\columnwidth}|

.. cssclass:: longtable

 
| Parameter / script name                       | Type    | Default             | Function                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
| Replace / ``replace``                         | Boolean | Off                 | Clear the selected channel(s) before drawing into them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
| Colored Noise / ``noiseColored``              | Boolean | Off                 | If checked, generate independent noise patterns for the red, green and blue channels, and set alpha to 1.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 
| Noise Size / ``noiseSize``                    | Double  | x: 350 y: 350       | Size of noise in pixels, corresponding to its lowest frequency.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| Z0 / ``noiseZ``                               | Double  | 0                   | Z coordinate on the noise at frame=0. The noise pattern is different for every integer value of Z, so this can be used as a random seed.                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
| Z Slope / ``noiseZSlope``                     | Double  | 0                   | Z is computed as Z = Z0 + frame \* Z_slope. 0 means a constant noise, 1 means a different noise pattern at every frame, values close to 0 mean a noise that varies slowly with time.                                                                                                                                                                                                                                                                                                                                                                       |
 
| Noise Type / ``noiseType``                    | Choice  | FBM                 | | Kind of noise.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|                                               |         |                     | | **Cell Noise (cell)**: Cell noise generates a field of constant colored cubes based on the integer location. This is the same as the prman cellnoise function. You may want to set xRotate and yRotate to 0 in the Transform tab to get square cells.                                                                                                                                                                                                                                                                                                    |
|                                               |         |                     | | **Noise (noise)**: Noise is a random function that smoothly blends between samples at integer locations. This is Ken Perlin’s original noise function.                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                               |         |                     | | **FBM (fbm)**: FBM (Fractal Brownian Motion) is a multi-frequency noise function. The base frequency is the same as the “Noise” function. The total number of frequencies is controlled by octaves. The lacunarity is the spacing between the frequencies - a value of 2 means each octave is twice the previous frequency. The gain controls how much each frequency is scaled relative to the previous frequency.                                                                                                                                      |
|                                               |         |                     | | **Turbulence (turbulence)**: turbulence is a variant of fbm where the absolute value of each noise term is taken. This gives a more billowy appearance.                                                                                                                                                                                                                                                                                                                                                                                                  |
|                                               |         |                     | | **Voronoi (voronoi)**: Voronoi is a cellular noise pattern. It is a jittered variant of cellnoise. The type parameter describes different variants of the noise function. The jitter param controls how irregular the pattern is (jitter = 0 is like ordinary cellnoise). The fbm\* params can be used to distort the noise field. When fbmScale is zero (the default), there is no distortion. The remaining params are the same as for the fbm function. NOTE: This does not necessarily return [0,1] value, because it can return arbitrary distance. |
 
| Voronoi Type / ``voronoiType``                | Choice  | Cell                | | Different variants of the Voronoi noise function.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                               |         |                     | | **Cell (cell)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|                                               |         |                     | | **Type 2 (type2)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                               |         |                     | | **Type 3 (type3)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                               |         |                     | | **Type 4 (type4)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|                                               |         |                     | | **Type 5 (type5)**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 
| Jitter / ``jitter``                           | Double  | 0.5                 | The jitter param controls how irregular the pattern is (jitter = 0 is like ordinary cellnoise).                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| FBM Scale / ``fbmScale``                      | Double  | 0                   | The fbm\* params can be used to distort the noise field. When fbmScale is zero (the default), there is no distortion.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 
| Octaves / ``fbmOctaves``                      | Integer | 6                   | The total number of frequencies is controlled by octaves.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 
| Lacunarity / ``fbmLacunarity``                | Double  | 2                   | The lacunarity is the spacing between the frequencies - a value of 2 means each octave is twice the previous frequency.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
| Gain / ``fbmGain``                            | Double  | 0.5                 | The gain controls how much each frequency is scaled relative to the previous frequency.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
| Translate / ``transformTranslate``            | Double  | x: 0 y: 0           | Translation along the x and y axes in pixels. Can also be adjusted by clicking and dragging the center handle in the Viewer.                                                                                                                                                                                                                                                                                                                                                                                                                               |
 
| Rotate / ``transformRotate``                  | Double  | 0                   | Rotation angle in degrees around the Center. Can also be adjusted by clicking and dragging the rotation bar in the Viewer.                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
| Scale / ``transformScale``                    | Double  | x: 1 y: 1           | Scale factor along the x and y axes. Can also be adjusted by clicking and dragging the outer circle or the diameter handles in the Viewer.                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
| Uniform / ``transformScaleUniform``           | Boolean | Off                 | Use the X scale for both directions                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| Skew X / ``transformSkewX``                   | Double  | 0                   | Skew along the x axis. Can also be adjusted by clicking and dragging the skew bar in the Viewer.                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 
| Skew Y / ``transformSkewY``                   | Double  | 0                   | Skew along the y axis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 
| Skew Order / ``transformSkewOrder``           | Choice  | XY                  | | The order in which skew transforms are applied: X then Y, or Y then X.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                               |         |                     | | **XY**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                               |         |                     | | **YX**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
| Amount / ``transformAmount``                  | Double  | 1                   | Amount of transform to apply. 0 means the transform is identity, 1 means to apply the full transform.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 
| Center / ``transformCenter``                  | Double  | x: 0.5 y: 0.5       | Center of rotation and scale.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
 
| Reset Center / ``transformResetCenter``       | Button  |                     | Reset the position of the center to the center of the input region of definition                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 
| Interactive Update / ``transformInteractive`` | Boolean | On                  | If checked, update the parameter values during interaction with the image viewer, else update the values when pen is released.                                                                                                                                                                                                                                                                                                                                                                                                                             |
 
| HiDPI / ``hidpi``                             | Boolean | Off                 | Should be checked when the display area is High-DPI (a.k.a Retina). Draws OpenGL overlays twice larger.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
| X Rotate / ``XRotate``                        | Double  | 27                  | Rotation about the X axis in the 3D noise space (X,Y,Z). Noise artifacts may appear if it is 0 or a multiple of 90.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| Y Rotate / ``YRotate``                        | Double  | 37                  | Rotation about the Y axis in the 3D noise space (X,Y,Z). Noise artifacts may appear if it is 0 or a multiple of 90.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 
| Ramp Type / ``rampType``                      | Choice  | None                | | The type of interpolation used to generate the ramp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|                                               |         |                     | | **Linear (linear)**: Linear ramp.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                               |         |                     | | **PLinear (plinear)**: Perceptually linear ramp in Rec.709.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|                                               |         |                     | | **Ease-in (easein)**: Catmull-Rom spline, smooth start, linear end (a.k.a. smooth0).                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|                                               |         |                     | | **Ease-out (easeout)**: Catmull-Rom spline, linear start, smooth end (a.k.a. smooth1).                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|                                               |         |                     | | **Smooth (smooth)**: Traditional smoothstep ramp.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|                                               |         |                     | | **None (none)**: No color gradient.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 
| Point 0 / ``rampPoint0``                      | Double  | x: 100 y: 100       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| Color 0 / ``rampColor0``                      | Color   | r: 0 g: 0 b: 0 a: 0 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| Point 1 / ``rampPoint1``                      | Double  | x: 100 y: 200       |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| Color 1 / ``rampColor1``                      | Color   | r: 1 g: 1 b: 1 a: 1 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
| Interactive Update / ``rampInteractive``      | Boolean | Off                 | If checked, update the parameter values during interaction with the image viewer, else update the values when pen is released.                                                                                                                                                                                                                                                                                                                                                                                                                             |
 
| Invert Mask / ``maskInvert``                  | Boolean | Off                 | When checked, the effect is fully applied where the mask is 0.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 
| Mix / ``mix``                                 | Double  | 1                   | Mix factor between the original and the transformed image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 
