forked from libtcod/python-tcod
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathnoise.py
More file actions
267 lines (227 loc) · 9.52 KB
/
noise.py
File metadata and controls
267 lines (227 loc) · 9.52 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
"""
The :any:`Noise.sample_mgrid` and :any:`Noise.sample_ogrid` methods are
multi-threaded operations when the Python runtime supports OpenMP.
Even when single threaded these methods will perform much better than
multiple calls to :any:`Noise.get_point`.
Example::
import numpy as np
import tcod
import tcod.noise
noise = tcod.noise.Noise(
dimensions=2,
algorithm=tcod.NOISE_SIMPLEX,
implementation=tcod.noise.TURBULENCE,
hurst=0.5,
lacunarity=2.0,
octaves=4,
seed=None,
)
# Create a 5x5 open multi-dimensional mesh-grid.
ogrid = [np.arange(5, dtype=np.float32),
np.arange(5, dtype=np.float32)]
print(ogrid)
# Scale the grid.
ogrid[0] *= 0.25
ogrid[1] *= 0.25
# Return the sampled noise from this grid of points.
samples = noise.sample_ogrid(ogrid)
print(samples)
"""
from __future__ import absolute_import
import numpy as np
from tcod.libtcod import ffi, lib
import tcod.libtcod
"""Noise implementation constants"""
SIMPLE = 0
FBM = 1
TURBULENCE = 2
class Noise(object):
"""
The ``hurst`` exponent describes the raggedness of the resultant noise,
with a higher value leading to a smoother noise.
Not used with tcod.noise.SIMPLE.
``lacunarity`` is a multiplier that determines how fast the noise
frequency increases for each successive octave.
Not used with tcod.noise.SIMPLE.
Args:
dimensions (int): Must be from 1 to 4.
algorithm (int): Defaults to NOISE_SIMPLEX
implementation (int): Defaults to tcod.noise.SIMPLE
hurst (float): The hurst exponent. Should be in the 0.0-1.0 range.
lacunarity (float): The noise lacunarity.
octaves (float): The level of detail on fBm and turbulence
implementations.
seed (Optional[Random]): A Random instance, or None.
Attributes:
noise_c (CData): A cffi pointer to a TCOD_noise_t object.
"""
def __init__(self, dimensions, algorithm=2, implementation=SIMPLE,
hurst=0.5, lacunarity=2.0, octaves=4, seed=None):
if not 0 < dimensions <= 4:
raise ValueError('dimensions must be in range 0 < n <= 4, got %r' %
(dimensions,))
self._random = seed
_random_c = seed.random_c if seed else ffi.NULL
self._algorithm = algorithm
self.noise_c = ffi.gc(
ffi.cast(
'struct TCOD_Noise*',
lib.TCOD_noise_new(dimensions, hurst, lacunarity,
_random_c),
),
lib.TCOD_noise_delete)
self._tdl_noise_c = ffi.new('TDLNoise*', (self.noise_c,
dimensions,
0,
octaves))
self.implementation = implementation # sanity check
@property
def dimensions(self):
return self._tdl_noise_c.dimensions
@property
def dimentions(self): # deprecated
return self.dimensions
@property
def algorithm(self):
return self.noise_c.noise_type
@algorithm.setter
def algorithm(self, value):
lib.TCOD_noise_set_type(self.noise_c, value)
@property
def implementation(self):
return self._tdl_noise_c.implementation
@implementation.setter
def implementation(self, value):
if not 0 <= value < 3:
raise ValueError('%r is not a valid implementation. ' % (value,))
self._tdl_noise_c.implementation = value
@property
def hurst(self):
return self.noise_c.H
@property
def lacunarity(self):
return self.noise_c.lacunarity
@property
def octaves(self):
return self._tdl_noise_c.octaves
@octaves.setter
def octaves(self, value):
self._tdl_noise_c.octaves = value
def get_point(self, x=0, y=0, z=0, w=0):
"""Return the noise value at the (x, y, z, w) point.
Args:
x (float): The position on the 1st axis.
y (float): The position on the 2nd axis.
z (float): The position on the 3rd axis.
w (float): The position on the 4th axis.
"""
return lib.NoiseGetSample(self._tdl_noise_c, (x, y, z, w))
def sample_mgrid(self, mgrid):
"""Sample a mesh-grid array and return the result.
The :any:`sample_ogrid` method performs better as there is a lot of
overhead when working with large mesh-grids.
Args:
mgrid (numpy.ndarray): A mesh-grid array of points to sample.
A contiguous array of type `numpy.float32` is preferred.
Returns:
numpy.ndarray: An array of sampled points.
This array has the shape: ``mgrid.shape[:-1]``.
The ``dtype`` is `numpy.float32`.
"""
mgrid = np.ascontiguousarray(mgrid, np.float32)
if mgrid.shape[0] != self.dimensions:
raise ValueError('mgrid.shape[0] must equal self.dimensions, '
'%r[0] != %r' % (mgrid.shape, self.dimensions))
out = np.ndarray(mgrid.shape[1:], np.float32)
if mgrid.shape[1:] != out.shape:
raise ValueError('mgrid.shape[1:] must equal out.shape, '
'%r[1:] != %r' % (mgrid.shape, out.shape))
lib.NoiseSampleMeshGrid(self._tdl_noise_c, out.size,
ffi.cast('float*', mgrid.ctypes.data),
ffi.cast('float*', out.ctypes.data))
return out
def sample_ogrid(self, ogrid):
"""Sample an open mesh-grid array and return the result.
Args
ogrid (Sequence[Sequence[float]]): An open mesh-grid.
Returns:
numpy.ndarray: An array of sampled points.
The ``shape`` is based on the lengths of the open mesh-grid
arrays.
The ``dtype`` is `numpy.float32`.
"""
if len(ogrid) != self.dimensions:
raise ValueError('len(ogrid) must equal self.dimensions, '
'%r != %r' % (len(ogrid), self.dimensions))
ogrids = [np.ascontiguousarray(array, np.float32) for array in ogrid]
out = np.ndarray([array.size for array in ogrids], np.float32)
lib.NoiseSampleOpenMeshGrid(
self._tdl_noise_c,
len(ogrids),
out.shape,
[ffi.cast('float*', array.ctypes.data) for array in ogrids],
ffi.cast('float*', out.ctypes.data),
)
return out
def __getstate__(self):
state = self.__dict__.copy()
if self.dimensions < 4 and self.noise_c.waveletTileData == ffi.NULL:
# Trigger a side effect of wavelet, so that copies will be synced.
saved_algo = self.algorithm
self.algorithm = tcod.libtcod.NOISE_WAVELET
self.get_point()
self.algorithm = saved_algo
waveletTileData = None
if self.noise_c.waveletTileData != ffi.NULL:
waveletTileData = list(self.noise_c.waveletTileData[0:32*32*32])
state['_waveletTileData'] = waveletTileData
state['noise_c'] = {
'ndim': self.noise_c.ndim,
'map': list(self.noise_c.map),
'buffer': [list(sub_buffer) for sub_buffer in self.noise_c.buffer],
'H': self.noise_c.H,
'lacunarity': self.noise_c.lacunarity,
'exponent': list(self.noise_c.exponent),
'waveletTileData': waveletTileData,
'noise_type': self.noise_c.noise_type,
}
state['_tdl_noise_c'] = {
'dimensions': self._tdl_noise_c.dimensions,
'implementation': self._tdl_noise_c.implementation,
'octaves': self._tdl_noise_c.octaves,
}
return state
def __setstate__(self, state):
if isinstance(state, tuple): # deprecated format
return self._setstate_old(state)
# unpack wavelet tile data if it exists
if '_waveletTileData' in state:
state['_waveletTileData'] = ffi.new('float[]',
state['_waveletTileData'])
state['noise_c']['waveletTileData'] = state['_waveletTileData']
else:
state['noise_c']['waveletTileData'] = ffi.NULL
# unpack TCOD_Noise and link to Random instance
state['noise_c']['rand'] = state['_random'].random_c
state['noise_c'] = ffi.new('struct TCOD_Noise*', state['noise_c'])
# unpack TDLNoise and link to libtcod noise
state['_tdl_noise_c']['noise'] = state['noise_c']
state['_tdl_noise_c'] = ffi.new('TDLNoise*', state['_tdl_noise_c'])
self.__dict__.update(state)
def _setstate_old(self, state):
self._random = state[0]
self.noise_c = ffi.new('struct TCOD_Noise*')
self.noise_c.ndim = state[3]
ffi.buffer(self.noise_c.map)[:] = state[4]
ffi.buffer(self.noise_c.buffer)[:] = state[5]
self.noise_c.H = state[6]
self.noise_c.lacunarity = state[7]
ffi.buffer(self.noise_c.exponent)[:] = state[8]
if state[9]:
# high change of this being prematurely garbage collected!
self.__waveletTileData = ffi.new('float[]', 32*32*32)
ffi.buffer(self.__waveletTileData)[:] = state[9]
self.noise_c.noise_type = state[10]
self._tdl_noise_c = ffi.new('TDLNoise*',
(self.noise_c, self.noise_c.ndim,
state[1], state[2]))