[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [20283] trunk/blender/release/scripts/ bpymodules/BPyMesh_octree.py: remove module that was never used.
Campbell Barton
ideasman42 at gmail.com
Wed May 20 05:30:50 CEST 2009
Revision: 20283
http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=20283
Author: campbellbarton
Date: 2009-05-20 05:30:50 +0200 (Wed, 20 May 2009)
Log Message:
-----------
remove module that was never used.
Removed Paths:
-------------
trunk/blender/release/scripts/bpymodules/BPyMesh_octree.py
Deleted: trunk/blender/release/scripts/bpymodules/BPyMesh_octree.py
===================================================================
--- trunk/blender/release/scripts/bpymodules/BPyMesh_octree.py 2009-05-20 02:17:53 UTC (rev 20282)
+++ trunk/blender/release/scripts/bpymodules/BPyMesh_octree.py 2009-05-20 03:30:50 UTC (rev 20283)
@@ -1,332 +0,0 @@
-from Blender import *
-
-try:
- import psyco
- psyco.full()
-except:
- print 'no psyco for you!'
-
-DotVecs= Mathutils.DotVecs
-#========================================================
-# SPACIAL TREE - Seperate Class - use if you want to
-# USed for getting vert is a proximity
-LEAF_SIZE = 128
-class octreeNode:
- def __init__(self, verts, parent):
-
- # Assunme we are a leaf node, until split is run.
- self.verts = verts
- self.children = []
-
- if parent == None: # ROOT NODE, else set bounds when making children,
- # BOUNDS
- v= verts[0]
- maxx,maxy,maxz= v.co
- minx,miny,minz= maxx,maxy,maxz
-
- for v in verts:
- x,y,z= v.co
- if x>maxx: maxx= x
- if y>maxy: maxy= y
- if z>maxz: maxz= z
-
- if x<minx: minx= x
- if y<miny: miny= y
- if z<minz: minz= z
-
- self.minx= minx
- self.miny= miny
- self.minz= minz
-
- self.maxx= maxx
- self.maxy= maxy
- self.maxz= maxz
-
- # We have no parent to split us so split ourselves.
- #self.setCornerPoints()
- self.splitNode()
-
- def splitNode(self):
- if len(self.verts) > LEAF_SIZE:
- self.makeChildren() # 8 new children,
- self.verts = None
- # Alredy assumed a leaf not so dont do anything here.
-
- def makeChildren(self):
- verts= self.verts
- # Devide into 8 children.
- axisDividedVerts = [[],[],[],[],[],[],[],[]] # Verts Only
-
-
- divx = (self.maxx + self.minx) / 2
- divy = (self.maxy + self.miny) / 2
- divz = (self.maxz + self.minz) / 2
-
- # Sort into 8
- for v in verts:
- x,y,z = v.co
-
- if x > divx:
- if y > divy:
- if z > divz:
- axisDividedVerts[0].append(v)
- else:
- axisDividedVerts[1].append(v)
- else:
- if z > divz:
- axisDividedVerts[2].append(v)
- else:
- axisDividedVerts[3].append(v)
- else:
- if y > divy:
- if z > divz:
- axisDividedVerts[4].append(v)
- else:
- axisDividedVerts[5].append(v)
- else:
- if z > divz:
- axisDividedVerts[6].append(v)
- else:
- axisDividedVerts[7].append(v)
-
- # populate self.children
- for i in xrange(8):
- octNode = octreeNode(axisDividedVerts[i], self)
- # Set bounds manually
- if i == 0:
- octNode.minx = divx
- octNode.maxx = self.maxx
- octNode.miny = divy
- octNode.maxy = self.maxy
- octNode.minz = divz
- octNode.maxz = self.maxz
- elif i == 1:
- octNode.minx = divx
- octNode.maxx = self.maxx
- octNode.miny = divy
- octNode.maxy = self.maxy
- octNode.minz = self.minz #
- octNode.maxz = divz #
- elif i == 2:
- octNode.minx = divx
- octNode.maxx = self.maxx
- octNode.miny = self.miny #
- octNode.maxy = divy #
- octNode.minz = divz
- octNode.maxz = self.maxz
- elif i == 3:
- octNode.minx = divx
- octNode.maxx = self.maxx
- octNode.miny = self.miny #
- octNode.maxy = divy #
- octNode.minz = self.minz #
- octNode.maxz = divz #
- elif i == 4:
- octNode.minx = self.minx #
- octNode.maxx = divx #
- octNode.miny = divy
- octNode.maxy = self.maxy
- octNode.minz = divz
- octNode.maxz = self.maxz
- elif i == 5:
- octNode.minx = self.minx #
- octNode.maxx = divx #
- octNode.miny = divy
- octNode.maxy = self.maxy
- octNode.minz = self.minz #
- octNode.maxz = divz #
- elif i == 6:
- octNode.minx = self.minx #
- octNode.maxx = divx #
- octNode.miny = self.miny #
- octNode.maxy = divy #
- octNode.minz = divz
- octNode.maxz = self.maxz
- elif i == 7:
- octNode.minx = self.minx #
- octNode.maxx = divx #
- octNode.miny = self.miny #
- octNode.maxy = divy #
- octNode.minz = self.minz #
- octNode.maxz = divz #
- #octNode.setCornerPoints()
- octNode.splitNode() # Splits the node if it can.
- self.children.append(octNode)
-
- # GETS VERTS IN A Distance RANGE-
- def getVertsInRange(self, loc, normal, range_val, vertList):
- #loc= Mathutils.Vector(loc) # MUST BE VECTORS
- #normal= Mathutils.Vector(normal)
-
- '''
- loc: Vector of the location to search from
- normal: None or Vector - if a vector- will only get verts on this side of the vector
- range_val: maximum distance. A negative value will fill the list with teh closest vert only.
- vertList: starts as an empty list
- list that this function fills with verts that match
- '''
- xloc,yloc,zloc= loc
-
- if range_val<0:
- range_val= -range_val
- FIND_CLOSEST= True
- vertList.append(None) # just update the 1 vertex
- else:
- FIND_CLOSEST= False
-
- if self.children:
- # Check if the bounds are in range_val,
- for childNode in self.children:
- # First test if we are surrounding the point.
- if\
- childNode.minx - range_val < xloc and\
- childNode.maxx + range_val > xloc and\
- childNode.miny - range_val < yloc and\
- childNode.maxy + range_val > yloc and\
- childNode.minz - range_val < zloc and\
- childNode.maxz + range_val > zloc:
- # Recurse down or get virts.
- childNode.getVertsInRange(loc, normal, range_val, vertList)
- #continue # Next please
-
- else: # we are a leaf node. Test vert locations.
- if not normal:
- # Length only check
- for v in self.verts:
- length = (loc - v.co).length
- if length < range_val:
- if FIND_CLOSEST:
- # Just update the 1 vert
- vertList[0]= (v, length)
- range_val= length # Shink the length so we only get verts from their.
- else:
- vertList.append((v, length))
- else:
- # Lengh and am I infront of the vert.
- for v in self.verts:
- length = (loc - v.co).length
- if length < range_val:
- # Check if the points in front
- dot= DotVecs(normal, loc) - DotVecs(normal, v.co)
- if dot<0:
- vertList.append((v, length))
-
-# END TREE
-
-
-
-
-# EXAMPLE RADIO IN PYTHON USING THE ABOVE FUNCTION
-"""
-import BPyMesh
-# Radio bake
-def bake():
-
- _AngleBetweenVecs_= Mathutils.AngleBetweenVecs
- def AngleBetweenVecs(a1,a2):
- try:
- return _AngleBetweenVecs_(a1,a2)
- except:
- return 180
-
-
-
- scn = Scene.GetCurrent()
- ob = scn.getActiveObject()
- me = ob.getData(mesh=1)
-
- dist= Draw.PupFloatInput('MaxDist:', 2.0, 0.1, 20.0, 0.1, 3)
- if dist==None:
- return
-
- # Make nice normals
- BPyMesh.meshCalcNormals(me)
-
-
- len_verts= len(me.verts)
- #me.sel= False
- meshOctTree = octreeNode(me.verts, None)
-
-
-
- # Store face areas
- vertex_areas= [0.0] * len_verts
-
- # Get vertex areas - all areas of face users
- for f in me.faces:
- a= f.area
- for v in f.v:
- vertex_areas[v.index] += a
-
-
-
- bias= 0.001
-
- t= sys.time()
-
- # Tone for the verts
- vert_tones= [0.0] * len_verts
- maxtone= 0.0
- mintone= 100000000
- for i, v in enumerate(me.verts):
- if not i%10:
- print 'verts to go', len_verts-i
- v_co= v.co
- v_no= v.no
- verts_in_range= []
- meshOctTree.getVertsInRange(v_co, v_no, dist, verts_in_range)
-
- tone= 0.0
- # These are verts in our range
- for test_v, length in verts_in_range:
- if bias<length:
- try:
- # Make sure this isnt a back facing vert
- normal_diff= AngleBetweenVecs(test_v.no, v_no)
- except:
- continue
-
- if normal_diff > 90: # were facing this vert
- #if 1:
- # Current value us between zz90 and 180
- # make between 0 and 90
- # so 0 is right angles and 90 is direct opposite vertex normal
- normal_diff= (normal_diff-90)
-
- # Vertex area needs to be taken into account so we dont have small faces over influencing.
- vertex_area= vertex_areas[test_v.index]
-
- # Get the angle the vertex is in location from the location and normal of the vert.
- above_diff= AngleBetweenVecs(test_v.co-v.co, v_no)
- ## Result will be between 0 :above and 90: horizon.. invert this so horizon has littel effect
- above_diff= 90-above_diff
- # dist-length or 1.0/length both work well
- tone= (dist-length) * vertex_area * above_diff * normal_diff
- vert_tones[i] += tone
-
- if maxtone<vert_tones[i]:
- maxtone= vert_tones[i]
- if mintone>vert_tones[i]:
- mintone= vert_tones[i]
-
-
- if not maxtone:
- Draw.PupMenu('No verts in range, use a larger range')
- return
-
- # Apply tones
- for f in me.faces:
- f_col= f.col
- for i, v in enumerate(f.v):
- c= f_col[i]
- v_index= v.index
- tone= int(((maxtone - vert_tones[v.index]) / maxtone) * 255 )
- #print tone
- c.r= c.g= c.b= tone
-
- print 'time', sys.time()-t
-
-
-if __name__=="__main__":
- bake()
-"""
\ No newline at end of file
More information about the Bf-blender-cvs
mailing list