Das deutsche Python-Forum

Code: Alles auswählen

import bpy
from .tree import Tree
#from .Branch import Branch, reset, nextv
from .Leaf import Leaf
from bpy.props import BoolProperty
from bpy.types import Panel


def main(context):
    tree = Tree()


class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    def execute(self, context):
        main(context)


def register():
    bpy.utils.register_class(SimpleOperator)


def unregister():
    bpy.utils.unregister_class(SimpleOperator)


if __name__ == "__main__":
    register()

    # test call
    #bpy.ops.object.simple_operator()

Code: Alles auswählen

from mathutils import Vector
import bpy


    
class Branch:
    
    def __init__(self,p,pos,dir):
            self.pos = pos.copy()
            self.count = 0
            self.len = 5
            parent = p
            dir = Vector()

    def reset(self):
            self.count = 0
            self.dir = self.saveDir.copy()
            
    def next(self):
        v = Vector.mult(dir, len)
        next = Vector.add(pos, v)
        return next
    
b = Branch(None,Vector([0,0,0]),Vector([0,1]))
#print(b.pos)

Code: Alles auswählen

from random import random, uniform,randint
import bpy
from mathutils import Vector, Matrix


def sphere(r,p):
    r2 = r*r
    while True:
        x = (random()*2-1)*r
        y = (random()*2-1)*r
        z = (random()*2-1)*r
        if x*x+y*y+z*z <= r2:
            yield p+Vector((x,y,z))
a = randint(0,9)
b = randint(0,9)
c = randint(0,9)
class Leaf(object):
	def __init__(self):
		context = bpy.context
		obj = context.object
		self.reached = False
		self.pos = Vector([a,b,c])

	def reached(self):
		self.reached = True

	def show(self):
		self.pushMatrix()
		self.translate(self.pos.x, self.pos.y, self.pos.z)
		self.sphere(5,Vector((0,0,8)))
		self.popMatrix()
		
l = Leaf()

Code: Alles auswählen

from mathutils import Vector
from array import array
import bpy
from .Branch import Branch,b
from .Leaf import Leaf, sphere,l
from bpy.props import BoolProperty
from math import sqrt


max_dist = 200
min_dist = 10

def closest(pos, count, n, x, y, z):
        d2 = 1e30
        for i in range(n):
          if count[i] > 1 : continue
          dx, dy, dz = x-pos[i*3], y-pos[i*3+1], z-pos[i*3+2]
          d = dx*dx + dy*dy + dz*dz
          if d < d2:
            d2 = d
            ci = i
            v = dx,dy,dz
        return d2, ci, v

closeEnough = BoolProperty(default = False)
class Tree:
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    bl_label = 'Tools Tab Label'
    bl_context = 'objectmode'
    bl_category = 'SC'
    
    
    
    
    
    def __init__(self):
        self.branches = list('b') #Branch
        self.leaves = list('l')  #Leaf
        i = 0
        while(i < 1000):
            self.leaves.append(sphere)
            i += 1
        root = b
        self.branches.append(root)
        current = root
        while closeEnough == True:
            trunk = Branch(current)
            self.branches.append(trunk)
            current = trunk
    def getDistance(p0, p1):
        return sqrt((p0[0] - p1[0])**2 + (p0[1] - p1[1])**2 + (p0[2] - p1[2])**2)       
            
    
        for i in range (len('l')):
            Leaf('l',leaves(i)) 
            d = getDistance(b.pos, l.pos)
            if (d < max_dist) :
                closeEnough = True
            else:    
                closeEnough = False
  
 


  
  
    def grow(self):
            for i in range (len('l')):
                Leaf(l,self.leaves(i)) 
                self.closestBranch = None
                self.Vector.closestDir = None 
                self.record = -1

      
            for i in range (len('b')):
                Branch(b,branches.get(i))  
                self.Vector.dir = Vector.sub(self.l.pos,self.b.pos)
                self.d = self.dir.mag()
                if (d < min_dist):
                    self.l.reached = None
                    break
                elif(d > max_dist):
                    if (self.closest == None or d < self.record) :
                        self.closest = b
                        self.closestDir = dir
                        self.record = d
                
            
            
            if (self.closest != None) :
                self.closestDir.normalize()
                self.closest.dir.add(closestDir)
                self.closest.count+=1
        
        
            for i in range (leaves.size()-1):
                if (leaves.get(i).reached):
                    leaves.discard(i)
                
        
            for i in range (leaves.size()-1):
                if (leaves.get(i).reached):
                    leaves.remove(i)
                    i-=1
                
            for i in range (branches.size()-1):
                Branch(b,branches.get(i)) 
                if (b.count > 0):
                    self.dir.b.div(b.count)
                    self.dir.b.normalize()
                    newB = Branch(b)
                    branches.add(newB)
                    b.reset()
                    
                    
                    
    #importiert von https://blender.stackexchange.com/questions/5898/how-can-i-create-a-cylinder-linking-two-points-with-python
    def cylinder_between(x1, y1, z1, x2, y2, z2, r):

        dx = x2 - x1
        dy = y2 - y1
        dz = z2 - z1    
        dist = sqrt(dx**2 + dy**2 + dz**2)

        bpy.ops.mesh.primitive_cylinder_add(
            radius = 4, 
            depth = dist,
            location = (dx/2 + x1, dy/2 + y1, dz/2 + z1)   
        ) 

        phi = math.atan2(dy, dx) 
        theta = math.acos(dz/dist) 

        bpy.context.object.rotation_euler[1] = theta 
        bpy.context.object.rotation_euler[2] = phi 
        
    def show() :
        for i in range (leaves.size()):
            Leaf(l,leaves.get(i))  
            l.show()
            i+=1
        
    
        for i in range (branches,size()) :
                Branch(b,branches.get(i))  
                i+=1
                if (self.b.parent != None) :
                    clyinder_between(self.b.pos.x, self.b.pos.y, self.b.pos.z, self.b.parent.pos.x, self.b.parent.pos.y, self.b.parent.pos.z)