def coords(self, size=CHUNK, numWorkers=1): noise = fns.Noise(seed=None, numWorkers=numWorkers) coords = fns.empty_coords(size) coords[0,:] = np.arange(size) coords[1,:] = np.arange(-size//2, size//2) coords[2,:] = np.linspace(-1.0, 1.0, size) noise.genFromCoords(coords) # Re-use coords to make sure the array isn't accidentally free'd # in FastNoiseSIMD noise2 = fns.Noise(seed=None, numWorkers=numWorkers) noise2.genFromCoords(coords) return
def test_noise_type(self, size=CHUNK, numWorkers=1): noise = fns.Noise(seed=None, numWorkers=numWorkers) # Iterate through NoiseType for newNoise in fns.NoiseType: noise.noiseType = newNoise assert(noise.noiseType == newNoise) result = noise.genAsGrid(shape=size)
def generate_terrain(seed, points): coords = fns.empty_coords(points.shape[0]) coords[:] = points.T # Cellular, PerlinFractal, ValueFractal, Cubic, Simplex, WhiteNoise, CubicFractal, SimplexFractal, Perlin, Value noise = fns.Noise(seed=seed, numWorkers=1) noise.frequency = 0.02 noise.noiseType = fns.NoiseType.SimplexFractal noise.fractal.octaves = 4 noise.fractal.lacunarity = 2.1 noise.fractal.gain = 0.45 noise.perturb.perturbType = fns.PerturbType.NoPerturb noise_values = noise.genFromCoords(coords) # Create an empty array of air res = np.full(points.shape[:1], 0, dtype=np.uint32) # Assign dirt res[points[:, 2] + noise_values * 40 < 5.0] = 1 # Assign water res[points[:, 2] < 0.0] = 2 # # Assign clouds # res[(points[:, 2] - 110) ** 2 * 1e-1 + noise_values * 100 < -60.0] = 3 return res
def __init__(self, height, width, seed=None): self.distortion = Distortion() self.height = height self.width = width if not seed: seed = time.time_ns() self.perlin_noise = fns.Noise(seed) self.normalizing_lambda = lambda x: x * 2 * np.pi
def grid_3d(self, size=CHUNK3, numWorkers=1): noise = fns.Noise(seed=None, numWorkers=numWorkers) noise.frequency = 0.15 assert(noise.frequency == 0.15) noise.axesScales = [0.9, 0.85, 0.9] assert(noise.axesScales == [0.9, 0.85, 0.9]) result = noise.genAsGrid(shape=[size,size,size]) assert(result.shape == (size,size,size))
def fractal(self, size=CHUNK, numWorkers=1): # Iterate through FractalType noise = fns.Noise(seed=None, numWorkers=numWorkers) noise.fractal.octaves = 2 assert(noise.fractal.octaves == 2) noise.fractal.lacunarity = 1.9 assert(noise.fractal.lacunarity == 1.9) noise.fractal.gain = 0.7 assert(noise.fractal.gain == 0.7) for newFractal in fns.FractalType: noise.fractal.fractalType = newFractal assert(noise.fractal.fractalType == newFractal) noise.genAsGrid(shape=size)
def get_noise_block(shape, rx=0, rz=0): """ Fill a matrix with a nice perlin noise. :param shape: :return: """ perlin = fns.Noise(seed=42, numWorkers=2) perlin.frequency = 0.02 perlin.noiseType = fns.NoiseType.Perlin perlin.fractal.octaves = 4 perlin.fractal.lacunarity = 2.1 perlin.fractal.gain = 0.15 perlin.perturb.perturbType = fns.PerturbType.NoPerturb return perlin.genAsGrid(shape, start=[rx * 512, 0, rz * 512])
def test_perturb(self, size=CHUNK, numWorkers=1): # Iterate through PeturbType noise = fns.Noise(seed=None, numWorkers=numWorkers) noise.perturb.amp = 1.1 assert(noise.perturb.amp == 1.1) noise.perturb.frequency = 0.44 assert(noise.perturb.frequency == 0.44) noise.perturb.octaves = 2 assert(noise.perturb.octaves == 2) noise.perturb.lacunarity = 2.2 assert(noise.perturb.lacunarity == 2.2) noise.perturb.gain = 0.6 assert(noise.perturb.gain == 0.6) for newPeturb in fns.PerturbType: noise.perturb.perturbType = newPeturb assert(noise.perturb.perturbType == newPeturb) noise.genAsGrid(shape=size)
def get_noise_block_trees(shape, seed=27): """ Fill a matrix with a nice perlin noise. :param shape: :return: """ perlin = fns.Noise(seed=seed, numWorkers=2) perlin.frequency = 0.1 perlin.noiseType = fns.NoiseType.Perlin perlin.fractal.octaves = 4 perlin.fractal.lacunarity = 2.1 perlin.fractal.gain = 0.30 perlin.perturb.perturbType = fns.PerturbType.NoPerturb block = perlin.genAsGrid(shape) block -= block.min() block /= block.std() return block
def setup_fns(self, noise_type=fns.NoiseType.Simplex, frequency=0.01, fractal_type=fns.FractalType.FBM, fractal_octaves=3, fractal_gain=0.5, fractal_lacunarity=2.0, perturb_type=fns.PerturbType.NoPerturb, perturb_octaves=3, perturb_frequency=0.5, perturb_amp=1.0, perturb_gain=0.5, perturb_lacunarity=2.0, perturb_normalise_length=1.0, cell_distance_func=fns.CellularDistanceFunction.Euclidean, cell_distance_indices=(0, 1), cell_jitter=0.45, cell_lookup_frequency=0.2, cell_noise_lookup_type=fns.NoiseType.Simplex, cell_return_type=fns.CellularReturnType.Distance, seed=None): self.fns = fns.Noise(seed or self.seed) self.fns.noiseType = noise_type self.fns.frequency = frequency self.fns.fractal.fractalType = fractal_type self.fns.fractal.octaves = fractal_octaves self.fns.fractal.gain = fractal_gain self.fns.fractal.lacunarity = fractal_lacunarity self.fns.perturb.perturbType = perturb_type self.fns.perturb.octaves = perturb_octaves self.fns.perturb.frequency = perturb_frequency self.fns.perturb.amp = perturb_amp self.fns.perturb.gain = perturb_gain self.fns.perturb.lacunarity = perturb_lacunarity self.fns.perturb.normaliseLength = perturb_normalise_length self.fns.cell.distanceFunc = cell_distance_func self.fns.cell.distanceIndices = cell_distance_indices self.fns.cell.jitter = cell_jitter self.fns.cell.lookupFrequency = cell_lookup_frequency self.fns.cell.noiseLookupType = cell_noise_lookup_type self.fns.cell.returnType = cell_return_type
def test_cell(self, size=CHUNK, numWorkers=1): noise = fns.Noise(seed=None, numWorkers=numWorkers) # Iterate through cellular options noise.cell.jitter = 0.7 assert(noise.cell.jitter == 0.7) noise.cell.lookupFrequency = 0.3 assert(noise.cell.lookupFrequency == 0.3) noise.cell.distanceIndices = [0, 2] assert(noise.cell.distanceIndices == [0, 2]) noise.cell.returnType = fns.CellularReturnType.NoiseLookup for newNoise in fns.NoiseType: noise.cell.noiseLookupType = newNoise assert(noise.cell.noiseLookupType == newNoise) noise.genAsGrid(shape=size) for retType in fns.CellularReturnType: noise.cell.returnType = retType assert(noise.cell.returnType == retType) noise.genAsGrid(shape=size) for distFunc in fns.CellularDistanceFunction: noise.cell.distanceFunc = distFunc assert(noise.cell.distanceFunc == distFunc) noise.genAsGrid(shape=size)
def augmentDepth(depth, obj_mask, mask_ori, shadowClK, shadowMK, blurK, blurS, depthNoise, method): sensor = True simplex = True if method == 0: pass elif method == 1: sensor = True simplex = False elif method == 2: sensor = False simplex = True # erode and blur mask to get more realistic appearance partmask = mask_ori partmask = partmask.astype(np.float32) #mask = partmask > (np.median(partmask) * 0.4) partmask = np.where(partmask > 0.0, 255.0, 0.0) cv2.imwrite('/home/sthalham/partmask.png', partmask) # apply shadow kernel = np.ones((shadowClK, shadowClK)) partmask = cv2.morphologyEx(partmask, cv2.MORPH_OPEN, kernel) partmask = signal.medfilt2d(partmask, kernel_size=shadowMK) partmask = partmask.astype(np.uint8) mask = partmask > 20 depth = np.where(mask, depth, 0.0) if sensor is True: depthFinal = cv2.resize(depth, (270, 360)) res = (((depthFinal / 1000.0) * 1.41421356) ** 2) depthFinal = cv2.GaussianBlur(depthFinal, (blurK, blurK), blurS, blurS) # quantify to depth resolution and apply gaussian dNonVar = np.divide(depthFinal, res, out=np.zeros_like(depthFinal), where=res != 0) dNonVar = np.round(dNonVar) dNonVar = np.multiply(dNonVar, res) noise = np.multiply(dNonVar, depthNoise) depthFinal = np.random.normal(loc=dNonVar, scale=noise, size=dNonVar.shape) depth = cv2.resize(depthFinal, (resX, resY)) if simplex is True: # fast perlin noise seed = np.random.randint(2 ** 31) N_threads = 4 perlin = fns.Noise(seed=seed, numWorkers=N_threads) drawFreq = random.uniform(0.05, 0.2) # 0.05 - 0.2 # drawFreq = 0.5 perlin.frequency = drawFreq perlin.noiseType = fns.NoiseType.SimplexFractal perlin.fractal.fractalType = fns.FractalType.FBM drawOct = [4, 8] freqOct = np.bincount(drawOct) rndOct = np.random.choice(np.arange(len(freqOct)), 1, p=freqOct / len(drawOct), replace=False) perlin.fractal.octaves = rndOct perlin.fractal.lacunarity = 2.1 perlin.fractal.gain = 0.45 perlin.perturb.perturbType = fns.PerturbType.NoPerturb # linemod if not sensor: # noise according to keep it unreal #noiseX = np.random.uniform(0.0001, 0.1, resX * resY) # 0.0001 - 0.1 #noiseY = np.random.uniform(0.0001, 0.1, resX * resY) # 0.0001 - 0.1 #noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1 #Wxy = np.random.randint(0, 10) # 0 - 10 #Wz = np.random.uniform(0.0, 0.005) #0 - 0.005 noiseX = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1 noiseY = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1 noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1 Wxy = np.random.randint(2, 5) # 0 - 10 Wz = np.random.uniform(0.0001, 0.004) # 0 - 0.005 else: noiseX = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1 noiseY = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1 noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1 Wxy = np.random.randint(1, 5) # 1 - 5 Wz = np.random.uniform(0.0001, 0.004) #0.0001 - 0.004 # tless #noiseX = np.random.uniform(0.001, 0.1, resX * resY) # 0.0001 - 0.1 #noiseY = np.random.uniform(0.001, 0.1, resX * resY) # 0.0001 - 0.1 #noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1 #Wxy = np.random.randint(2, 8) # 0 - 10 #Wz = np.random.uniform(0.0, 0.005) X, Y = np.meshgrid(np.arange(resX), np.arange(resY)) coords0 = fns.empty_coords(resX * resY) coords1 = fns.empty_coords(resX * resY) coords2 = fns.empty_coords(resX * resY) coords0[0, :] = noiseX.ravel() coords0[1, :] = Y.ravel() coords0[2, :] = X.ravel() VecF0 = perlin.genFromCoords(coords0) VecF0 = VecF0.reshape((resY, resX)) coords1[0, :] = noiseY.ravel() coords1[1, :] = Y.ravel() coords1[2, :] = X.ravel() VecF1 = perlin.genFromCoords(coords1) VecF1 = VecF1.reshape((resY, resX)) coords2[0, :] = noiseZ.ravel() coords2[1, :] = Y.ravel() coords2[2, :] = X.ravel() VecF2 = perlin.genFromCoords(coords2) VecF2 = VecF2.reshape((resY, resX)) x = np.arange(resX, dtype=np.uint16) x = x[np.newaxis, :].repeat(resY, axis=0) y = np.arange(resY, dtype=np.uint16) y = y[:, np.newaxis].repeat(resX, axis=1) # vanilla #fx = x + Wxy * VecF0 #fy = y + Wxy * VecF1 #fx = np.where(fx < 0, 0, fx) #fx = np.where(fx >= resX, resX - 1, fx) #fy = np.where(fy < 0, 0, fy) #fy = np.where(fy >= resY, resY - 1, fy) #fx = fx.astype(dtype=np.uint16) #fy = fy.astype(dtype=np.uint16) #Dis = depth[fy, fx] + Wz * VecF2 #depth = np.where(Dis > 0, Dis, 0.0) #print(x.shape) #print(np.amax(depth)) #print(np.amin(depth)) Wxy_scaled = depth * 0.001 * Wxy Wz_scaled = depth * 0.001 * Wz # scale with depth fx = x + Wxy_scaled * VecF0 fy = y + Wxy_scaled * VecF1 fx = np.where(fx < 0, 0, fx) fx = np.where(fx >= resX, resX - 1, fx) fy = np.where(fy < 0, 0, fy) fy = np.where(fy >= resY, resY - 1, fy) fx = fx.astype(dtype=np.uint16) fy = fy.astype(dtype=np.uint16) Dis = depth[fy, fx] + Wz_scaled * VecF2 depth = np.where(Dis > 0, Dis, 0.0) return depth
import pyfastnoisesimd as fns import numpy as np import time from hihi import color_print as cp n = fns.Noise() n.numWorkers = 4 n_cycles = 12 print(cp.red('Is Numpy resizing the arrays after we exit scope?')) coords = [None] * n_cycles for I in range(n_cycles): len_coords = 4096 + I + 1 coords[I] = fns.empty_coords(len_coords) print(cp.yellow("\n Iteration #{I} with len: {len_coords}")) # print(f"\n\n Iteration #{I} with len: {len_coords}") coords[I][0, :] = np.pi coords[I][1, :] = 0.5 coords[I][2, :] = np.exp(1) result = n.genFromCoords(coords[I]) # time.sleep(0.2) print(cp.magenta('== Done ==')) # print('== Done ==')
# Generate lambda (meridian) and phi (parallel) angles in radians, from the # projection formula meridian = X * inverseRadius parallel = np.arcsin((0.5 * inverseRadius) * Y) # Show the sampling (essentially Tissot's indicatrices): ''' plt.figure() plt.plot( meridian, parallel, 'k.' ) plt.xlabel( 'meridian (rad)' ) plt.ylabel( 'Parallel (rad)' ) plt.title( 'meridian and parallel sampling space') ''' # Make your Noise object bumps = fns.Noise(seed=42) bumps.noiseType = fns.NoiseType.Perlin bumps.frequency = freq print('FastNoiseSIMD maximum supported SIMD instruction level: {}'.format( fns.extension.SIMD_LEVEL)) # Generate an empty-array of 3D cartesian coordinates. You can use NumPy # arrays from other sources but see the warnings in `Noise.genFromCoords()` coords = fns.empty_aligned((3, meridian.size)) print('== coords.shape: ', coords.shape) print('== parallel.shape: ', parallel.shape) # Fill coords with Cartesian coordinates in 3D # (Note that normally zenith starts at 0.0 rad, whereas we want the equator to be # 0.0 rad, so we swap cos/sin for the `parallel` axis) coords[0, :meridian.size] = radius * np.sin(parallel) # Z
print("Generated {} coords in {:.2e} s".format(maskLen, t1 - t0)) print("Generated noise for {} coords with {} workers in {:.3e} s".format( maskLen, noise.numWorkers, t2 - t1)) print(" {:.1f} ns/pixel".format(1e9 * (t2 - t1) / maskLen)) return pmap # Let's set the view-parallel so we can see the top of the sphere p0 = np.pi - 0.3 # the view-meridian isn't so important, but if you wanted to rotate the # view, this is how you do it. l0 = 0.0 # Now create a Noise object and populate it with intelligent values. How to # come up with 'intelligent' values is left as an exercise for the reader. gasy = fns.Noise(numWorkers=N_thread) gasy.frequency = 1.8 gasy.axesScales = (1.0, 0.06, 0.06) gasy.fractal.octaves = 5 gasy.fractal.lacunarity = 1.0 gasy.fractal.gain = 0.33 gasy.perturb.perturbType = fns.PerturbType.GradientFractal gasy.perturb.amp = 0.5 gasy.perturb.frequency = 1.2 gasy.perturb.octaves = 5 gasy.perturb.lacunarity = 2.5 gasy.perturb.gain = 0.5 gasy_map = orthoProject(gasy, tile2=1024, p0=p0, l0=l0)
def __init__(self, **kwargs): self.noise = OpenSimplex(**kwargs) self.fast_noise = fns.Noise()
import numpy as np import numpy.testing as npt import pyfastnoisesimd as fns noise = fns.Noise() noise.numWorkers = 4 grid_origin = noise.genAsGrid(shape=[64, 64, 64], start=[0, 0, 0]) grid_offset = noise.genAsGrid(shape=[64, 64, 64], start=[50, 50, 50]) try: npt.assert_array_almost_equal(grid_origin, grid_offset) raise ValueError( 'Arrays are equal, that means `start` parameter is not working') except AssertionError: print('Issue 17 is ok')
import numpy as np import pyfastnoisesimd as fns # Num workers does not seem to matter. # It only seems to be an issue if the middle dimension is not divisible # by the SIMD length? n = fns.Noise(numWorkers=1) shape = [27, 127, 1] for I in range(10): # print(I) res = n.genAsGrid(shape) print('Finished successfully')
import numpy as np import pyfastnoisesimd as fns import time import numpy.testing as npt print( '**Note that if you have Hyperthreading the optimum thread count is the number of physical cores.**' ) N_thread = fns.num_virtual_cores() shape = [N_thread * 2, 1024, 1024] print('Array shape: {}'.format(shape)) # Plot cellular noise with a gradient perturbation cellular = fns.Noise(numWorkers=1) print('SIMD level supported: {}'.format(fns.extension.SIMD_LEVEL)) # The Noise class uses properties to map to the FastNoiseSIMD library Set<...> functions cellular.seed = 42 cellular.noiseType = fns.NoiseType.Cellular cellular.frequency = 0.005 cellular.axesScales = [shape[-1] / shape[0], 1.0, 1.0] cellular.cell.returnType = fns.CellularReturnType.Distance cellular.cell.distanceFunc = fns.CellularDistanceFunction.Euclidean cellular.cell.noiseLookupType = fns.NoiseType.Simplex cellular.cell.lookupFrequency = 0.2 cellular.cell.jitter = 0.5 cellular.cell.distanceIndices = (0, 1) cellular.fractal.octaves = 4
def augmentDepth(depth, obj_mask, mask_ori): resY, resX = depth.shape drawKern = [3, 5, 7] freqKern = np.bincount(drawKern) kShadow = np.random.choice(np.arange(len(freqKern)), 1, p=freqKern / len(drawKern), replace=False) kShadow.astype(int) shadowClK = kShadow[0] kMed = np.random.choice(np.arange(len(freqKern)), 1, p=freqKern / len(drawKern), replace=False) kMed.astype(int) shadowMK = kMed[0] kBlur = np.random.choice(np.arange(len(freqKern)), 1, p=freqKern / len(drawKern), replace=False) kBlur.astype(int) blurK = kBlur[0] blurS = random.uniform(0.0, 1.5) # mask rendering failed for first rendered dataset # erode and blur mask to get more realistic appearance #partmask = mask_ori #partmask = partmask.astype(np.float32) #mask = partmask > (np.median(partmask) * 0.4) #partmask = np.where(mask_ori > 1, 255.0, 0.0) partmask = np.where(mask_ori > 0, 255.0, 0.0) #aug_dep = partmask.astype(np.uint8) #cv2.imwrite('/home/stefan/mask.png', aug_dep) # apply shadow kernel = np.ones((shadowClK, shadowClK)) partmask = cv2.morphologyEx(partmask, cv2.MORPH_OPEN, kernel) partmask = signal.medfilt2d(partmask, kernel_size=shadowMK) partmask = partmask.astype(np.uint8) mask = partmask > 0 depth = np.where(mask, depth, 0.0) depthFinal = cv2.resize(depth, None, fx=1 / 2, fy=1 / 2) res = (((depthFinal / 1000.0) * 1.41421356)**2) depthFinal = cv2.GaussianBlur(depthFinal, (blurK, blurK), blurS, blurS) # quantify to depth resolution and apply gaussian dNonVar = np.divide(depthFinal, res, out=np.zeros_like(depthFinal), where=res != 0) dNonVar = np.round(dNonVar) dNonVar = np.multiply(dNonVar, res) noise = np.multiply(dNonVar, random.uniform(0.002, 0.004)) # empirically determined depthFinal = np.random.normal(loc=dNonVar, scale=noise, size=dNonVar.shape) depth = cv2.resize(depthFinal, (resX, resY)) # fast perlin noise seed = np.random.randint(2**31) N_threads = 4 perlin = fns.Noise(seed=seed, numWorkers=N_threads) drawFreq = random.uniform(0.05, 0.2) # 0.05 - 0.2 #drawFreq = 0.5 perlin.frequency = drawFreq perlin.noiseType = fns.NoiseType.SimplexFractal perlin.fractal.fractalType = fns.FractalType.FBM drawOct = [4, 8] freqOct = np.bincount(drawOct) rndOct = np.random.choice(np.arange(len(freqOct)), 1, p=freqOct / len(drawOct), replace=False) #rndOct = 8 perlin.fractal.octaves = rndOct perlin.fractal.lacunarity = 2.1 perlin.fractal.gain = 0.45 perlin.perturb.perturbType = fns.PerturbType.NoPerturb noiseX = np.random.uniform(0.001, 0.01, resX * resY) # 0.001, 0.01 noiseY = np.random.uniform(0.001, 0.01, resX * resY) # 0.0001 - 0.1 noiseZ = np.random.uniform(0.01, 0.1, resX * resY) # 0.01 - 0.1 Wxy = np.random.randint(1, 5) # 1 - 5 Wz = np.random.uniform(0.0001, 0.004) #0.0001 - 0.004 X, Y = np.meshgrid(np.arange(resX), np.arange(resY)) coords0 = fns.empty_coords(resX * resY) coords1 = fns.empty_coords(resX * resY) coords2 = fns.empty_coords(resX * resY) coords0[0, :] = noiseX.ravel() coords0[1, :] = Y.ravel() coords0[2, :] = X.ravel() VecF0 = perlin.genFromCoords(coords0) VecF0 = VecF0.reshape((resY, resX)) coords1[0, :] = noiseY.ravel() coords1[1, :] = Y.ravel() coords1[2, :] = X.ravel() VecF1 = perlin.genFromCoords(coords1) VecF1 = VecF1.reshape((resY, resX)) coords2[0, :] = noiseZ.ravel() coords2[1, :] = Y.ravel() coords2[2, :] = X.ravel() VecF2 = perlin.genFromCoords(coords2) VecF2 = VecF2.reshape((resY, resX)) # vanilla # fx = x + Wxy * VecF0 # fy = y + Wxy * VecF1 # fx = np.where(fx < 0, 0, fx) # fx = np.where(fx >= resX, resX - 1, fx) # fy = np.where(fy < 0, 0, fy) # fy = np.where(fy >= resY, resY - 1, fy) # fx = fx.astype(dtype=np.uint16) # fy = fy.astype(dtype=np.uint16) # Dis = depth[fy, fx] + Wz * VecF2 # depth = np.where(Dis > 0, Dis, 0.0) x = np.arange(resX, dtype=np.uint16) x = x[np.newaxis, :].repeat(resY, axis=0) y = np.arange(resY, dtype=np.uint16) y = y[:, np.newaxis].repeat(resX, axis=1) Wxy_scaled = depth * 0.001 * Wxy Wz_scaled = depth * 0.001 * Wz # scale with depth fx = x + Wxy_scaled * VecF0 fy = y + Wxy_scaled * VecF1 fx = np.where(fx < 0, 0, fx) fx = np.where(fx >= resX, resX - 1, fx) fy = np.where(fy < 0, 0, fy) fy = np.where(fy >= resY, resY - 1, fy) fx = fx.astype(dtype=np.uint16) fy = fy.astype(dtype=np.uint16) Dis = depth[fy, fx] + Wz_scaled * VecF2 depth = np.where(Dis > 0, Dis, 0.0) return depth
def grid_2d(self, size=CHUNK2, numWorkers=1): noise = fns.Noise(seed=None, numWorkers=numWorkers) # Test 2D result = noise.genAsGrid(shape=[size,size]) assert(result.shape == (size,size))
def grid_1d(self, size=CHUNK, numWorkers=1): # Test 1D noise = fns.Noise(seed=None, numWorkers=numWorkers) result = noise.genAsGrid(shape=size) assert(result.shape == (size,))