Esempio n. 1
0
def save_vertex_position(target):
    # active when 1, or close by 0
    addProps(target, 'vic_active', True)
    # no nagetive number, the higher value the more detail
    addProps(target, 'vic_detail', 1.0)
    # 0.0~1.0 will be best!
    addProps(target, 'vic_effective', 1.0)
    # using vertex color
    addProps(target, 'vic_using_vertex_color_map', False)
    # using vertex color for effective value
    addProps(target, 'vic_effective_by_vertex_color', 'Col')

    detail = target['vic_detail']
    map_vertex_color = target['vic_effective_by_vertex_color']

    addProps(target, 'vic_init_vertex_position',
             [v.co.copy() for v in target.data.vertices], True)
    addProps(target, 'vic_proxy_vertex_position',
             [target.matrix_world @ v.co.copy() for v in target.data.vertices],
             True)

    if map_vertex_color in target.data.vertex_colors:
        collect_color = collectVertexColor(
            target.data, target.data.vertex_colors[map_vertex_color])
        map_vertexs = [avg_col(v).hsv[2] for k, v in collect_color.items()]
        addProps(target, 'vic_force_for_each_vertex_by_vertex_color',
                 map_vertexs, True)
    else:
        addProps(target, 'vic_force_for_each_vertex_by_vertex_color',
                 [.2 for v in target.data.vertices], True)
    addProps(target, 'vic_force_for_each_vertex',
             [((noise.noise(Vector(v) * detail)) + 1) / 2
              for v in target['vic_init_vertex_position']], True)
Esempio n. 2
0
    def iter_grow(self, param):

        # container for points on contour
        contour_points = []

        # create empty bmesh to store vertices of circle
        bm = bmesh.new()

        # divide circle in segments
        circle_segments = np.linspace(0, 2 * np.pi, param["n_segments"])

        for segment in circle_segments:

            # generate point on a cricle as argument to perlin noise
            xoff = np.interp(np.cos(segment), [-1, 1], param["noise_range"])
            yoff = np.interp(np.sin(segment), [-1, 1], param["noise_range"])
            zoff = param["zoff"]

            pos = np.array([xoff, yoff, zoff])

            # generate noise value
            noise_val = noise.noise(pos)  # NB: noise elem [-1,1]
            noise_val = np.interp(noise_val, [-1, 1], param["noise_amp"])

            # add to radius
            radius_curr = param["radius"] + noise_val

            # create circle point on nosy radius from center
            x = self.center[0] + radius_curr * np.cos(segment)
            y = self.center[1] + radius_curr * np.sin(segment)
            z = self.center[2]

            # add  point to bmesh and container
            bm.verts.new(np.array([x, y, z]))
            contour_points.append([x, y, z])

        # add faces
        bm.faces.new(bm.verts)

        # add a new mesh data
        layer_mesh_data = bpy.data.meshes.new(param["layer_name"] + "_data")

        # add a new empty mesh object using the mesh data
        layer_mesh_object = bpy.data.objects.new(
            param["layer_name"] + "_object", layer_mesh_data)

        # make the bmesh the object's mesh
        # transfer bmesh data do mesh data which is connected to empty mesh object
        bm.to_mesh(layer_mesh_data)
        bm.free()

        # add color
        material = bpy.data.materials.new(param["layer_name"] + "_material")
        material.diffuse_color = param["color"]
        layer_mesh_object.active_material = material

        # return object, data for object can be extracted via eden_layer_mesh_object.data
        return layer_mesh_object, contour_points
def export_ter(filepath):
    start_time = time.process_time()
    filename = filepath + '.ter'
    # start to set all the tags and values needed for the .ter file
    ter_header = 'TERRAGENTERRAIN '
    size_tag = 'SIZE'
    size = 64
    scal_tag = 'SCAL'
    scalx = 30.0
    scaly = 30.0
    scalz = 30.0
    altw_tag = 'ALTW'
    HeightScale = 80
    BaseHeight = 0
    totalpoints = (size + 1) * (size + 1)
    # set seed for noise.random()
    noise.seed_set(123)
    # values are packed as short (i.e = integers max 32767) so we map them in the right range
    values = []
    # values = [int(map_range(noise.random(), 0.0, 1.0, 0.0, 32767.0)) for i in range(totalpoints)]
    for x in range(size + 1):
        for y in range(size + 1):
            vec = Vector((x, y, 0.0))
            out = int(map_range(noise.noise(vec, 3), -1.0, 1.0, 0.0, 32767.0))
            values.append(out)
    print(values)
    eof_tag = 'EOF'  # end of file tag

    with open(filename, "wb") as file:
        # write the header
        file.write(ter_header.encode('ascii'))
        # write the size of the terrain
        file.write(size_tag.encode('ascii'))
        file.write(struct.pack('h', size))
        # padding byte needed after SIZE
        file.write(struct.pack('xx'))  # padding -> b'\x00\x00'
        # write the scale tag = SCAL
        file.write(scal_tag.encode('ascii'))
        # pack the scaling values as floats
        file.write(struct.pack('fff', scalx, scaly, scalz))
        # write the altitude ALTW tag
        file.write(altw_tag.encode('ascii'))
        # pack heightScale and baseHeight
        file.write(struct.pack('h', HeightScale))
        file.write(struct.pack('h', BaseHeight))
        # pack as shorts the elvetions values
        for v in values:
            file.write(struct.pack('h', v))
        # EOF = end of file
        file.write(eof_tag.encode('ascii'))
        file.close()

    print('Terrain exported in %.4f sec.' % (time.process_time() - start_time))
Esempio n. 4
0
        def grow(self, n_iter):

            for i in range(n_iter):

                vertex_idx = np.random.choice(len(self.vertices), 1)[0]

                pos = np.array([np.cos(self.vertices[vertex_idx].phi), np.sin(self.vertices[vertex_idx].phi), np.pi])

                noise_val = noise.noise(pos)

                self.vertices[vertex_idx].r += np.abs(noise_val)

            self.construct_mesh(self.vertices)
Esempio n. 5
0
    def turbulence(vec,oct,freq,rseed):
        #we choose a noise type
        noise_type = noise.types.STDPERLIN
        #set the seed but won't work with blender noise
        noise.seed_set(rseed)
        sndata = []
        value = 0.0

        for o in range(oct):
           
            freq *= 2.0
            vVec = Vector(vec)
            multVec = vVec * freq
            #print(multVec)
            #print(f)
            value += abs(noise.noise(multVec,noise_type))/freq 
            #value += (noise.noise(multVec,noise_type))/f
            #value += amplitude*(noise.noise(multVec,noise_type))
            
        return value
Esempio n. 6
0
                            SvSetSocketAnyType, SvGetSocketAnyType)

'''
using slice [:] to generate 3-tuple instead of .to_tuple()
because it tests slightly faster on larger data.
'''


scalar_out = {
    "DOT":          (lambda u, v: Vector(u).dot(v), 2),
    "DISTANCE":     (lambda u, v: (Vector(u) - Vector(v)).length, 2),
    "ANGLE RAD":    (lambda u, v: Vector(u).angle(v, 0), 2),
    "ANGLE DEG":    (lambda u, v: degrees(Vector(u).angle(v, 0)), 2),

    "LEN":          (lambda u: Vector(u).length, 1),
    "NOISE-S":      (lambda u: noise(Vector(u)), 1),
    "CELL-S":       (lambda u: cell(Vector(u)), 1)
}

vector_out = {
    "CROSS":        (lambda u, v: Vector(u).cross(v)[:], 2),
    "ADD":          (lambda u, v: (u[0]+v[0], u[1]+v[1], u[2]+v[2]), 2),
    "SUB":          (lambda u, v: (u[0]-v[0], u[1]-v[1], u[2]-v[2]), 2),
    "REFLECT":      (lambda u, v: Vector(u).reflect(v)[:], 2),
    "PROJECT":      (lambda u, v: Vector(u).project(v)[:], 2),
    "SCALAR":       (lambda u, s: (Vector(u) * s)[:], 2),
    "1/SCALAR":     (lambda u, s: (Vector(u) * (1 / s))[:], 2),
    "ROUND":        (lambda u, s: Vector(u).to_tuple(s), 2),

    "NORMALIZE":    (lambda u: Vector(u).normalized()[:], 1),
    "NEG":          (lambda u: (-Vector(u))[:], 1),
Esempio n. 7
0
def create_perlin_points(num_points, x_scale=scale, z_scale=z_scale):
    return [
        Vector((i * x_scale, 0, z_scale * noise(Vector((i * x_scale, 0, 0)))))
        for i in range(N)
    ]
Esempio n. 8
0
def Effect_Basis_Function(coords, type, bias):
    bias = int(bias)
    type = int(type)
    x, y, z = coords
    iscale = 1.0
    offset = 0.0

    ## gradient:
    if type == 1:
        effect = offset + iscale * (Bias_Types[bias](x + y))
    ## waves / bumps:
    elif type == 2:
        effect = offset + iscale * 0.5 * (Bias_Types[bias]
                                          (x * pi) + Bias_Types[bias](y * pi))
    ## zigzag:
    elif type == 3:
        effect = offset + iscale * Bias_Types[bias](offset + iscale *
                                                    sin(x * pi + sin(y * pi)))
    ## wavy:
    elif type == 4:
        effect = offset + iscale * (Bias_Types[bias](
            cos(x) + sin(y) + cos(x * 2 + y * 2) - sin(-x * 4 + y * 4)))
    ## sine bump:
    elif type == 5:
        effect = offset + iscale * 1 - Bias_Types[bias](
            (sin(x * pi) + sin(y * pi)))
    ## dots:
    elif type == 6:
        effect = offset + iscale * (Bias_Types[bias](x * pi * 2) *
                                    Bias_Types[bias](y * pi * 2)) - 0.5
    ## rings:
    elif type == 7:
        effect = offset + iscale * (Bias_Types[bias](1.0 - (x * x + y * y)))
    ## spiral:
    elif type == 8:
        effect = offset + iscale * Bias_Types[bias](
            (x * sin(x * x + y * y) + y * cos(x * x + y * y)) /
            (x**2 + y**2 + 0.5)) * 2
    ## square / piramide:
    elif type == 9:
        effect = offset + iscale * Bias_Types[bias](1.0 - sqrt(
            (x * x)**10 + (y * y)**10)**0.1)
    ## blocks:
    elif type == 10:
        effect = (0.5 -
                  max(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi)))
        if effect > 0.0:
            effect = 1.0
        effect = offset + iscale * effect
    ## grid:
    elif type == 11:
        effect = (0.025 -
                  min(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi)))
        if effect > 0.0:
            effect = 1.0
        effect = offset + iscale * effect
    ## tech:
    elif type == 12:
        a = max(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi))
        b = max(Bias_Types[bias](x * pi * 2 + 2),
                Bias_Types[bias](y * pi * 2 + 2))
        effect = min(Bias_Types[bias](a), Bias_Types[bias](b)) * 3.0 - 2.0
        if effect > 0.5:
            effect = 1.0
        effect = offset + iscale * effect
    ## crackle:
    elif type == 13:
        t = turbulence((x, y, 0), 6, 0, noise_basis="BLENDER") * 0.25
        effect = variable_lacunarity((x, y, t),
                                     0.25,
                                     noise_type2='VORONOI_CRACKLE')
        if effect > 0.5:
            effect = 0.5
        effect = offset + iscale * effect
    ## sparse cracks noise:
    elif type == 14:
        effect = 2.5 * abs(noise(
            (x, y, 0), noise_basis="PERLIN_ORIGINAL")) - 0.1
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * (effect * 2.5)
    ## shattered rock noise:
    elif type == 15:
        effect = 0.5 + noise((x, y, 0), noise_basis="VORONOI_F2F1")
        if effect > 0.75:
            effect = 0.75
        effect = offset + iscale * effect
    ## lunar noise:
    elif type == 16:
        effect = 0.25 + 1.5 * voronoi(
            (x, y, 0), distance_metric='DISTANCE_SQUARED')[0][0]
        if effect > 0.5:
            effect = 0.5
        effect = offset + iscale * effect * 2
    ## cosine noise:
    elif type == 17:
        effect = cos(5 * noise((x, y, 0), noise_basis="BLENDER"))
        effect = offset + iscale * (effect * 0.5)
    ## spikey noise:
    elif type == 18:
        n = 0.5 + 0.5 * turbulence(
            (x * 5, y * 5, 0), 8, 0, noise_basis="BLENDER")
        effect = ((n * n)**5)
        effect = offset + iscale * effect
    ## stone noise:
    elif type == 19:
        effect = offset + iscale * (noise(
            (x * 2, y * 2, 0), noise_basis="BLENDER") * 1.5 - 0.75)
    ## Flat Turb:
    elif type == 20:
        t = turbulence((x, y, 0), 6, 0, noise_basis="BLENDER")
        effect = t * 2.0
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * effect
    ## Flat Voronoi:
    elif type == 21:
        t = 1 - voronoi((x, y, 0), distance_metric='DISTANCE_SQUARED')[0][0]
        effect = t * 2 - 1.5
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * effect
    else:
        effect = 0.0

    if effect < 0.0:
        effect = 0.0

    return effect
Esempio n. 9
0
    def execute(self, context):
        seed(self.seed)
        bpy.ops.mesh.primitive_grid_add(x_subdivisions=self.xsub,
                                        y_subdivisions=self.ysub,
                                        enter_editmode=True)
        # TODO make spacing of horizontal rows somewhat variable
        obj = bpy.context.edit_object
        me = obj.data
        bm = bmesh.from_edit_mesh(me)
        bm.faces.active = None

        for i in range(self.nv):
            verts = get_internal_verts(bm)
            if len(verts):
                vert = choice(verts)
                bmesh.ops.dissolve_faces(bm,
                                         faces=vert.link_faces,
                                         use_verts=False)

        for i in range(self.ne):
            edges = get_internal_edges(bm)
            if len(edges):
                edge = choice(edges)
                bmesh.ops.dissolve_faces(bm,
                                         faces=edge.link_faces,
                                         use_verts=False)

        for edge in get_movable_edges(bm):
            x = (random() * 2 - 1) * self.randomedge * (2.0 / self.xsub) * 0.5
            edge.verts[0].co.x += x
            edge.verts[1].co.x += x
        for vert in bm.verts:
            x = (noise(vert.co) * 2 - 1) * self.randomvert * (2.0 /
                                                              self.xsub) * 0.5
            y = (noise(vert.co + Vector((11.1, 13.12, 17.14))) * 2 -
                 1) * self.randomvert * (2.0 / self.ysub) * 0.5
            vert.co.x += x
            vert.co.y += y

        extruded_faces = bmesh.ops.extrude_discrete_faces(
            bm, faces=bm.faces)['faces']
        bm.verts.index_update()
        for face in extruded_faces:
            vindices = [v.index for v in face.verts]
            for vert in face.verts:
                for e in vert.link_edges:
                    overt = e.other_vert(vert)
                    if overt.index not in vindices:
                        overt.tag = True
        bmesh.ops.delete(bm, geom=[v for v in bm.verts if v.tag], context=1)

        for face in bm.faces:
            z = (random() * 2 - 1) * self.zrandom
            for vert in face.verts:
                vert.co.z += z

        bmesh.update_edit_mesh(me, True)
        bpy.ops.object.editmode_toggle()
        obj.scale.x = self.xsub / 10.0
        obj.scale.y = self.ysub / 10.0

        # add random uv and vcolor
        me.uv_textures.new()
        uv_layer = me.uv_layers.active.data
        vertex_colors = me.vertex_colors.new().data
        for poly in me.polygons:
            offset = Vector(
                (random(), random(), 0)) if obj.randomuv else Vector((0, 0, 0))
            color = [random(), random(), random()]
            for loop_index in range(poly.loop_start,
                                    poly.loop_start + poly.loop_total):
                coords = me.vertices[me.loops[loop_index].vertex_index].co
                uv_layer[loop_index].uv = (coords + offset).xy
                vertex_colors[loop_index].color = color

        bpy.ops.object.modifier_add(type='SOLIDIFY')
        bpy.context.object.modifiers["Solidify"].offset = 1
        bpy.context.object.modifiers["Solidify"].thickness = 0.1
        bpy.ops.object.modifier_add(type='BEVEL')
        bpy.context.object.modifiers["Bevel"].width = 0.01
        bpy.context.object.modifiers["Bevel"].segments = 2

        return {'FINISHED'}
Esempio n. 10
0
import json

cont = logic.getCurrentController()
owner = cont.owner

init_pos = []
detail = owner['detail']

def push_init_pos( add_point ):
    global init_pos
    need_add = True
    for p in init_pos:
        if p[0] == add_point[0] and p[1] == add_point[1] and p[2] == add_point[2]:
            need_add = False
            p[3].append( add_point[3][0] )
    if need_add:
        init_pos.append( add_point )        
        
for mesh_index, mesh in enumerate( owner.meshes, 0 ):
    for m_index in range(len(mesh.materials)):
        for v_index in range(mesh.getVertexArrayLength(m_index)):
            vertex = mesh.getVertex(m_index, v_index)
            push_init_pos( [vertex.x,vertex.y,vertex.z, [[mesh_index, m_index, v_index]]] )
 
force_pos = [ ( noise.noise( Vector([p[0],p[1],p[2]]) * detail ) + 1 ) / 2 for p in init_pos ]
proxy_pos_vec = [ owner.worldTransform * Vector([p[0],p[1],p[2]]) for p in init_pos ]
proxy_pos = [[p[0],p[1],p[2]] for p in proxy_pos_vec ]

owner['init_pos'] = json.dumps( init_pos )   
owner['proxy_pos'] = json.dumps( proxy_pos )   
owner['force_pos'] = json.dumps( force_pos )   
Esempio n. 11
0
def Effect_Basis_Function(coords, type, bias):
    bias = int(bias)
    type = int(type)
    x, y, z = coords
    iscale = 1.0
    offset = 0.0

    ## gradient:
    if type == 1:
        effect = offset + iscale * (Bias_Types[bias](x + y))
    ## waves / bumps:
    elif type == 2:
        effect = offset + iscale * 0.5 * (Bias_Types[bias](x * pi) + Bias_Types[bias](y * pi))
    ## zigzag:
    elif type == 3:
        effect = offset + iscale * Bias_Types[bias](offset + iscale * sin(x * pi + sin(y * pi)))
    ## wavy:
    elif type == 4:
        effect = offset + iscale * (Bias_Types[bias](cos(x) + sin(y) + cos(x * 2 + y * 2) - sin(-x * 4 + y * 4)))
    ## sine bump:
    elif type == 5:
        effect =   offset + iscale * 1 - Bias_Types[bias]((sin(x * pi) + sin(y * pi)))
    ## dots:
    elif type == 6:
        effect = offset + iscale * (Bias_Types[bias](x * pi * 2) * Bias_Types[bias](y * pi * 2)) - 0.5
    ## rings:
    elif type == 7:
        effect = offset + iscale * (Bias_Types[bias ](1.0 - (x * x + y * y)))
    ## spiral:
    elif type == 8:
        effect = offset + iscale * Bias_Types[bias]( (x * sin(x * x + y * y) + y * cos(x * x + y * y)) / (x**2 + y**2 + 0.5)) * 2
    ## square / piramide:
    elif type == 9:
        effect = offset + iscale * Bias_Types[bias](1.0 - sqrt((x * x)**10 + (y * y)**10)**0.1)
    ## blocks:
    elif type == 10:
        effect = (0.5 - max(Bias_Types[bias](x * pi) , Bias_Types[bias](y * pi)))
        if effect > 0.0:
            effect = 1.0
        effect = offset + iscale * effect
    ## grid:
    elif type == 11:
        effect = (0.025 - min(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi)))
        if effect > 0.0:
            effect = 1.0
        effect = offset + iscale * effect
    ## tech:
    elif type == 12:
        a = max(Bias_Types[bias](x * pi), Bias_Types[bias](y * pi))
        b = max(Bias_Types[bias](x * pi * 2 + 2), Bias_Types[bias](y * pi * 2 + 2))
        effect = min(Bias_Types[bias](a), Bias_Types[bias](b)) * 3.0 - 2.0
        if effect > 0.5:
            effect = 1.0
        effect = offset + iscale * effect
    ## crackle:
    elif type == 13:
        t = turbulence((x, y, 0), 6, 0, 0) * 0.25
        effect = variable_lacunarity((x, y, t), 0.25, 0, 8)
        if effect > 0.5:
            effect = 0.5
        effect = offset + iscale * effect
    ## sparse cracks noise:
    elif type == 14:
        effect = 2.5 * abs(noise((x, y, 0), 1)) - 0.1
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * (effect * 2.5)
    ## shattered rock noise:
    elif type == 15:
        effect = 0.5 + noise((x, y, 0), 7)
        if effect > 0.75:
            effect = 0.75
        effect = offset + iscale * effect
    ## lunar noise:
    elif type == 16:
        effect = 0.25 + 1.5 * voronoi((x, y, 0), 1)[0][0]
        if effect > 0.5:
            effect = 0.5
        effect = offset + iscale * effect * 2
    ## cosine noise:
    elif type == 17:
        effect = cos(5 * noise((x, y, 0), 0))
        effect = offset + iscale * (effect * 0.5)
    ## spikey noise:
    elif type == 18:
        n = 0.5 + 0.5 * turbulence((x * 5, y * 5, 0), 8, 0, 0)
        effect = ((n * n)**5)
        effect = offset + iscale * effect
    ## stone noise:
    elif type == 19:
        effect = offset + iscale * (noise((x * 2, y * 2, 0), 0) * 1.5 - 0.75)
    ## Flat Turb:
    elif type == 20:
        t = turbulence((x, y, 0), 6, 0, 0)
        effect = t * 2.0
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * effect
    ## Flat Voronoi:
    elif type == 21:
        t = 1 - voronoi((x, y, 0), 1)[0][0]
        effect = t * 2 - 1.5
        if effect > 0.25:
            effect = 0.25
        effect = offset + iscale * effect
    else:
        effect = 0.0

    if effect < 0.0:
        effect = 0.0

    return effect
Esempio n. 12
0
bm = bmesh.new()

# divide circle in segments
circle_segments = np.linspace(0, 2 * np.pi, 50)

for segment in circle_segments:

    # generate point on a cricle as argument to perlin noise
    xoff = np.interp(np.cos(segment), [-1, 1], [0.1, 0.9])
    yoff = np.interp(np.sin(segment), [-1, 1], [0.1, 0.9])
    zoff = 4.12

    pos = np.array([xoff, yoff, zoff])

    # generate noise value
    noise_val = noise.noise(pos)  # NB: noise elem [-1,1]

    # add to radius
    radius_curr_x = 10 + noise_val
    radius_curr_y = 10 + noise_val

    # create circle point on nosy radius from center
    x = 0 + radius_curr_x * np.cos(segment)
    y = 0 + radius_curr_y * np.sin(segment)
    z = 0

    # add  point to bmesh
    bm.verts.new(np.array([x, y, z]))

bm.faces.new(bm.verts)
"""
Esempio n. 13
0
                            SvSetSocketAnyType, SvGetSocketAnyType)

'''
using slice [:] to generate 3-tuple instead of .to_tuple()
because it tests slightly faster on larger data.
'''


scalar_out = {
    "DOT":          (lambda u, v: Vector(u).dot(v), 2),
    "DISTANCE":     (lambda u, v: (Vector(u) - Vector(v)).length, 2),
    "ANGLE RAD":    (lambda u, v: Vector(u).angle(v, 0), 2),
    "ANGLE DEG":    (lambda u, v: degrees(Vector(u).angle(v, 0)), 2),

    "LEN":          (lambda u: Vector(u).length, 1),
    "NOISE-S":      (lambda u: noise(Vector(u)), 1),
    "CELL-S":       (lambda u: cell(Vector(u)), 1)
}

vector_out = {
    "CROSS":        (lambda u, v: Vector(u).cross(v)[:], 2),
    "ADD":          (lambda u, v: (u[0]+v[0],u[1]+v[1],u[2]+v[2]), 2),
    "SUB":          (lambda u, v: (u[0]-v[0],u[1]-v[1],u[2]-v[2]), 2),
    "REFLECT":      (lambda u, v: Vector(u).reflect(v)[:], 2),
    "PROJECT":      (lambda u, v: Vector(u).project(v)[:], 2),
    "SCALAR":       (lambda u, s: (Vector(u) * s)[:], 2),
    "1/SCALAR":     (lambda u, s: (Vector(u) * (1 / s))[:], 2),
    "ROUND":        (lambda u, s: Vector(u).to_tuple(s), 2),

    "NORMALIZE":    (lambda u: Vector(u).normalized()[:], 1),
    "NEG":          (lambda u: -Vector(u)[:], 1),
Esempio n. 14
0
import bpy
import numpy as np
from mathutils import noise

# add plane mesh
bpy.ops.mesh.primitive_plane_add()
plane = bpy.context.object
plane.name = 'air_plane'

# select plane
plane = bpy.data.objects['air_plane']

# enter edit mode
bpy.ops.object.mode_set(mode='EDIT')

# subdivide
bpy.ops.mesh.subdivide(number_cuts=10)

# get vertices
bpy.ops.mesh.select_mode(type='VERT')
bpy.ops.mesh.select_all(action='SELECT')
bpy.ops.object.mode_set(mode='OBJECT')  # pazi!!

verts = plane.data.vertices
print("N", len(verts))
for v in verts:
    v.co[2] = noise.noise(v.co)
    def iter_grow(self, param):

        # container for points on contour
        contour_points = []

        # create empty bmesh to store vertices of circle
        bm = bmesh.new()

        # divide circle in segments
        circle_segments = np.linspace(0, 2 * np.pi, param["n_segments"])

        for segment in circle_segments:

            # generate point on a cricle as argument to perlin noise
            xoff = np.interp(np.cos(segment), [-1, 1], param["noise_range"])
            yoff = np.interp(np.sin(segment), [-1, 1], param["noise_range"])
            zoff = param["zoff"]

            pos = np.array([xoff, yoff, zoff])

            # generate noise value
            noise_val = noise.noise(pos)  # NB: noise elem [-1,1]
            #noise_val = np.random.rand()

            # add to radius
            radius_curr_x = param["radius_xy"][0] + noise_val
            radius_curr_y = param["radius_xy"][1] + noise_val

            # create circle point on nosy radius from center
            x = self.center[0] + radius_curr_x * np.cos(segment)
            y = self.center[1] + radius_curr_y * np.sin(segment)
            z = self.center[2]

            # add  point to bmesh and container
            bm.verts.new(np.array([x, y, z]))
            contour_points.append([x, y, z])

        # add faces and extrude
        # https://blender.stackexchange.com/questions/65359/how-to-create-and-extrude-a-bmesh-face

        # think of this new vertices as bottom of the extruded shape
        bottom_face = bm.faces.new(bm.verts)

        # next we create top via extrude operator, note it doesn't move the new face
        # we make our 1 face into a list so it can be accepted to geom
        #top_face = bmesh.ops.extrude_face_region(bm, geom=[bottom_face])

        # here we move all vertices returned by the previous extrusion
        # filter the "geom" list for vertices using list constructor
        #bmesh.ops.translate(bm, vec=param["extrude"], verts=[v for v in top_face["geom"] if isinstance(v,bmesh.types.BMVert)])

        #bm.normal_update()

        # add a new mesh data
        layer_mesh_data = bpy.data.meshes.new(param["layer_name"] + "_data")

        # add a new empty mesh object using the mesh data
        layer_mesh_object = bpy.data.objects.new(
            param["layer_name"] + "_object", layer_mesh_data)

        # make the bmesh the object's mesh
        # transfer bmesh data do mesh data which is connected to empty mesh object
        bm.to_mesh(layer_mesh_data)
        bm.free()

        # add color
        material = bpy.data.materials.new(param["layer_name"] + "_material")
        material.diffuse_color = param["color"]
        layer_mesh_object.active_material = material

        # return object, data for object can be extracted via eden_layer_mesh_object.data
        return layer_mesh_object, contour_points
Esempio n. 16
0
    def __iter_grow(self, param):
        """ Creates one perturbed circle

		Given the parameters, this method is creating one perturbed circle.
		That is it performs one iteration of growth.

		Args:
			param (dict): parameters for creating the perturbed circle.
		
		Yields:
			Blender mesh object: representation of perturbed circle.
			list: contour points.

		"""

        # List of points that will be created on the contour.
        contour_points = []

        # Create empty bmesh to store vertices of circle.
        bm = bmesh.new()

        circle_segments = np.linspace(start=0,
                                      stop=2 * np.pi,
                                      num=param["n_segments"])

        # For every segment in circle create a perturbed vertex.
        for segment in circle_segments:

            xoff = np.interp(x=np.cos(segment),
                             xp=[-1, 1],
                             fp=param["noise_range"])

            yoff = np.interp(x=np.sin(segment),
                             xp=[-1, 1],
                             fp=param["noise_range"])

            zoff = param["zoff"]

            pos = np.array([xoff, yoff, zoff])

            noise_val = noise.noise(pos)  # NB: noise elem [-1,1]
            noise_val = np.interp(x=noise_val,
                                  xp=[-1, 1],
                                  fp=param["noise_amp"])

            radius_curr = param["radius"] + noise_val

            x = self.center[0] + radius_curr * np.cos(segment)
            y = self.center[1] + radius_curr * np.sin(segment)
            z = self.center[2]

            bm.verts.new(np.array([x, y, z]))
            contour_points.append([x, y, z])

        # Create face from existing vertices.
        bm.faces.new(bm.verts)

        # Add a new mesh data.
        layer_mesh_data = bpy.data.meshes.new(param["layer_name"] + "_data")

        # add a new empty mesh object using the mesh data.
        layer_mesh_object = bpy.data.objects.new(
            param["layer_name"] + "_object", layer_mesh_data)

        # Transform bmesh to mesh.
        bm.to_mesh(layer_mesh_data)
        bm.free()

        # Add material and color.
        material = bpy.data.materials.new(param["layer_name"] + "_material")
        material.diffuse_color = param["color"]
        layer_mesh_object.active_material = material

        return layer_mesh_object, contour_points
Esempio n. 17
0
	def execute(self, context):
		seed(self.seed)
		bpy.ops.mesh.primitive_grid_add(x_subdivisions=self.xsub, y_subdivisions=self.ysub, enter_editmode=True)
		# TODO make spacing of horizontal rows somewhat variable
		obj = bpy.context.edit_object
		me = obj.data
		bm = bmesh.from_edit_mesh(me)
		bm.faces.active = None
		
		for i in range(self.nv):
			verts = get_internal_verts(bm)
			if len(verts):
				vert = choice(verts)
				bmesh.ops.dissolve_faces(bm, faces=vert.link_faces, use_verts=False)
				
		for i in range(self.ne):
			edges = get_internal_edges(bm)
			if len(edges):
				edge = choice(edges)
				bmesh.ops.dissolve_faces(bm, faces=edge.link_faces, use_verts=False)
				
		for edge in get_movable_edges(bm):
			x = (random()*2-1)*self.randomedge*(2.0/self.xsub)*0.5
			edge.verts[0].co.x += x
			edge.verts[1].co.x += x
		for vert in bm.verts:
			x = (noise(vert.co)*2-1)*self.randomvert*(2.0/self.xsub)*0.5
			y = (noise(vert.co+Vector((11.1,13.12,17.14)))*2-1)*self.randomvert*(2.0/self.ysub)*0.5
			vert.co.x += x
			vert.co.y += y
		
		extruded_faces = bmesh.ops.extrude_discrete_faces(bm, faces=bm.faces)['faces']
		bm.verts.index_update()
		for face in extruded_faces:
			vindices = [v.index for v in face.verts]
			for vert in face.verts:
				for e in vert.link_edges:
					overt = e.other_vert(vert)
					if overt.index not in vindices:
						overt.tag = True
		bmesh.ops.delete(bm, geom=[v for v in bm.verts if v.tag], context=1)

		for face in bm.faces:
			z = (random()*2-1) * self.zrandom
			for vert in face.verts:
				vert.co.z += z
		
		bmesh.update_edit_mesh(me, True)
		bpy.ops.object.editmode_toggle()
		obj.scale.x = self.xsub/10.0
		obj.scale.y = self.ysub/10.0

		# add random uv and vcolor
		me.uv_textures.new()
		uv_layer = me.uv_layers.active.data
		vertex_colors = me.vertex_colors.new().data
		for poly in me.polygons:
			offset = Vector((random(), random(), 0)) if self.randomuv else Vector((0, 0, 0))
			color = [random(), random(), random()]
			for loop_index in range(poly.loop_start, poly.loop_start + poly.loop_total):
				coords = me.vertices[me.loops[loop_index].vertex_index].co
				uv_layer[loop_index].uv = (coords + offset).xy
				vertex_colors[loop_index].color = color
		
		
		bpy.ops.object.modifier_add(type='SOLIDIFY')
		bpy.context.object.modifiers["Solidify"].offset = 1
		bpy.context.object.modifiers["Solidify"].thickness = 0.1
		bpy.ops.object.modifier_add(type='BEVEL')
		bpy.context.object.modifiers["Bevel"].width = 0.01
		bpy.context.object.modifiers["Bevel"].segments = 2

		return {'FINISHED'}
Esempio n. 18
0
from mathutils import noise
import numpy as np
import bpy

segment = np.pi + 0.1
xoff = np.interp(np.cos(segment), [-1, 1], [2, 7])
yoff = np.interp(np.sin(segment), [-1, 1], [2, 7])
zoff = 0.4

pos = np.array([xoff, yoff, zoff])

val = noise.noise(pos)
radius = np.interp(val, [0, 1], [2, 7])

print(xoff, yoff, zoff)
print(val, radius)
"""
from mathutils import noise
import numpy as np 
import bpy
import bmesh

class PerlinCircle:
    
    def __init

def perlin_circle(bm, param):
    
    circle_segments = np.linspace(0, 2*np.pi, param["n_segments"])
    center = np.array([-1,-1,0])
    radius = 2