265 lines
44 KiB
Python
265 lines
44 KiB
Python
# Generated automatically by compile.ps1. Do not edit.
|
|
INBUILT_KEYWORDS = {
|
|
'break', 'continue', 'else', 'for', 'if', 'in', 'none', 'null', 'return', 'while'
|
|
}
|
|
INBUILT_CONSTANTS = {
|
|
'e', 'pi'
|
|
}
|
|
INBUILT_FUNCTIONS = {
|
|
'abs', 'acos', 'acosh', 'add_key', 'all', 'angle', 'any', 'append', 'argmax', 'argmin', 'argsort', 'as_nested', 'as_nested_tensor', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'band', 'batch_shuffle', 'bitcount', 'bitwise_and', 'bitwise_not', 'bitwise_or', 'bitwise_xor', 'blur', 'bnot', 'bor', 'botk', 'botk_ind', 'botk_indices', 'bxor', 'cat', 'ceil', 'cellular', 'cellular_noise', 'cielab_to_rgb', 'clamp', 'cnt', 'concat', 'concatenate', 'conv', 'convolution', 'coordinates', 'coords', 'corr', 'correlation', 'cos', 'cosh', 'cosine_similarity', 'cossim', 'count', 'cov', 'crop', 'cross', 'cubic', 'cubic_ease', 'cumprod', 'cumsum', 'diag', 'diagonal_matrix', 'dilate', 'dist', 'distance', 'domain_warp', 'domain_warp_noise', 'dot', 'edge', 'elastic', 'elastic_ease', 'endswith', 'entropy', 'erf', 'erfinv', 'erode', 'exp', 'ezconv', 'ezconvolution', 'fft', 'find', 'flatten', 'flip', 'float', 'floor', 'flow_ang', 'flow_angle', 'flow_apply', 'flow_mag', 'flow_magnitude', 'flow_to_image', 'fract', 'gamma', 'gaussian', 'gelu', 'get_value', 'hist', 'histogram', 'hsv_to_rgb', 'ifft', 'int', 'int_to_rgb', 'interpolate_area', 'interpolate_linear', 'interpolate_nearest', 'interpolate_nearest_exact', 'join', 'keys', 'length', 'lerp', 'linspace', 'ln', 'log', 'logspace', 'lower', 'map', 'matmul', 'mean', 'median', 'mode', 'moment', 'morph_close', 'morph_open', 'motion_mask', 'nan_to_num', 'noise', 'now', 'nvl', 'oklab_to_rgb', 'overlay', 'pad', 'percentile', 'perlin', 'perlin_noise', 'perm', 'permute', 'pinv', 'plasma', 'plasma_noise', 'popcnt', 'popcount', 'pow', 'prcnt', 'print', 'print_shape', 'pshp', 'quantile', 'quartil', 'quartile', 'rand', 'randb', 'randbeta', 'randc', 'randchi2', 'rande', 'randg', 'randgumbel', 'randl', 'randln', 'randn', 'random_bernoulli', 'random_beta', 'random_cauchy', 'random_chi2', 'random_exponential', 'random_gamma', 'random_gumbel', 'random_laplace', 'random_log_normal', 'random_normal', 'random_poisson', 'random_studentt', 'random_uniform', 'random_weibull', 'randp', 'randt', 'randu', 'randw', 'range', 'relu', 'remap', 'remove_key', 'repeat', 'replace', 'reshape', 'rgb_to_cielab', 'rgb_to_hsv', 'rgb_to_int', 'rgb_to_oklab', 'ridged', 'ridged_noise', 'rife', 'rm_kay', 'roll', 'round', 'rshp', 'select', 'shape', 'shuffle', 'sigm', 'sign', 'sin', 'sine', 'sine_ease', 'singular_value_decomposition', 'sinh', 'smax', 'smin', 'smootherstep', 'smoothstep', 'snorm', 'softmax', 'softmin', 'softplus', 'sort', 'split', 'sqrt', 'squeeze', 'stack_clear', 'stack_get', 'stack_has', 'stack_pop', 'stack_push', 'startswith', 'std', 'step', 'substr', 'substring', 'sum', 'svd', 'swap', 'tan', 'tanh', 'tensor', 'text_image', 'timestamp', 'tmax', 'tmin', 'tnorm', 'topk', 'topk_ind', 'topk_indices', 'trim', 'turbulence', 'unique', 'unsqueeze', 'upper', 'var', 'voronoi', 'voronoi_noise', 'where', 'worley'
|
|
}
|
|
|
|
INBUILT_FUNCTION_META = {
|
|
'sin': {'min_args': 1, 'max_args': 1, 'snippet': 'sin(x)', 'description': 'applies sinus function to value or each element of value'},
|
|
'cos': {'min_args': 1, 'max_args': 1, 'snippet': 'cos(x)', 'description': 'applies cosinus function to value or each element of value'},
|
|
'tan': {'min_args': 1, 'max_args': 1, 'snippet': 'tan(x)', 'description': 'applies tangents function to value or each element of value'},
|
|
'asin': {'min_args': 1, 'max_args': 1, 'snippet': 'asin(x)', 'description': 'applies arcus sinus function to value or each element of value'},
|
|
'acos': {'min_args': 1, 'max_args': 1, 'snippet': 'acos(x)', 'description': 'applies arcus cosinus function to value or each element of value'},
|
|
'atan': {'min_args': 1, 'max_args': 1, 'snippet': 'atan(x)', 'description': 'applies arcus tangents function to value or each element of value'},
|
|
'atan2': {'min_args': 2, 'max_args': 2, 'snippet': 'atan2(y, x)', 'description': 'computes the arc tangent of y/x, using the signs of both arguments to determine the quadrant'},
|
|
'sinh': {'min_args': 1, 'max_args': 1, 'snippet': 'sinh(x)', 'description': 'applies hyperbolic sinus function to value or each element of value'},
|
|
'cosh': {'min_args': 1, 'max_args': 1, 'snippet': 'cosh(x)', 'description': 'applies hyperbolic cosinus function to value or each element of value'},
|
|
'tanh': {'min_args': 1, 'max_args': 1, 'snippet': 'tanh(x)', 'description': 'applies hyperbolic tangents function to value or each element of value'},
|
|
'asinh': {'min_args': 1, 'max_args': 1, 'snippet': 'asinh(x)', 'description': 'applies hyperbolic arcus sinus function to value or each element of value'},
|
|
'acosh': {'min_args': 1, 'max_args': 1, 'snippet': 'acosh(x)', 'description': 'applies hyperbolic arcus cosinus function to value or each element of value'},
|
|
'atanh': {'min_args': 1, 'max_args': 1, 'snippet': 'atanh(x)', 'description': 'applies hyperbolic arcus tangents function to value or each element of value'},
|
|
'abs': {'min_args': 1, 'max_args': 1, 'snippet': 'abs(x)', 'description': 'applies per element absolute value function. Same as |x| for numbers.'},
|
|
'sqrt': {'min_args': 1, 'max_args': 1, 'snippet': 'sqrt(x)', 'description': 'applies sqere root per element. Negative numbers return NaN (not a number)'},
|
|
'ln': {'min_args': 1, 'max_args': 1, 'snippet': 'ln(x)', 'description': 'applies natural logarithm to value (per element). Negative numbers return NaN (not a number)'},
|
|
'log': {'min_args': 1, 'max_args': 1, 'snippet': 'log(x)', 'description': 'applies base 10 logarithm to value (per element). Negative numbers return NaN (not a number)'},
|
|
'exp': {'min_args': 1, 'max_args': 1, 'snippet': 'exp(x)', 'description': 'applies e^x to value (per element)'},
|
|
'smin': {'min_args': 1, 'max_args': None, 'snippet': 'smin(x, ...)', 'description': 'computes the minimum of inputs or elements. Tensors must have the same size or be broadcastable to same size. When called as smin(x, dims) with x a tensor/list, reduces x along dims (a single dim or list of dims) instead.'},
|
|
'smax': {'min_args': 1, 'max_args': None, 'snippet': 'smax(x, ...)', 'description': 'computes the maximum of inputs or elements. Tensors must have the same size or be broadcastable to same size. When called as smax(x, dims) with x a tensor/list, reduces x along dims (a single dim or list of dims) instead.'},
|
|
'tmin': {'min_args': 2, 'max_args': 2, 'snippet': 'tmin(x, y)', 'description': 'elementwise minimum of tensor or list. min(x,y) when inputs are floats'},
|
|
'tmax': {'min_args': 2, 'max_args': 2, 'snippet': 'tmax(x, y)', 'description': 'elementwise maximum of tensor or list. max(x,y) when inputs are floats'},
|
|
'tnorm': {'min_args': 1, 'max_args': 2, 'snippet': 'tnorm(x, dim)', 'description': 'normalises tensor or list by multiplication such that sum(x^2)==1.0 for each slice. Defaults to the last dimension; dim selects a different slicing dimension.'},
|
|
'snorm': {'min_args': 1, 'max_args': 2, 'snippet': 'snorm(x, dim)', 'description': 'frobenius norm of tensor. Along dimension if dimension specified. Dimension can be a list. Defaults to no dimension.'},
|
|
'floor': {'min_args': 1, 'max_args': 1, 'snippet': 'floor(x)', 'description': 'returns the largest integer less than or equal to x'},
|
|
'ceil': {'min_args': 1, 'max_args': 1, 'snippet': 'ceil(x)', 'description': 'returns the smallest integer greater than or equal to x'},
|
|
'round': {'min_args': 1, 'max_args': 1, 'snippet': 'round(x)', 'description': 'rounds x to the nearest integer'},
|
|
'gamma': {'min_args': 1, 'max_args': 1, 'snippet': 'gamma(x)', 'description': 'computes the gamma function (per element)'},
|
|
'pow': {'min_args': 2, 'max_args': 2, 'snippet': 'pow(x, y)', 'description': 'computes x raised to the power of y'},
|
|
'sigm': {'min_args': 1, 'max_args': 1, 'snippet': 'sigm(x)', 'description': 'applies the sigmoid function: 1 / (1 + exp(-x))'},
|
|
'clamp': {'min_args': 3, 'max_args': 3, 'snippet': 'clamp(x, min, max)', 'description': 'clamps x between min and max per element'},
|
|
'fft': {'min_args': 1, 'max_args': 1, 'snippet': 'fft(x)', 'description': 'computes fast Fourier transform of x'},
|
|
'ifft': {'min_args': 1, 'max_args': 2, 'snippet': 'ifft(x, shape)', 'description': 'inverse fast Fourier transform of x. shape (defaults to the node\'s tensor shape) sizes the K/Kx/Ky/.../frequency variables made available while evaluating x, it does not resize x itself.'},
|
|
'angle': {'min_args': 1, 'max_args': 1, 'snippet': 'angle(x)', 'description': 'returns the angle of a complex number or vector'},
|
|
'print': {'min_args': 1, 'max_args': 1, 'snippet': 'print(x)', 'description': 'prints the value of x to the console while passing output unchanged'},
|
|
'print_shape': {'min_args': 1, 'max_args': 1, 'snippet': 'print_shape(x)', 'description': 'prints the shape of the tensor x'},
|
|
'pshp': {'min_args': 1, 'max_args': 1, 'snippet': 'pshp(x)', 'description': 'prints the shape of the tensor x'},
|
|
'nvl': {'min_args': 4, 'max_args': 4, 'snippet': 'nvl(x, nan, pos_inf, neg_inf)', 'description': 'null value replacement - inspired by NVL'},
|
|
'nan_to_num': {'min_args': 4, 'max_args': 4, 'snippet': 'nan_to_num(x, nan, pos_inf, neg_inf)', 'description': 'null value replacement - inspired by NVL'},
|
|
'lerp': {'min_args': 3, 'max_args': 3, 'snippet': 'lerp(a, b, t)', 'description': 'linear interpolation between a and b by t per element. t can be float or tensor.'},
|
|
'step': {'min_args': 2, 'max_args': 2, 'snippet': 'step(x, edge)', 'description': 'returns 0 if x < edge, else 1'},
|
|
'smoothstep': {'min_args': 3, 'max_args': 3, 'snippet': 'smoothstep(x, edge0, edge1)', 'description': 'smooth interpolation between edge0 and edge1'},
|
|
'fract': {'min_args': 1, 'max_args': 1, 'snippet': 'fract(x)', 'description': 'returns the fractional part of x: x - floor(x)'},
|
|
'relu': {'min_args': 1, 'max_args': 1, 'snippet': 'relu(x)', 'description': 'applies rectified linear unit function: max(0, x)'},
|
|
'softplus': {'min_args': 1, 'max_args': 1, 'snippet': 'softplus(x)', 'description': 'applies the softplus function: ln(1 + exp(x))'},
|
|
'gelu': {'min_args': 1, 'max_args': 1, 'snippet': 'gelu(x)', 'description': 'applies the Gaussian Error Linear Unit (GELU) activation function'},
|
|
'sign': {'min_args': 1, 'max_args': 1, 'snippet': 'sign(x)', 'description': 'returns the sign of x: -1, 0, or 1'},
|
|
'map': {'min_args': 2, 'max_args': 4, 'snippet': 'map(tensor, coord1, coord2, coord3)', 'description': 'samples/remaps input tensor using coordinates'},
|
|
'ezconvolution': {'min_args': 2, 'max_args': 3, 'snippet': 'ezconvolution(tensor, kernel_sizes..., kernel)', 'description': 'applies convolution with kernel. Attempts to correctly convolve over size dimensions.'},
|
|
'ezconv': {'min_args': 2, 'max_args': 3, 'snippet': 'ezconv(tensor, kernel_sizes..., kernel)', 'description': 'applies convolution with kernel. Attempts to correctly convolve over size dimensions.'},
|
|
'convolution': {'min_args': 2, 'max_args': 3, 'snippet': 'convolution(tensor, kernel_sizes..., kernel)', 'description': 'applies convolution with kernel. Expects [batch,channel, ...]'},
|
|
'conv': {'min_args': 2, 'max_args': 3, 'snippet': 'conv(tensor, kernel_sizes..., kernel)', 'description': 'applies convolution with kernel. Expects [batch,channel, ...]'},
|
|
'swap': {'min_args': 4, 'max_args': 4, 'snippet': 'swap(x, dim, idx1, idx2)', 'description': 'swaps elements along dim between idx1 and idx2'},
|
|
'permute': {'min_args': 2, 'max_args': 2, 'snippet': 'permute(x, dims)', 'description': 'permutes the dimensions of tensor x according to dims'},
|
|
'perm': {'min_args': 2, 'max_args': 2, 'snippet': 'perm(x, dims)', 'description': 'permutes the dimensions of tensor x according to dims'},
|
|
'reshape': {'min_args': 2, 'max_args': 2, 'snippet': 'reshape(x, shape)', 'description': 'reshapes tensor x to the specified shape'},
|
|
'rshp': {'min_args': 2, 'max_args': 2, 'snippet': 'rshp(x, shape)', 'description': 'reshapes tensor x to the specified shape'},
|
|
'range': {'min_args': 3, 'max_args': 3, 'snippet': 'range(start, stop, step)', 'description': 'creates a range of values between start (inclusive) and stop (exclusive) using step. Use linspace if you want value count.'},
|
|
'linspace': {'min_args': 3, 'max_args': 3, 'snippet': 'linspace(start, stop, num)', 'description': 'creates num linearly spaced values from start to stop (inclusive). Use range if you want to control the step between values.'},
|
|
'logspace': {'min_args': 4, 'max_args': 4, 'snippet': 'logspace(start, stop, num, base)', 'description': 'creates logarithmically spaced values'},
|
|
'topk': {'min_args': 2, 'max_args': 2, 'snippet': 'topk(x, k)', 'description': 'returns the k largest elements of x. For tensors it keeps them in place.'},
|
|
'botk': {'min_args': 2, 'max_args': 2, 'snippet': 'botk(x, k)', 'description': 'returns the k smallest elements of x. For tensors it keeps them in place.'},
|
|
'pinv': {'min_args': 1, 'max_args': 1, 'snippet': 'pinv(x)', 'description': 'computes the permutative inverse of a list x (list must have uniqe elements) -- TODO: CHECK --'},
|
|
'sum': {'min_args': 1, 'max_args': 2, 'snippet': 'sum(x, dims)', 'description': 'computes the sum of elements of x, optionally along one or more dimensions'},
|
|
'mean': {'min_args': 1, 'max_args': 1, 'snippet': 'mean(x)', 'description': 'computes the arithmetic mean of elements of x'},
|
|
'std': {'min_args': 1, 'max_args': 1, 'snippet': 'std(x)', 'description': 'computes the standard deviation of elements of x'},
|
|
'var': {'min_args': 1, 'max_args': 1, 'snippet': 'var(x)', 'description': 'computes the variance of elements of x'},
|
|
'quartile': {'min_args': 2, 'max_args': 2, 'snippet': 'quartile(x, q)', 'description': 'computes the q-th quartile of x'},
|
|
'quartil': {'min_args': 2, 'max_args': 2, 'snippet': 'quartil(x, q)', 'description': 'computes the q-th quartile of x'},
|
|
'percentile': {'min_args': 2, 'max_args': 2, 'snippet': 'percentile(x, p)', 'description': 'computes the p-th percentile of x'},
|
|
'prcnt': {'min_args': 2, 'max_args': 2, 'snippet': 'prcnt(x, p)', 'description': 'computes the p-th percentile of x'},
|
|
'quantile': {'min_args': 2, 'max_args': 2, 'snippet': 'quantile(x, q)', 'description': 'computes the q-th quantile of x'},
|
|
'dot': {'min_args': 2, 'max_args': 2, 'snippet': 'dot(x, y)', 'description': 'computes the dot product of x and y after flattening both to 1D. Use cross(x, y) if you need a per-vector product with the last dimension kept.'},
|
|
'moment': {'min_args': 3, 'max_args': 3, 'snippet': 'moment(x, a, k)', 'description': 'computes the k-th moment of x around a'},
|
|
'erf': {'min_args': 1, 'max_args': 1, 'snippet': 'erf(x)', 'description': 'computes the error function (torch.erf)'},
|
|
'erfinv': {'min_args': 1, 'max_args': 1, 'snippet': 'erfinv(x)', 'description': 'computes the inverse error function (torch.erfinv)'},
|
|
'any': {'min_args': 1, 'max_args': 1, 'snippet': 'any(x)', 'description': 'returns 1 if any element of x is non-zero otherwise 0'},
|
|
'all': {'min_args': 1, 'max_args': 1, 'snippet': 'all(x)', 'description': 'returns 1 if all elements of x are non-zero otherwise 0'},
|
|
'edge': {'min_args': 1, 'max_args': 2, 'snippet': 'edge(x, matrix_size)', 'description': 'detects edges in x. Matrix size denotes the size of edge detection matrix.'},
|
|
'blur': {'min_args': 2, 'max_args': 3, 'snippet': 'blur(x, sigma, reshape)', 'description': 'applies a Gaussian blur to x with specified sigma. if reshape has value of 1.0, then it tries orienting the input such that channel is in the direction of filter. Otherwise it expect color dimension to be the last.'},
|
|
'gaussian': {'min_args': 2, 'max_args': 3, 'snippet': 'gaussian(x, sigma, reshape)', 'description': 'applies a Gaussian blur to x with specified sigma. if reshape has value of 1.0, then it tries orienting the input such that channel is in the direction of filter. Otherwise it expect color dimension to be the last.'},
|
|
'median': {'min_args': 1, 'max_args': 1, 'snippet': 'median(x)', 'description': 'computes the median of elements of x'},
|
|
'mode': {'min_args': 1, 'max_args': 1, 'snippet': 'mode(x)', 'description': 'computes the mode of elements of x'},
|
|
'cumsum': {'min_args': 1, 'max_args': 2, 'snippet': 'cumsum(x, dim)', 'description': 'computes the cumulative sum, defaulting to the first dimension.'},
|
|
'cumprod': {'min_args': 1, 'max_args': 1, 'snippet': 'cumprod(x)', 'description': 'computes the cumulative product over first dimension.'},
|
|
'topk_ind': {'min_args': 2, 'max_args': 2, 'snippet': 'topk_ind(x, k)', 'description': 'returns the indices of the k largest elements of x'},
|
|
'topk_indices': {'min_args': 2, 'max_args': 2, 'snippet': 'topk_indices(x, k)', 'description': 'returns the indices of the k largest elements of x'},
|
|
'botk_ind': {'min_args': 2, 'max_args': 2, 'snippet': 'botk_ind(x, k)', 'description': 'returns the indices of the k smallest elements of x'},
|
|
'botk_indices': {'min_args': 2, 'max_args': 2, 'snippet': 'botk_indices(x, k)', 'description': 'returns the indices of the k smallest elements of x'},
|
|
'cubic_ease': {'min_args': 3, 'max_args': 3, 'snippet': 'cubic_ease(a, b, t)', 'description': 'cubic ease between a and b'},
|
|
'cubic': {'min_args': 3, 'max_args': 3, 'snippet': 'cubic(a, b, t)', 'description': 'cubic ease between a and b'},
|
|
'elastic_ease': {'min_args': 3, 'max_args': 3, 'snippet': 'elastic_ease(a, b, t)', 'description': 'elastic ease between a and b'},
|
|
'elastic': {'min_args': 3, 'max_args': 3, 'snippet': 'elastic(a, b, t)', 'description': 'elastic ease between a and b'},
|
|
'sine_ease': {'min_args': 3, 'max_args': 3, 'snippet': 'sine_ease(a, b, t)', 'description': 'sine easing between a and b'},
|
|
'sine': {'min_args': 3, 'max_args': 3, 'snippet': 'sine(a, b, t)', 'description': 'sine easing between a and b'},
|
|
'smootherstep': {'min_args': 3, 'max_args': 3, 'snippet': 'smootherstep(x, edge0, edge1)', 'description': 'smoother interpolation between edge0 and edge1'},
|
|
'dist': {'min_args': 4, 'max_args': 4, 'snippet': 'dist(x1, y1, x2, y2)', 'description': 'computes Euclidean distance between (x1, y1) and (x2, y2)'},
|
|
'distance': {'min_args': 4, 'max_args': 4, 'snippet': 'distance(x1, y1, x2, y2)', 'description': 'computes Euclidean distance between (x1, y1) and (x2, y2)'},
|
|
'remap': {'min_args': 5, 'max_args': 5, 'snippet': 'remap(v, i_min, i_max, o_min, o_max)', 'description': 'remaps values from input range to output range'},
|
|
'cossim': {'min_args': 2, 'max_args': 2, 'snippet': 'cossim(x, y)', 'description': 'computes the cosine similarity between x and y.'},
|
|
'cosine_similarity': {'min_args': 2, 'max_args': 2, 'snippet': 'cosine_similarity(x, y)', 'description': 'computes the cosine similarity between x and y.'},
|
|
'count': {'min_args': 1, 'max_args': 1, 'snippet': 'count(x)', 'description': 'returns the number of elements in x'},
|
|
'cnt': {'min_args': 1, 'max_args': 1, 'snippet': 'cnt(x)', 'description': 'returns the number of elements in x'},
|
|
'length': {'min_args': 1, 'max_args': 1, 'snippet': 'length(x)', 'description': 'returns the number of elements in x'},
|
|
'keys': {'min_args': 1, 'max_args': 1, 'snippet': 'keys(x)', 'description': 'returns a list of dictionary keys in insertion order'},
|
|
'repeat': {'min_args': 2, 'max_args': 3, 'snippet': 'repeat(x, count, dims)', 'description': 'repeats tensor elements; count may be scalar or per-dim list'},
|
|
'flatten': {'min_args': 1, 'max_args': 1, 'snippet': 'flatten(x)', 'description': 'flattens tensor into a 1D tensor'},
|
|
'append': {'min_args': 2, 'max_args': 2, 'snippet': 'append(x, y)', 'description': 'appends y to the end of x. If inputs are tensors use concatenate(x,...,dim)'},
|
|
'get_value': {'min_args': 1, 'max_args': 1, 'snippet': 'get_value(slot)', 'description': 'returns the value at slot from stack'},
|
|
'flow_apply': {'min_args': 2, 'max_args': 2, 'snippet': 'flow_apply(image, flow)', 'description': 'applies optical flow to an image'},
|
|
'batch_shuffle': {'min_args': 2, 'max_args': 2, 'snippet': 'batch_shuffle(x, indices)', 'description': 'shuffles and duplicates or skips the batch dimension of x according to indices'},
|
|
'shuffle': {'min_args': 2, 'max_args': 2, 'snippet': 'shuffle(x, indices)', 'description': 'shuffles and duplicates or skips the batch dimension of x according to indices'},
|
|
'select': {'min_args': 2, 'max_args': 2, 'snippet': 'select(x, indices)', 'description': 'shuffles and duplicates or skips the batch dimension of x according to indices'},
|
|
'motion_mask': {'min_args': 1, 'max_args': 1, 'snippet': 'motion_mask(x)', 'description': 'generates a motion mask from optical flow'},
|
|
'flow_to_image': {'min_args': 1, 'max_args': 1, 'snippet': 'flow_to_image(x)', 'description': 'converts optical flow x to an RGB image. Up-Down is blue-yellow Left-right green-magenta.'},
|
|
'flow_mag': {'min_args': 1, 'max_args': 1, 'snippet': 'flow_mag(x)', 'description': 'computes the magnitude of optical flow (or any other structure with last dimension of 2)'},
|
|
'flow_magnitude': {'min_args': 1, 'max_args': 1, 'snippet': 'flow_magnitude(x)', 'description': 'computes the magnitude of optical flow (or any other structure with last dimension of 2)'},
|
|
'flow_ang': {'min_args': 1, 'max_args': 1, 'snippet': 'flow_ang(x)', 'description': 'computes the angle of optical flow (basically angle() but real and imaginery is separate in 2 dimensions)'},
|
|
'flow_angle': {'min_args': 1, 'max_args': 1, 'snippet': 'flow_angle(x)', 'description': 'computes the angle of optical flow (basically angle() but real and imaginery is separate in 2 dimensions)'},
|
|
'where': {'min_args': 3, 'max_args': 3, 'snippet': 'where(condition, x, y)', 'description': 'returns x if condition is true, else y. Runs per element.'},
|
|
'histogram': {'min_args': 4, 'max_args': 4, 'snippet': 'histogram(x, bins, min, max)', 'description': 'computes histogram'},
|
|
'hist': {'min_args': 4, 'max_args': 4, 'snippet': 'hist(x, bins, min, max)', 'description': 'computes histogram'},
|
|
'overlay': {'min_args': 3, 'max_args': 4, 'snippet': 'overlay(base, overlay, offset, opacity)', 'description': 'overlays overlay on base at offset. Opacity controls blending. It can be tensor or float. If it is tensor it should be the same shape as overlay.'},
|
|
'pad': {'min_args': 2, 'max_args': 2, 'snippet': 'pad(x, padding)', 'description': 'pads tensor x with specified padding (dim 0 neg, dim 0 pos, dim 1 ...)'},
|
|
'cross': {'min_args': 2, 'max_args': 2, 'snippet': 'cross(x, y)', 'description': 'computes the cross product of x and y. Last dimension must be 3'},
|
|
'matmul': {'min_args': 2, 'max_args': 2, 'snippet': 'matmul(x, y)', 'description': 'computes the matrix multiplication of x and y'},
|
|
'rife': {'min_args': 2, 'max_args': 5, 'snippet': 'rife(image1, image2, tiling_size, iterations, multi_scale)', 'description': 'computes the optical flow field ([H, W, 2]) between image1 and image2 using a RAFT-based model'},
|
|
'bnot': {'min_args': 1, 'max_args': 1, 'snippet': 'bnot(x)', 'description': 'computes the bitwise NOT'},
|
|
'bitwise_not': {'min_args': 1, 'max_args': 1, 'snippet': 'bitwise_not(x)', 'description': 'computes the bitwise NOT'},
|
|
'bitcount': {'min_args': 1, 'max_args': 1, 'snippet': 'bitcount(x)', 'description': 'returns the number of set bits'},
|
|
'popcount': {'min_args': 1, 'max_args': 1, 'snippet': 'popcount(x)', 'description': 'returns the number of set bits'},
|
|
'popcnt': {'min_args': 1, 'max_args': 1, 'snippet': 'popcnt(x)', 'description': 'returns the number of set bits'},
|
|
'shape': {'min_args': 1, 'max_args': 1, 'snippet': 'shape(x)', 'description': 'returns the shape of tensor as a list'},
|
|
'band': {'min_args': 2, 'max_args': 2, 'snippet': 'band(x, y)', 'description': 'computes the element-wise bitwise AND of x and y'},
|
|
'bitwise_and': {'min_args': 2, 'max_args': 2, 'snippet': 'bitwise_and(x, y)', 'description': 'computes the element-wise bitwise AND of x and y'},
|
|
'bxor': {'min_args': 2, 'max_args': 2, 'snippet': 'bxor(x, y)', 'description': 'computes the element-wise bitwise XOR of x and y'},
|
|
'bitwise_xor': {'min_args': 2, 'max_args': 2, 'snippet': 'bitwise_xor(x, y)', 'description': 'computes the element-wise bitwise XOR of x and y'},
|
|
'bor': {'min_args': 2, 'max_args': 2, 'snippet': 'bor(x, y)', 'description': 'computes the element-wise bitwise OR of x and y'},
|
|
'bitwise_or': {'min_args': 2, 'max_args': 2, 'snippet': 'bitwise_or(x, y)', 'description': 'computes the element-wise bitwise OR of x and y'},
|
|
'tensor': {'min_args': 1, 'max_args': 3, 'snippet': 'tensor(shape, value, dtype_template)', 'description': 'creates a tensor with specified shape and optional value/type. Default value is 0 and default format FP32'},
|
|
'add_key': {'min_args': 3, 'max_args': 3, 'snippet': 'add_key(dict, key, value)', 'description': 'adds or replaces a dictionary entry and returns the updated dictionary'},
|
|
'remove_key': {'min_args': 2, 'max_args': 2, 'snippet': 'remove_key(dict, key)', 'description': 'removes a dictionary entry and returns the updated dictionary'},
|
|
'rm_kay': {'min_args': 2, 'max_args': 2, 'snippet': 'rm_kay(dict, key)', 'description': 'removes a dictionary entry and returns the updated dictionary'},
|
|
'stack_push': {'min_args': 2, 'max_args': 2, 'snippet': 'stack_push(slot, val)', 'description': 'pushes val onto the end of slot stack'},
|
|
'stack_pop': {'min_args': 1, 'max_args': 1, 'snippet': 'stack_pop(slot)', 'description': 'removes and returns the last element of slot stack'},
|
|
'stack_clear': {'min_args': 1, 'max_args': 1, 'snippet': 'stack_clear(slot)', 'description': 'clears the contents of slot stack'},
|
|
'stack_has': {'min_args': 1, 'max_args': 1, 'snippet': 'stack_has(slot)', 'description': 'returns 1.0 if slot exists in stack and is not empty else returns 0.0'},
|
|
'stack_get': {'min_args': 1, 'max_args': 1, 'snippet': 'stack_get(slot)', 'description': 'returns the last pushed value in slot without popping it'},
|
|
'cat': {'min_args': 3, 'max_args': None, 'snippet': 'cat(x1, x2, ..., dim)', 'description': 'concatenates tensors along the specified dimension'},
|
|
'concat': {'min_args': 3, 'max_args': None, 'snippet': 'concat(x1, x2, ..., dim)', 'description': 'concatenates tensors along the specified dimension'},
|
|
'concatenate': {'min_args': 3, 'max_args': None, 'snippet': 'concatenate(x1, x2, ..., dim)', 'description': 'concatenates tensors along the specified dimension'},
|
|
'int': {'min_args': 1, 'max_args': 1, 'snippet': 'int(x)', 'description': 'casts x to integer'},
|
|
'float': {'min_args': 1, 'max_args': 1, 'snippet': 'float(x)', 'description': 'casts x to float'},
|
|
'upper': {'min_args': 1, 'max_args': 1, 'snippet': 'upper(x)', 'description': 'converts string to uppercase'},
|
|
'lower': {'min_args': 1, 'max_args': 1, 'snippet': 'lower(x)', 'description': 'converts string to lowercase'},
|
|
'trim': {'min_args': 1, 'max_args': 1, 'snippet': 'trim(x)', 'description': 'removes leading and trailing whitespace from string'},
|
|
'split': {'min_args': 1, 'max_args': 2, 'snippet': 'split(x, delimiter)', 'description': 'splits string to list of strings based on delimiter. Default is space.'},
|
|
'join': {'min_args': 1, 'max_args': 2, 'snippet': 'join(x, separator)', 'description': 'joins strings in list using separator. Defalut separator is "". If you want to join tensors use concatinate(...)'},
|
|
'substring': {'min_args': 2, 'max_args': 3, 'snippet': 'substring(s, start, length)', 'description': 'returns length characters of s starting at start. If length is not supplied, it returns the rest of the string'},
|
|
'substr': {'min_args': 2, 'max_args': 3, 'snippet': 'substr(s, start, length)', 'description': 'returns length characters of s starting at start. If length is not supplied, it returns the rest of the string'},
|
|
'find': {'min_args': 2, 'max_args': 2, 'snippet': 'find(s, sub)', 'description': 'returns the index of the first occurrence of sub in s. -1 if not found. Works only for strings.'},
|
|
'replace': {'min_args': 3, 'max_args': 3, 'snippet': 'replace(s, old, new)', 'description': 'replaces occurrences of old with new in s. Mostly for strings but can work with lists and tensors.'},
|
|
'dilate': {'min_args': 1, 'max_args': 2, 'snippet': 'dilate(x, kernel)', 'description': 'applies dilation to x. kernel is optional.'},
|
|
'erode': {'min_args': 1, 'max_args': 2, 'snippet': 'erode(x, kernel)', 'description': 'applies erosion to x. kernel is size of used matrix.'},
|
|
'morph_open': {'min_args': 1, 'max_args': 2, 'snippet': 'morph_open(x, kernel)', 'description': 'applies morphological opening to x. kernel is size of used matrix.'},
|
|
'morph_close': {'min_args': 1, 'max_args': 2, 'snippet': 'morph_close(x, kernel)', 'description': 'applies morphological closing to x. kernel is size of used matrix.'},
|
|
'rgb_to_oklab': {'min_args': 1, 'max_args': 3, 'snippet': 'rgb_to_oklab(r, g, b)', 'description': 'converts RGB to OKLab. It has 2 modes. Aither 1 or 3 parameters. With 1 parameter it expects last dimension of 3 and with 3 it concatinates them after converting.'},
|
|
'rgb_to_cielab': {'min_args': 1, 'max_args': 3, 'snippet': 'rgb_to_cielab(r, g, b)', 'description': 'converts RGB to CIELAB. It has 2 modes. Aither 1 or 3 parameters. With 1 parameter it expects last dimension of 3 and with 3 it concatinates them after converting.'},
|
|
'oklab_to_rgb': {'min_args': 1, 'max_args': 3, 'snippet': 'oklab_to_rgb(oklab)', 'description': 'converts OKLab to RGB. It has 2 modes. Aither 1 or 3 parameters. With 1 parameter it expects last dimension of 3 and with 3 it concatinates them after converting.'},
|
|
'cielab_to_rgb': {'min_args': 1, 'max_args': 3, 'snippet': 'cielab_to_rgb(cielab)', 'description': 'converts CIELAB to RGB. It has 2 modes. Aither 1 or 3 parameters. With 1 parameter it expects last dimension of 3 and with 3 it concatinates them after converting.'},
|
|
'rgb_to_hsv': {'min_args': 1, 'max_args': 4, 'snippet': 'rgb_to_hsv(rgb, degrees)', 'description': 'converts RGB to HSV. It has 2 modes. Aither 1 or 3 parameters. With 1 parameter it expects last dimension of 3 and with 3 it concatinates them after converting. If degrees is specified and nonzero it returns hue as 0-360 instead of 0-1'},
|
|
'hsv_to_rgb': {'min_args': 1, 'max_args': 4, 'snippet': 'hsv_to_rgb(hsv, degrees)', 'description': 'converts HSV to RGB. It has 2 modes. Aither 1 or 3 parameters. With 1 parameter it expects last dimension of 3 and with 3 it concatinates them after converting.'},
|
|
'int_to_rgb': {'min_args': 1, 'max_args': 1, 'snippet': 'int_to_rgb(val)', 'description': 'converts an integer to an RGB color. If input is tensor it stacks the resulting R, G and B tensors using last dimension. If It is list, List of lists is returned and if value, 3 long list is returned.'},
|
|
'rgb_to_int': {'min_args': 3, 'max_args': 3, 'snippet': 'rgb_to_int(r, g, b)', 'description': 'converts RGB components to an integer It uses last dimension of tensor (or list) as R,G,B if one value. Othervise uses whole thing as channel.'},
|
|
'interpolate_linear': {'min_args': 2, 'max_args': 2, 'snippet': 'interpolate_linear(x, y)', 'description': 'performs linear interpolation on X. Assumes that dim 0 is batch and dim 1 = channel'},
|
|
'interpolate_area': {'min_args': 2, 'max_args': 2, 'snippet': 'interpolate_area(x, y)', 'description': 'performs area interpolation X. Assumes that dim 0 is batch and dim 1 = channel'},
|
|
'interpolate_nearest': {'min_args': 2, 'max_args': 2, 'snippet': 'interpolate_nearest(x, y)', 'description': 'performs nearest neighbor interpolation X. Assumes that dim 0 is batch and dim 1 = channel'},
|
|
'interpolate_nearest_exact': {'min_args': 2, 'max_args': 2, 'snippet': 'interpolate_nearest_exact(x, y)', 'description': 'performs nearest neighbor interpolation X. Assumes that dim 0 is batch and dim 1 = channel'},
|
|
'text_image': {'min_args': 3, 'max_args': 9, 'snippet': 'text_image(text, font, size, max_width, weight, rotation_angle, line_spacing, italic, underline)', 'description': 'renders text to an 2D tensor'},
|
|
'as_nested_tensor': {'min_args': 1, 'max_args': 1, 'snippet': 'as_nested_tensor(x)', 'description': 'converts a list to a nested tensor (special object containing tensors of different shapes behaving like a tensor)'},
|
|
'as_nested': {'min_args': 1, 'max_args': 1, 'snippet': 'as_nested(x)', 'description': 'converts a list to a nested tensor (special object containing tensors of different shapes behaving like a tensor)'},
|
|
'svd': {'min_args': 1, 'max_args': 2, 'snippet': 'svd(x, full_matrices)', 'description': 'computes the singular value decomposition of x. Returns a list of 3 tensors: U, S, V such that x = matmul(matmul(U, diagonal_matrix(S,shape(U))), V)'},
|
|
'singular_value_decomposition': {'min_args': 1, 'max_args': 2, 'snippet': 'singular_value_decomposition(x, full_matrices)', 'description': 'computes the singular value decomposition of x. Returns a list of 3 tensors: U, S, V such that x = matmul(matmul(U, diagonal_matrix(S,shape(U))), V)'},
|
|
'diagonal_matrix': {'min_args': 2, 'max_args': 5, 'snippet': 'diagonal_matrix(x, shape, offset, dim1, dim2)', 'description': 'creates a diagonal matrix from x with specified shape. offset is the diagonal offset. dim1 and dim2 are the dimensions to place the diagonal on.'},
|
|
'diag': {'min_args': 2, 'max_args': 5, 'snippet': 'diag(x, shape, offset, dim1, dim2)', 'description': 'creates a diagonal matrix from x with specified shape. offset is the diagonal offset. dim1 and dim2 are the dimensions to place the diagonal on.'},
|
|
'timestamp': {'min_args': 0, 'max_args': 0, 'snippet': 'timestamp()', 'description': 'returns the current system timestamp'},
|
|
'now': {'min_args': 0, 'max_args': 0, 'snippet': 'now()', 'description': 'returns the current system timestamp'},
|
|
'sort': {'min_args': 1, 'max_args': 3, 'snippet': 'sort(x, desc, dim)', 'description': 'returns a sorted version of x (If input is tensor, it sorts the last dimension)'},
|
|
'argsort': {'min_args': 1, 'max_args': 3, 'snippet': 'argsort(x, desc, dim)', 'description': 'returns the indices that would sort x. desc defaults to ascending and dim defaults to the last dimension.'},
|
|
'argmin': {'min_args': 1, 'max_args': 2, 'snippet': 'argmin(x, as_position)', 'description': 'returns the minimum position in flattened x or coordinates as a list when requested'},
|
|
'argmax': {'min_args': 1, 'max_args': 2, 'snippet': 'argmax(x, as_position)', 'description': 'returns the maximum position in flattened x or coordinates as a list when requested'},
|
|
'softmax': {'min_args': 1, 'max_args': 2, 'snippet': 'softmax(x, axis)', 'description': 'applies the softmax function to x (sum of slice == 1.0 and max value <= 1.0). axis defaults to last.'},
|
|
'softmin': {'min_args': 1, 'max_args': 2, 'snippet': 'softmin(x, axis)', 'description': 'applies the softmin function to x (same as softmax(-x,[axis])). axis defaults to last.'},
|
|
'unique': {'min_args': 1, 'max_args': 1, 'snippet': 'unique(x)', 'description': 'returns the unique elements (sorted, flatened)'},
|
|
'flip': {'min_args': 2, 'max_args': 2, 'snippet': 'flip(x, dims)', 'description': 'reverses the order of elements along the specified dimensions. Works also for text and list with dims=0'},
|
|
'startswith': {'min_args': 2, 'max_args': 2, 'snippet': 'startswith(text, prefix)', 'description': 'returns 1 if text starts with prefix, else 0'},
|
|
'endswith': {'min_args': 2, 'max_args': 2, 'snippet': 'endswith(text, suffix)', 'description': 'returns 1 if text ends with suffix, else 0'},
|
|
'squeeze': {'min_args': 1, 'max_args': 2, 'snippet': 'squeeze(x, dim)', 'description': 'removes size-1 dimensions from tensor x, optionally at dim'},
|
|
'unsqueeze': {'min_args': 2, 'max_args': 2, 'snippet': 'unsqueeze(x, dim)', 'description': 'inserts a size-1 dimension into tensor x at dim'},
|
|
'roll': {'min_args': 2, 'max_args': 3, 'snippet': 'roll(x, shifts, axis)', 'description': 'rolls tensor x along axis'},
|
|
'cov': {'min_args': 2, 'max_args': 2, 'snippet': 'cov(x, y)', 'description': 'computes the covariance matrix of x and y'},
|
|
'corr': {'min_args': 2, 'max_args': 2, 'snippet': 'corr(x, y)', 'description': 'computes the correlation between x and y'},
|
|
'correlation': {'min_args': 2, 'max_args': 2, 'snippet': 'correlation(x, y)', 'description': 'computes the correlation between x and y'},
|
|
'entropy': {'min_args': 1, 'max_args': 1, 'snippet': 'entropy(x)', 'description': 'computes shanon entropy'},
|
|
'crop': {'min_args': 3, 'max_args': 3, 'snippet': 'crop(x, start, size)', 'description': 'crops tensor x. Take size and begin at start. start should be the low corner. The result is at most size (if size is bigger then rest of tensor).'},
|
|
'coords': {'min_args': 2, 'max_args': 3, 'snippet': 'coords(shape, dim, dtype)', 'description': 'generates a tensor with the specified shape whose values are the coordinates of each element along the specified dimension. The dtype can be specified to control the data type of the output tensor.'},
|
|
'coordinates': {'min_args': 2, 'max_args': 3, 'snippet': 'coordinates(shape, dim, dtype)', 'description': 'generates a tensor with the specified shape whose values are the coordinates of each element along the specified dimension. The dtype can be specified to control the data type of the output tensor.'},
|
|
'noise': {'min_args': 1, 'max_args': 2, 'snippet': 'noise(seed, shape)', 'description': 'generates normally distributed random noise'},
|
|
'randn': {'min_args': 1, 'max_args': 2, 'snippet': 'randn(seed, shape)', 'description': 'generates normally distributed random noise'},
|
|
'random_normal': {'min_args': 1, 'max_args': 2, 'snippet': 'random_normal(seed, shape)', 'description': 'generates normally distributed random noise'},
|
|
'rand': {'min_args': 1, 'max_args': 2, 'snippet': 'rand(seed, shape)', 'description': 'generates uniformly distributed random noise'},
|
|
'randu': {'min_args': 1, 'max_args': 2, 'snippet': 'randu(seed, shape)', 'description': 'generates uniformly distributed random noise'},
|
|
'random_uniform': {'min_args': 1, 'max_args': 2, 'snippet': 'random_uniform(seed, shape)', 'description': 'generates uniformly distributed random noise'},
|
|
'randc': {'min_args': 3, 'max_args': 4, 'snippet': 'randc(seed, median, sigma, shape)', 'description': 'generates Cauchy distributed random values.'},
|
|
'random_cauchy': {'min_args': 3, 'max_args': 4, 'snippet': 'random_cauchy(seed, median, sigma, shape)', 'description': 'generates Cauchy distributed random values.'},
|
|
'rande': {'min_args': 2, 'max_args': 3, 'snippet': 'rande(seed, lambda, shape)', 'description': 'generates exponentially distributed random values'},
|
|
'random_exponential': {'min_args': 2, 'max_args': 3, 'snippet': 'random_exponential(seed, lambda, shape)', 'description': 'generates exponentially distributed random values'},
|
|
'randln': {'min_args': 3, 'max_args': 4, 'snippet': 'randln(seed, mean, std, shape)', 'description': 'generates log-normally distributed random values.'},
|
|
'random_log_normal': {'min_args': 3, 'max_args': 4, 'snippet': 'random_log_normal(seed, mean, std, shape)', 'description': 'generates log-normally distributed random values.'},
|
|
'randb': {'min_args': 2, 'max_args': 3, 'snippet': 'randb(seed, probability, shape)', 'description': 'generates Bernoulli distributed random values (0 or 1). Probability can be a tensor'},
|
|
'random_bernoulli': {'min_args': 2, 'max_args': 3, 'snippet': 'random_bernoulli(seed, probability, shape)', 'description': 'generates Bernoulli distributed random values (0 or 1). Probability can be a tensor'},
|
|
'randp': {'min_args': 2, 'max_args': 3, 'snippet': 'randp(seed, lambda, shape)', 'description': 'generates Poisson distributed random values.'},
|
|
'random_poisson': {'min_args': 2, 'max_args': 3, 'snippet': 'random_poisson(seed, lambda, shape)', 'description': 'generates Poisson distributed random values.'},
|
|
'randg': {'min_args': 3, 'max_args': 4, 'snippet': 'randg(seed, shape_param, scale, shape)', 'description': 'generates Gamma distributed random values.'},
|
|
'random_gamma': {'min_args': 3, 'max_args': 4, 'snippet': 'random_gamma(seed, shape_param, scale, shape)', 'description': 'generates Gamma distributed random values.'},
|
|
'randbeta': {'min_args': 3, 'max_args': 4, 'snippet': 'randbeta(seed, alpha, beta, shape)', 'description': 'generates Beta distributed random values'},
|
|
'random_beta': {'min_args': 3, 'max_args': 4, 'snippet': 'random_beta(seed, alpha, beta, shape)', 'description': 'generates Beta distributed random values'},
|
|
'randl': {'min_args': 3, 'max_args': 4, 'snippet': 'randl(seed, loc, scale, shape)', 'description': 'generates Laplace distributed random values'},
|
|
'random_laplace': {'min_args': 3, 'max_args': 4, 'snippet': 'random_laplace(seed, loc, scale, shape)', 'description': 'generates Laplace distributed random values'},
|
|
'randgumbel': {'min_args': 3, 'max_args': 4, 'snippet': 'randgumbel(seed, loc, scale, shape)', 'description': 'generates Gumbel distributed random values'},
|
|
'random_gumbel': {'min_args': 3, 'max_args': 4, 'snippet': 'random_gumbel(seed, loc, scale, shape)', 'description': 'generates Gumbel distributed random values'},
|
|
'randw': {'min_args': 3, 'max_args': 4, 'snippet': 'randw(seed, scale, concentration, shape)', 'description': 'generates Weibull distributed random values'},
|
|
'random_weibull': {'min_args': 3, 'max_args': 4, 'snippet': 'random_weibull(seed, scale, concentration, shape)', 'description': 'generates Weibull distributed random values'},
|
|
'randchi2': {'min_args': 2, 'max_args': 3, 'snippet': 'randchi2(seed, df, shape)', 'description': 'generates Chi-squared distributed random values'},
|
|
'random_chi2': {'min_args': 2, 'max_args': 3, 'snippet': 'random_chi2(seed, df, shape)', 'description': 'generates Chi-squared distributed random values'},
|
|
'randt': {'min_args': 2, 'max_args': 3, 'snippet': 'randt(seed, df, shape)', 'description': 'generates Student-t distributed random values'},
|
|
'random_studentt': {'min_args': 2, 'max_args': 3, 'snippet': 'random_studentt(seed, df, shape)', 'description': 'generates Student-t distributed random values'},
|
|
'perlin': {'min_args': 2, 'max_args': 5, 'snippet': 'perlin(seed, scale, octaves, offset, shape)', 'description': 'generates Perlin noise'},
|
|
'perlin_noise': {'min_args': 2, 'max_args': 5, 'snippet': 'perlin_noise(seed, scale, octaves, offset, shape)', 'description': 'generates Perlin noise'},
|
|
'cellular': {'min_args': 2, 'max_args': 5, 'snippet': 'cellular(seed, scale, jitter, offset, shape)', 'description': 'generates Cellular/Voronoi noise'},
|
|
'voronoi': {'min_args': 2, 'max_args': 5, 'snippet': 'voronoi(seed, scale, jitter, offset, shape)', 'description': 'generates Cellular/Voronoi noise'},
|
|
'worley': {'min_args': 2, 'max_args': 5, 'snippet': 'worley(seed, scale, jitter, offset, shape)', 'description': 'generates Cellular/Voronoi noise'},
|
|
'cellular_noise': {'min_args': 2, 'max_args': 5, 'snippet': 'cellular_noise(seed, scale, jitter, offset, shape)', 'description': 'generates Cellular/Voronoi noise'},
|
|
'voronoi_noise': {'min_args': 2, 'max_args': 5, 'snippet': 'voronoi_noise(seed, scale, jitter, offset, shape)', 'description': 'generates Cellular/Voronoi noise'},
|
|
'plasma': {'min_args': 2, 'max_args': 5, 'snippet': 'plasma(seed, scale, octaves, offset, shape)', 'description': 'generates Plasma/Turbulence noise - same as perlin but default octaves 4'},
|
|
'turbulence': {'min_args': 2, 'max_args': 5, 'snippet': 'turbulence(seed, scale, octaves, offset, shape)', 'description': 'generates Plasma/Turbulence noise - same as perlin but default octaves 4'},
|
|
'plasma_noise': {'min_args': 2, 'max_args': 5, 'snippet': 'plasma_noise(seed, scale, octaves, offset, shape)', 'description': 'generates Plasma/Turbulence noise - same as perlin but default octaves 4'},
|
|
'ridged': {'min_args': 2, 'max_args': 5, 'snippet': 'ridged(seed, scale, octaves, offset, shape)', 'description': 'generates ridged multi-fractal noise'},
|
|
'ridged_noise': {'min_args': 2, 'max_args': 5, 'snippet': 'ridged_noise(seed, scale, octaves, offset, shape)', 'description': 'generates ridged multi-fractal noise'},
|
|
'domain_warp': {'min_args': 4, 'max_args': 8, 'snippet': 'domain_warp(seed, scale, warp_scale, warp_strength, octaves, warp_octaves, offset, shape)', 'description': 'generates domain warped noise'},
|
|
'domain_warp_noise': {'min_args': 4, 'max_args': 8, 'snippet': 'domain_warp_noise(seed, scale, warp_scale, warp_strength, octaves, warp_octaves, offset, shape)', 'description': 'generates domain warped noise'},
|
|
}
|