Blender V5.3
BPy_FrsNoise.cpp
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2004-2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BPy_FrsNoise.h"
10#include "BPy_Convert.h"
11
12#include "../system/RandGen.h"
13
14#include "BLI_sys_types.hh"
15
16#include <sstream>
17
18using namespace Freestyle;
19
21
22//-------------------MODULE INITIALIZATION--------------------------------
23int FrsNoise_Init(PyObject *module)
24{
25 if (module == nullptr) {
26 return -1;
27 }
28
29 if (PyType_Ready(&FrsNoise_Type) < 0) {
30 return -1;
31 }
32 PyModule_AddObjectRef(module, "Noise", (PyObject *)&FrsNoise_Type);
33
34 return 0;
35}
36
37//------------------------INSTANCE METHODS ----------------------------------
38
40 /* Wrap. */
41 FrsNoise_doc,
42 "Class to provide Perlin noise functionalities.\n"
43 "\n"
44 ".. method:: __init__(seed = -1)\n"
45 "\n"
46 " Builds a Noise object. Seed is an optional argument. The seed value is used\n"
47 " as a seed for random number generation if it is equal to or greater than zero;\n"
48 " otherwise, time is used as a seed.\n"
49 "\n"
50 " :param seed: Seed for random number generation.\n"
51 " :type seed: int\n");
52static int FrsNoise_init(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
53{
54 static const char *kwlist[] = {"seed", nullptr};
55 long seed = -1;
56
57 if (!PyArg_ParseTupleAndKeywords(args,
58 kwds,
59 "|" /* Optional arguments. */
60 "l" /* `seed` */
61 ":__init__",
62 (char **)kwlist,
63 &seed))
64 {
65 return -1;
66 }
67 self->n = new Noise(seed);
68 self->pn = new PseudoNoise();
69 return 0;
70}
71
73{
74 delete self->n;
75 delete self->pn;
76 Py_TYPE(self)->tp_free((PyObject *)self);
77}
78
79static PyObject *FrsNoise_repr(BPy_FrsNoise *self)
80{
81 return PyUnicode_FromFormat("Noise - address: %p", self->n);
82}
83
85 /* Wrap. */
86 FrsNoise_turbulence1_doc,
87 ".. method:: turbulence1(v, freq, amp, oct=4)\n"
88 "\n"
89 " Returns a noise value for a 1D element.\n"
90 "\n"
91 " :param v: One-dimensional sample point.\n"
92 " :type v: float\n"
93 " :param freq: Noise frequency.\n"
94 " :type freq: float\n"
95 " :param amp: Amplitude.\n"
96 " :type amp: float\n"
97 " :param oct: Number of octaves.\n"
98 " :type oct: int\n"
99 " :return: A noise value.\n"
100 " :rtype: float\n");
101static PyObject *FrsNoise_drand(BPy_FrsNoise * /*self*/, PyObject *args, PyObject *kwds)
102{
103 static const char *kwlist[] = {"seed", nullptr};
104 long seed = 0;
105 if (!PyArg_ParseTupleAndKeywords(args,
106 kwds,
107 "|" /* Optional arguments. */
108 "I" /* `seed` */
109 ":rand",
110 (char **)kwlist,
111 &seed))
112 {
113 PyErr_SetString(PyExc_TypeError, "optional argument 1 must be of type int");
114 return nullptr;
115 }
116 if (seed) {
117 RandGen::srand48(seed);
118 }
119 return PyFloat_FromDouble(RandGen::drand48());
120}
121
122static PyObject *FrsNoise_turbulence_smooth(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
123{
124 static const char *kwlist[] = {"v", "oct", nullptr};
125
126 double x; // NOTE: this has to be a double (not float)
127 uint nbOctaves = 8;
128
129 if (!PyArg_ParseTupleAndKeywords(args,
130 kwds,
131 "d" /* `v` */
132 "|" /* Optional arguments. */
133 "I" /* `oct` */
134 ":turbulence_smooth",
135 (char **)kwlist,
136 &x,
137 &nbOctaves))
138 {
139 return nullptr;
140 }
141 return PyFloat_FromDouble(self->pn->turbulenceSmooth(x, nbOctaves));
142}
143
144static PyObject *FrsNoise_turbulence1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
145{
146 static const char *kwlist[] = {"v", "freq", "amp", "oct", nullptr};
147 float f1, f2, f3;
148 uint i = 4;
149
150 if (!PyArg_ParseTupleAndKeywords(args,
151 kwds,
152 "f" /* `v` */
153 "f" /* `freq` */
154 "f" /* `amp` */
155 "|" /* Optional arguments. */
156 "I" /* `oct` */
157 ":turbulence1",
158 (char **)kwlist,
159 &f1,
160 &f2,
161 &f3,
162 &i))
163 {
164 return nullptr;
165 }
166 return PyFloat_FromDouble(self->n->turbulence1(f1, f2, f3, i));
167}
168
170 /* Wrap. */
171 FrsNoise_turbulence2_doc,
172 ".. method:: turbulence2(v, freq, amp, oct=4)\n"
173 "\n"
174 " Returns a noise value for a 2D element.\n"
175 "\n"
176 " :param v: Two-dimensional sample point.\n"
177 " :type v: :class:`mathutils.Vector` | tuple[float, float] | list[float]\n"
178 " :param freq: Noise frequency.\n"
179 " :type freq: float\n"
180 " :param amp: Amplitude.\n"
181 " :type amp: float\n"
182 " :param oct: Number of octaves.\n"
183 " :type oct: int\n"
184 " :return: A noise value.\n"
185 " :rtype: float\n");
186static PyObject *FrsNoise_turbulence2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
187{
188 static const char *kwlist[] = {"v", "freq", "amp", "oct", nullptr};
189 PyObject *obj1;
190 float f2, f3;
191 uint i = 4;
192 Vec2f vec;
193
194 if (!PyArg_ParseTupleAndKeywords(args,
195 kwds,
196 "O" /* `v` */
197 "f" /* `freq` */
198 "f" /* `amp` */
199 "|" /* Optional arguments. */
200 "I" /* `oct` */
201 ":turbulence2",
202 (char **)kwlist,
203 &obj1,
204 &f2,
205 &f3,
206 &i))
207 {
208 return nullptr;
209 }
210 if (!Vec2f_ptr_from_PyObject(obj1, vec)) {
211 PyErr_SetString(PyExc_TypeError,
212 "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
213 return nullptr;
214 }
215 float t = self->n->turbulence2(vec, f2, f3, i);
216 return PyFloat_FromDouble(t);
217}
218
220 /* Wrap. */
221 FrsNoise_turbulence3_doc,
222 ".. method:: turbulence3(v, freq, amp, oct=4)\n"
223 "\n"
224 " Returns a noise value for a 3D element.\n"
225 "\n"
226 " :param v: Three-dimensional sample point.\n"
227 " :type v: :class:`mathutils.Vector` | tuple[float, float, float] | list[float]\n"
228 " :param freq: Noise frequency.\n"
229 " :type freq: float\n"
230 " :param amp: Amplitude.\n"
231 " :type amp: float\n"
232 " :param oct: Number of octaves.\n"
233 " :type oct: int\n"
234 " :return: A noise value.\n"
235 " :rtype: float\n");
236static PyObject *FrsNoise_turbulence3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
237{
238 static const char *kwlist[] = {"v", "freq", "amp", "oct", nullptr};
239 PyObject *obj1;
240 float f2, f3;
241 uint i = 4;
242 Vec3f vec;
243
244 if (!PyArg_ParseTupleAndKeywords(args,
245 kwds,
246 "O" /* `v` */
247 "f" /* `freq` */
248 "f" /* `amp` */
249 "|" /* Optional arguments. */
250 "I" /* `oct` */
251 ":turbulence3",
252 (char **)kwlist,
253 &obj1,
254 &f2,
255 &f3,
256 &i))
257 {
258 return nullptr;
259 }
260 if (!Vec3f_ptr_from_PyObject(obj1, vec)) {
261 PyErr_SetString(PyExc_TypeError,
262 "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
263 return nullptr;
264 }
265 float t = self->n->turbulence3(vec, f2, f3, i);
266 return PyFloat_FromDouble(t);
267}
268
270 /* Wrap. */
271 FrsNoise_smoothNoise1_doc,
272 ".. method:: smoothNoise1(v)\n"
273 "\n"
274 " Returns a smooth noise value for a 1D element.\n"
275 "\n"
276 " :param v: One-dimensional sample point.\n"
277 " :type v: float\n"
278 " :return: A smooth noise value.\n"
279 " :rtype: float\n");
280static PyObject *FrsNoise_smoothNoise1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
281{
282 static const char *kwlist[] = {"v", nullptr};
283 float f;
284
285 if (!PyArg_ParseTupleAndKeywords(args,
286 kwds,
287 "f" /* `v` */
288 ":smoothNoise1",
289 (char **)kwlist,
290 &f))
291 {
292 return nullptr;
293 }
294 return PyFloat_FromDouble(self->n->smoothNoise1(f));
295}
296
298 /* Wrap. */
299 FrsNoise_smoothNoise2_doc,
300 ".. method:: smoothNoise2(v)\n"
301 "\n"
302 " Returns a smooth noise value for a 2D element.\n"
303 "\n"
304 " :param v: Two-dimensional sample point.\n"
305 " :type v: :class:`mathutils.Vector` | tuple[float, float] | list[float]\n"
306 " :return: A smooth noise value.\n"
307 " :rtype: float\n");
308static PyObject *FrsNoise_smoothNoise2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
309{
310 static const char *kwlist[] = {"v", nullptr};
311 PyObject *obj;
312 Vec2f vec;
313
314 if (!PyArg_ParseTupleAndKeywords(args,
315 kwds,
316 "O" /* `v` */
317 ":smoothNoise2",
318 (char **)kwlist,
319 &obj))
320 {
321 return nullptr;
322 }
323 if (!Vec2f_ptr_from_PyObject(obj, vec)) {
324 PyErr_SetString(PyExc_TypeError,
325 "argument 1 must be a 2D vector (either a list of 2 elements or Vector)");
326 return nullptr;
327 }
328 float t = self->n->smoothNoise2(vec);
329 return PyFloat_FromDouble(t);
330}
331
333 /* Wrap. */
334 FrsNoise_smoothNoise3_doc,
335 ".. method:: smoothNoise3(v)\n"
336 "\n"
337 " Returns a smooth noise value for a 3D element.\n"
338 "\n"
339 " :param v: Three-dimensional sample point.\n"
340 " :type v: :class:`mathutils.Vector` | tuple[float, float, float] | list[float]\n"
341 " :return: A smooth noise value.\n"
342 " :rtype: float\n");
343static PyObject *FrsNoise_smoothNoise3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
344{
345 static const char *kwlist[] = {"v", nullptr};
346 PyObject *obj;
347 Vec3f vec;
348
349 if (!PyArg_ParseTupleAndKeywords(args,
350 kwds,
351 "O" /* `v` */
352 ":smoothNoise3",
353 (char **)kwlist,
354 &obj))
355 {
356 return nullptr;
357 }
358 if (!Vec3f_ptr_from_PyObject(obj, vec)) {
359 PyErr_SetString(PyExc_TypeError,
360 "argument 1 must be a 3D vector (either a list of 3 elements or Vector)");
361 return nullptr;
362 }
363 float t = self->n->smoothNoise3(vec);
364 return PyFloat_FromDouble(t);
365}
366
367#ifdef __GNUC__
368# ifdef __clang__
369# pragma clang diagnostic push
370# pragma clang diagnostic ignored "-Wcast-function-type"
371# else
372# pragma GCC diagnostic push
373# pragma GCC diagnostic ignored "-Wcast-function-type"
374# endif
375#endif
376
377static PyMethodDef BPy_FrsNoise_methods[] = {
378 {"turbulence1",
379 (PyCFunction)FrsNoise_turbulence1,
380 METH_VARARGS | METH_KEYWORDS,
381 FrsNoise_turbulence1_doc},
382 {"turbulence2",
383 (PyCFunction)FrsNoise_turbulence2,
384 METH_VARARGS | METH_KEYWORDS,
385 FrsNoise_turbulence2_doc},
386 {"turbulence3",
387 (PyCFunction)FrsNoise_turbulence3,
388 METH_VARARGS | METH_KEYWORDS,
389 FrsNoise_turbulence3_doc},
390 {"smoothNoise1",
391 (PyCFunction)FrsNoise_smoothNoise1,
392 METH_VARARGS | METH_KEYWORDS,
393 FrsNoise_smoothNoise1_doc},
394 {"smoothNoise2",
395 (PyCFunction)FrsNoise_smoothNoise2,
396 METH_VARARGS | METH_KEYWORDS,
397 FrsNoise_smoothNoise2_doc},
398 {"smoothNoise3",
399 (PyCFunction)FrsNoise_smoothNoise3,
400 METH_VARARGS | METH_KEYWORDS,
401 FrsNoise_smoothNoise3_doc},
402 {"rand", (PyCFunction)FrsNoise_drand, METH_VARARGS | METH_KEYWORDS, nullptr},
403 {"turbulence_smooth",
404 (PyCFunction)FrsNoise_turbulence_smooth,
405 METH_VARARGS | METH_KEYWORDS,
406 nullptr},
407 {nullptr, nullptr, 0, nullptr},
408};
409
410#ifdef __GNUC__
411# ifdef __clang__
412# pragma clang diagnostic pop
413# else
414# pragma GCC diagnostic pop
415# endif
416#endif
417
418/*-----------------------BPy_FrsNoise type definition ------------------------------*/
419
420PyTypeObject FrsNoise_Type = {
421 /*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0)
422 /*tp_name*/ "Noise",
423 /*tp_basicsize*/ sizeof(BPy_FrsNoise),
424 /*tp_itemsize*/ 0,
425 /*tp_dealloc*/ (destructor)FrsNoise_dealloc,
426 /*tp_vectorcall_offset*/ 0,
427 /*tp_getattr*/ nullptr,
428 /*tp_setattr*/ nullptr,
429 /*tp_as_async*/ nullptr,
430 /*tp_repr*/ (reprfunc)FrsNoise_repr,
431 /*tp_as_number*/ nullptr,
432 /*tp_as_sequence*/ nullptr,
433 /*tp_as_mapping*/ nullptr,
434 /*tp_hash*/ nullptr,
435 /*tp_call*/ nullptr,
436 /*tp_str*/ nullptr,
437 /*tp_getattro*/ nullptr,
438 /*tp_setattro*/ nullptr,
439 /*tp_as_buffer*/ nullptr,
440 /*tp_flags*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
441 /*tp_doc*/ FrsNoise_doc,
442 /*tp_traverse*/ nullptr,
443 /*tp_clear*/ nullptr,
444 /*tp_richcompare*/ nullptr,
445 /*tp_weaklistoffset*/ 0,
446 /*tp_iter*/ nullptr,
447 /*tp_iternext*/ nullptr,
448 /*tp_methods*/ BPy_FrsNoise_methods,
449 /*tp_members*/ nullptr,
450 /*tp_getset*/ nullptr,
451 /*tp_base*/ nullptr,
452 /*tp_dict*/ nullptr,
453 /*tp_descr_get*/ nullptr,
454 /*tp_descr_set*/ nullptr,
455 /*tp_dictoffset*/ 0,
456 /*tp_init*/ (initproc)FrsNoise_init,
457 /*tp_alloc*/ nullptr,
458 /*tp_new*/ PyType_GenericNew,
459};
460
bool Vec3f_ptr_from_PyObject(PyObject *obj, Vec3f &vec)
bool Vec2f_ptr_from_PyObject(PyObject *obj, Vec2f &vec)
PyDoc_STRVAR(FalseBP1D___doc__, "Class hierarchy: :class:`freestyle.types.BinaryPredicate1D` > :class:`FalseBP1D`\n" "\n" ".. method:: __call__(inter1, inter2)\n" "\n" " Always returns false.\n" "\n" " :param inter1: The first Interface1D object.\n" " :type inter1: :class:`freestyle.types.Interface1D`\n" " :param inter2: The second Interface1D object.\n" " :type inter2: :class:`freestyle.types.Interface1D`\n" " :return: False.\n" " :rtype: bool\n")
static PyObject * FrsNoise_repr(BPy_FrsNoise *self)
static PyObject * FrsNoise_turbulence2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static void FrsNoise_dealloc(BPy_FrsNoise *self)
int FrsNoise_Init(PyObject *module)
static PyObject * FrsNoise_turbulence_smooth(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_smoothNoise3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_turbulence3(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
PyTypeObject FrsNoise_Type
static PyObject * FrsNoise_drand(BPy_FrsNoise *, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_smoothNoise1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_turbulence1(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyObject * FrsNoise_smoothNoise2(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
static PyMethodDef BPy_FrsNoise_methods[]
static int FrsNoise_init(BPy_FrsNoise *self, PyObject *args, PyObject *kwds)
Pseudo-random number generator.
float turbulence3(Vec3f &v, float freq, float amp, uint oct=4)
Definition Noise.cpp:101
float turbulence1(float arg, float freq, float amp, uint oct=4)
Definition Noise.cpp:76
float turbulence2(Vec2f &v, float freq, float amp, uint oct=4)
Definition Noise.cpp:88
float smoothNoise3(Vec3f &vec)
Definition Noise.cpp:171
float smoothNoise1(float arg)
Definition Noise.cpp:116
Noise(long seed=-1)
Definition Noise.cpp:228
float smoothNoise2(Vec2f &vec)
Definition Noise.cpp:132
real turbulenceSmooth(real x, uint nbOctave=8)
static void srand48(long seedval)
Definition RandGen.cpp:101
static real drand48()
Definition RandGen.cpp:94
VecMat::Vec3< float > Vec3f
Definition Geom.h:28
VecMat::Vec2< float > Vec2f
Definition Geom.h:22
inherits from class Rep
Definition AppCanvas.cpp:20
Freestyle::PseudoNoise * pn
PyObject_HEAD Freestyle::Noise * n