# Best way to sample noise

• On 15/05/2014 at 01:47, xxxxxxxx wrote:

What is the best way to sample noise (2D or 3D)?
E.g. I have NOISE_NOISE as noise.
What is the width and height of the noise.
What is the size of equal colored planes?

Which setting to use when sampling. For x in range(300) and then?
r = p.Noise(noisetype, False, c4d.Vector(x, x, x))

Doing so, I do get various values, but I cannot link them to a point on the noise map.
Also, when using noisetype = c4d.NOISE_NONE I get only 0.

• On 15/05/2014 at 04:30, xxxxxxxx wrote:

There is a verry nice example in the docs.

``````
width = 300
height = 300
noisetype = c4d.NOISE_MOD_NOISE
bmp =  bitmaps.BaseBitmap()
bmp.Init(width, height, 24)

# Create and initialize the noise instance
p = C4DNoise(1234)
p.InitFbm(21, 2.1, 0.5)

rw = float(width-1)
rh = float(height-1)

# Iterate through the bitmap and set the noise value per pixel
for x in xrange(width) :
for y in xrange(height) :
r = p.Noise(noisetype, False, c4d.Vector(x/rw, y/rh, 0) * 7.0, octaves=5)
o = int(255.0*r)
if o < 0: o = 0
elif o > 255: o = 255

bmp[x, y] = (o, o, o)

bitmaps.ShowBitmap(bmp)

``````

width and hight depends on the bitmap size
like
bmp =  bitmaps.BaseBitmap()
bmp.Init(width, height, 24)

the size of colored planes is in this case:
r = p.Noise(noisetype, False, c4d.Vector(x/rw, y/rh, 0) * 7.0, octaves=0)
size = width/7.0

I did not understand

link them to a point on the noise map

Martin

• On 15/05/2014 at 05:13, xxxxxxxx wrote:

If you want to read a noise
It´s always relativ to the given global scale and not a bitmap size.

``````
mat=doc.GetFirstMaterial()
print size
print glbsize
print glbsize*5/size[0], "the size of colored planes relativ to the global scale"
``````

• On 15/05/2014 at 06:02, xxxxxxxx wrote:

Yes, I saw the example, but I want to deform an object using a noise.
How to map the noise to the object?

• On 15/05/2014 at 08:07, xxxxxxxx wrote:

That's a question of how you want to map the noise to an object. For instance, you could use
the UV position of its points to pass to the noise function and move the point along its vertex
normal.

-Niklas

• On 16/05/2014 at 01:17, xxxxxxxx wrote:

Ok, so use the UV coordinates to get the noise value?
r = p.Noise(noisetype, False, UV coordinates )

Why should you move the point along it vertex normal.
Isn't it enough to just get the noise for UV points and use that value to for example size the corresponding polygon?

• On 16/05/2014 at 03:42, xxxxxxxx wrote:

Thanks Niklas,

could you please tell us how to get the specific color vlaue of the calculated uvw position?.
I´m at this point right now:

``````
import c4d

def main() :
mat= doc.GetFirstMaterial()
print noisetype

#Get tag
UVWTag= op.GetTag(c4d.Tuvw)
print UVWTag

#just test it for one polygon
for i in xrange(UVWTag.GetDataCount()-1,UVWTag.GetDataCount()) :
uvwdict= UVWTag.GetSlow(i)
#corresponding Polygon
corres= op.GetPolygon(i)
#select for testing
Polygons= op.GetPolygonS()
Polygons.Select(i)
print corres

p1= op.GetPoint(corres.a)
p2= op.GetPoint(corres.b)
p3= op.GetPoint(corres.c)
p4= op.GetPoint(corres.d)

#calculate the vertexnormals of the corresponding vertices
dif_p1= p1- p2
nor_p1= p1.Cross(dif_p1).GetNormalized()
print nor_p1,"nor_p1"
dif_p2= p2- p3
nor_p2= p2.Cross(dif_p2).GetNormalized()
print nor_p2,"nor_p2"
#if tris
if corres.d== corres.c:
dif_p3= p3- p1
nor_p3= p3.Cross(dif_p3).GetNormalized()
print nor_p3,"nor_p3"
else:
dif_p3= p3- p4
nor_p3= p3.Cross(dif_p3).GetNormalized()
print nor_p3,"nor_p3"
dif_p4= p4- p1
nor_p4= p4.Cross(dif_p4).GetNormalized()
print nor_p4,"nor_p4"

#Values of UVW_Coordinates
print uvwdict["a"],"a"
print uvwdict["b"],"b"
print uvwdict["c"],"c"
print uvwdict["d"],"d"
``````

Martin

• On 30/05/2014 at 01:59, xxxxxxxx wrote:

I´m not sure if there is a better solution to handle noise sampling, but
with channel data from the render module you can read the overall shader information.

And of course, sorry for the twaddle I posted before.
A vertex normal could be calculated like this:

Cheers
Martin

``````
import c4d

from c4d import utils,Vector
from c4d.utils import SendModelingCommand

def main() :

if op== None: return
#convert
clone= SendModelingCommand(command= c4d.MCOMMAND_CURRENTSTATETOOBJECT, list= [op.GetClone()], doc= doc)
if not clone : return
obj= clone[0]

#optimize
opti= c4d.BaseContainer()
opti[c4d.MDATA_OPTIMIZE_POINTS] = True
SendModelingCommand(command= c4d.MCOMMAND_OPTIMIZE, list= [obj], bc= opti, doc= doc)

#triangulate the clone to ensure correct results with nonplanar quads
SendModelingCommand(command= c4d.MCOMMAND_TRIANGULATE, list= [obj], doc= doc)

#init neighbor class and get obj properties
PointCount= obj.GetPointCount()
PolyCount= obj.GetPolygonCount()
Matr= obj.GetMg()
nbr= utils.Neighbor()
nbr.Init(obj)

#set an empty list for the face normals
Face_N= []

#calculate face normals
for i in xrange(PolyCount) :

poly= obj.GetPolygon(i)
p1= obj.GetPoint(poly.a)+Matr.off
p2= obj.GetPoint(poly.b)+Matr.off
p3= obj.GetPoint(poly.c)+Matr.off

dif_p1= p1- p2
dif_p2= p2- p3
normal= dif_p1.Cross(dif_p2).GetNormalized()

Face_N.append((normal,i))

#for testing facenormals, calculate a matrix, test it with small cubes
mid_p= (p1+p2+p3)/3
off= mid_p
v3= normal
if abs(normal*Vector(0,1,0))<0.9999:
v2= normal.Cross(Vector(0,1,0)).GetNormalized()
else:
v2= normal.Cross(Vector(1,0,0)).GetNormalized()

v1= normal.Cross(v2).GetNormalized()

Face_N_Matr= c4d.Matrix(off, v1, v2, v3)
cube= c4d.BaseObject(c4d.Ocube)
cube.SetMg(Face_N_Matr)
cube.SetAbsScale(c4d.Vector(0.1,0.1,0.1))
doc.InsertObject(cube)

#set an empty vertex normal vector
Vert_N= Vector(0,0,0)

#for every point, average the neighboring facenormals to get the vertexnormal
for i in xrange(PointCount) :
Polys_P= nbr.GetPointPolys(i)

for p in Polys_P:
Vert_N+= Face_N[p][0]
print Face_N[p][0]
average= Vert_N/len(Polys_P)

#reset the vertex normal vector for the next point
Vert_N= Vector(0,0,0)

#calculate a matrix, test it with small cubes
off= obj.GetPoint(i)
v3= average
if abs(average*Vector(0,1,0))<0.9999:
v2= average.Cross(Vector(0,1,0)).GetNormalized()
else:
v2= average.Cross(Vector(1,0,0)).GetNormalized()

v1= average.Cross(v2).GetNormalized()

Vert_M= c4d.Matrix(off+Matr.off, v1, v2, v3)
cube= c4d.BaseObject(c4d.Ocube)
cube.SetMg(Vert_M)
cube.SetAbsScale(c4d.Vector(0.1,0.1,0.1))
doc.InsertObject(cube)