Newer
Older
icList = voxelByRays(obINSULATOR, winmgr.ORIGIN, winmgr.GSCALE)
print('<<<<<<------INSULATOR OBJECT CELL COUNT = ', len(icList) )
#writeArrayToCubes(icList, winmgr.GSCALE, winmgr.ORIGIN)
#return 'THEEND'
###====== 2) LOCATE CANDIDATE SITES AROUND CHARGE
cSites = getCandidateSites(cgrid, icList)
###====== 3) CALC POTENTIAL AT EACH SITE (Eqn. 10)
cSites = initialPointCharges(cgrid, cSites, eChargeList)
ts = 1
while ts <= TSTEPS:
###====== 1) SELECT NEW GROWTH SITE (Eqn. 12)
###===GET PROBABILITIES AT CANDIDATE SITES
gProbs = getGrowthProbability(winmgr.BIGVAR, cSites)
###===CHOOSE NEW GROWTH SITE BASED ON PROBABILITIES
gSitei = weightedRandomChoice(gProbs)
gsite = cSites[gSitei][0]
###====== 2) ADD NEW POINT CHARGE AT GROWTH SITE
###===ADD NEW GROWTH CELL TO GRID
cgrid.append(gsite)
###===REMOVE NEW GROWTH CELL FROM CANDIDATE SITES
cSites.remove(cSites[gSitei])
###====== 3) UPDATE POTENTIAL AT CANDIDATE SITES (Eqn. 11)
cSites = updatePointCharges(gsite, cSites, eChargeList)
###====== 4) ADD NEW CANDIDATES SURROUNDING GROWTH SITE
###===GET CANDIDATE 'STENCIL'
ncSitesT = getCandidateSites([gsite], icList)
###===REMOVE CANDIDATES ALREADY IN CANDIDATE LIST OR CHARGE GRID
ncSites = []
cSplit = splitList(cSites, 0)
for cn in ncSitesT:
if not cn in cSplit and \
not cn in cgrid:
ncSites.append((cn, 0))
###====== 5) CALC POTENTIAL AT NEW CANDIDATE SITES (Eqn. 10)
ncSplit = splitList(ncSites, 0)
ncSites = initialPointCharges(cgrid, ncSplit, eChargeList)
###===ADD NEW CANDIDATE SITES TO CANDIDATE LIST
for ncs in ncSites:
cSites.append(ncs)
###===ITERATION COMPLETE
istr1 = ':::T-STEP: ' + str(ts) + '/' + str(TSTEPS)
istr12 = ' | GROUNDZ: ' + str(winmgr.GROUNDZ) + ' | '
istr2 = 'CANDS: ' + str(len(cSites)) + ' | '
istr3 = 'GSITE: ' + str(gsite)
print(istr1 + istr12 + istr2 + istr3)
ts += 1
###---EARLY TERMINATION FOR GROUND/CLOUD STRIKE
if winmgr.GROUNDBOOL:
if gsite[2] == winmgr.GROUNDZ:
ts = TSTEPS+1
print('<<<<<<------EARLY TERMINATION DUE TO GROUNDSTRIKE')
continue
if winmgr.CLOUDBOOL:
#if gsite in cloudList:
if gsite in splitListCo(eChargeList):
ts = TSTEPS+1
print('<<<<<<------EARLY TERMINATION DUE TO CLOUDSTRIKE')
tc2 = time.clock()
tcRUN = tc2 - tc1
print('<<<<<<------LAPLACIAN GROWTH LOOP COMPLETED: ' + str(len(cgrid)) + ' / ' + str(tcRUN)[0:5] + ' SECONDS')
print('<<<<<<------VISUALIZING DATA')
reportSTRING = getReportString(tcRUN)
###---VISUALIZE ARRAY
visualizeArray(cgrid, obORIGIN, winmgr.GSCALE, winmgr.VMMESH, winmgr.VSMESH, winmgr.VCUBE, winmgr.VVOX, reportSTRING)
print('<<<<<<------COMPLETE')
######################################################################
################################ GUI #################################
######################################################################
###---NOT IN UI
bpy.types.WindowManager.ORIGIN = bpy.props.FloatVectorProperty(name = "origin charge")
bpy.types.WindowManager.GROUNDZ = bpy.props.IntProperty(name = "ground Z coordinate")
bpy.types.WindowManager.HORDER = bpy.props.IntProperty(name = "secondary paths orders")
###---IN UI
bpy.types.WindowManager.TSTEPS = bpy.props.IntProperty(
name = "iterations", description = "number of cells to create, will end early if hits ground plane or cloud")
bpy.types.WindowManager.GSCALE = bpy.props.FloatProperty(
name = "grid unit size", description = "scale of cells, .25 = 4 cells per blenderUnit")
bpy.types.WindowManager.BIGVAR = bpy.props.FloatProperty(
name = "straightness", description = "straightness/branchiness of bolt, <2 is mush, >12 is staight line, 6.3 is good")
bpy.types.WindowManager.GROUNDBOOL = bpy.props.BoolProperty(
name = "use ground object", description = "use ground plane or not")
bpy.types.WindowManager.GROUNDC = bpy.props.IntProperty(
name = "ground charge", description = "charge of ground plane")
bpy.types.WindowManager.CLOUDBOOL = bpy.props.BoolProperty(
name = "use cloud object", description = "use cloud obj, attracts and terminates like ground but any obj instead of z plane, can slow down loop if obj is large, overrides ground")
bpy.types.WindowManager.CLOUDC = bpy.props.IntProperty(
name = "cloud charge", description = "charge of a cell in cloud object (so total charge also depends on obj size)")
bpy.types.WindowManager.VMMESH = bpy.props.BoolProperty(
name = "multi mesh", description = "output to multi-meshes for different materials on main/sec/side branches")
bpy.types.WindowManager.VSMESH = bpy.props.BoolProperty(
name = "single mesh", description = "output to single mesh for using build modifier and particles for effects")
bpy.types.WindowManager.VCUBE = bpy.props.BoolProperty(
name = "cubes", description = "CTRL-J after run to JOIN, outputs a bunch of cube objest, mostly for testing")
bpy.types.WindowManager.VVOX = bpy.props.BoolProperty(
name = "voxel (experimental)", description = "output to a voxel file to bpy.data.filepath\FSLGvoxels.raw - doesn't work well right now")
bpy.types.WindowManager.IBOOL = bpy.props.BoolProperty(
name = "use insulator object", description = "use insulator mesh object to prevent growth of bolt in areas")
bpy.types.WindowManager.OOB = bpy.props.StringProperty(description = "origin of bolt, can be an Empty, if obj is mesh will use all verts as charges")
bpy.types.WindowManager.GOB = bpy.props.StringProperty(description = "object to use as ground plane, uses z coord only")
bpy.types.WindowManager.COB = bpy.props.StringProperty(description = "object to use as cloud, best to use a cube")
bpy.types.WindowManager.IOB = bpy.props.StringProperty(description = "object to use as insulator, 'voxelized' before generating bolt, can be slow")
###---DEFAULT USER SETTINGS
winmgr.TSTEPS = 350
winmgr.HORDER = 1
winmgr.GSCALE = 0.12
winmgr.BIGVAR = 6.3
winmgr.GROUNDBOOL = True
winmgr.GROUNDC = -250
winmgr.CLOUDBOOL = False
winmgr.CLOUDC = -1
winmgr.VMMESH = True
winmgr.VSMESH = False
winmgr.VCUBE = False
winmgr.VVOX = False
winmgr.IBOOL = False
winmgr.OOB = "ELorigin"
winmgr.GOB = "ELground"
winmgr.COB = "ELcloud"
winmgr.IOB = "ELinsulator"
except: pass
###---TESTING USER SETTINGS
if False:
#if True:
winmgr.TSTEPS = 40
#winmgr.HORDER = 1
#winmgr.GSCALE = 0.12
#winmgr.BIGVAR = 6.3
winmgr.GROUNDBOOL = True
#winmgr.GROUNDC = -500
winmgr.CLOUDBOOL = True
#winmgr.CLOUDC = -5
#winmgr.VMMESH = True
#winmgr.VSMESH = True
#winmgr.VCUBE = True
#winmgr.VVOX = True
winmgr.IBOOL = True
class runFSLGLoopOperator(bpy.types.Operator):
'''By The Mighty Hammer Of Thor!!!'''
bl_idname = "object.runfslg_operator"
bl_label = "run FSLG Loop Operator"
def execute(self, context):
if checkSettings():
FSLG()
else: pass
return {'FINISHED'}
class setupObjectsOperator(bpy.types.Operator):
'''create origin/ground/cloud/insulator objects'''
bl_idname = "object.setup_objects_operator"
bl_label = "Setup Objects Operator"
def execute(self, context):
setupObjects()
return {'FINISHED'}
class OBJECT_PT_fslg(bpy.types.Panel):
bl_label = "Laplacian Lightning - v0.2.6"
bl_space_type = "VIEW_3D"
bl_region_type = "TOOLS"
bl_context = "objectmode"
bl_category = "Addons"
def draw(self, context):
scn = context.scene
layout = self.layout
colR = layout.column()
#row1 = layout.row()
#colL = row1.column()
#colR = row1.column()
colR.label('-for progress open console-')
colR.label('Help > Toggle System Console')
colR.prop(winmgr, 'TSTEPS')
colR.prop(winmgr, 'GSCALE')
colR.prop(winmgr, 'BIGVAR')
colR.operator('object.setup_objects_operator', text = 'create setup objects')
colR.label('origin object')
colR.prop_search(winmgr, "OOB", context.scene, "objects")
colR.prop(winmgr, 'GROUNDBOOL')
colR.prop_search(winmgr, "GOB", context.scene, "objects")
colR.prop(winmgr, 'GROUNDC')
colR.prop(winmgr, 'CLOUDBOOL')
colR.prop_search(winmgr, "COB", context.scene, "objects")
colR.prop(winmgr, 'CLOUDC')
colR.prop(winmgr, 'IBOOL')
colR.prop_search(winmgr, "IOB", context.scene, "objects")
colR.operator('object.runfslg_operator', text = 'generate lightning')
#col.prop(winmgr, 'HORDER')
colR.prop(winmgr, 'VMMESH')
colR.prop(winmgr, 'VSMESH')
colR.prop(winmgr, 'VCUBE')
#colR.prop(winmgr, 'VVOX')
def getReportString(rtime):
rSTRING1 = 't:' + str(winmgr.TSTEPS) + ',sc:' + str(winmgr.GSCALE)[0:4] + ',uv:' + str(winmgr.BIGVAR)[0:4] + ','
rSTRING2 = 'ori:' + str(winmgr. ORIGIN[0]) + '/' + str(winmgr. ORIGIN[1]) + '/' + str(winmgr. ORIGIN[2]) + ','
rSTRING3 = 'gz:' + str(winmgr.GROUNDZ) + ',gc:' + str(winmgr.GROUNDC) + ',rtime:' + str(int(rtime))
return rSTRING1 + rSTRING2 + rSTRING3
def addReportProp(ob, str):
bpy.types.Object.FSLG_REPORT = bpy.props.StringProperty(
name = 'fslg_report', default = '')
ob.FSLG_REPORT = str
def register():
bpy.utils.register_class(runFSLGLoopOperator)
bpy.utils.register_class(setupObjectsOperator)
bpy.utils.register_class(OBJECT_PT_fslg)
def unregister():
bpy.utils.unregister_class(runFSLGLoopOperator)
bpy.utils.unregister_class(setupObjectsOperator)
bpy.utils.unregister_class(OBJECT_PT_fslg)
if __name__ == "__main__":
### RUN FOR TESTING
#FSLG()
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
### UI
register()
pass
###########################
##### FXN BENCHMARKS ######
###########################
def BENCH():
print('\n\n\n--->BEGIN BENCHMARK')
bt0 = time.clock()
###---MAKE A BIG LIST
tsize = 25
tlist = []
for x in range(tsize):
for y in range(tsize):
for z in range(tsize):
tlist.append((x,y,z))
tlist.append((x,y,z))
###---FUNCTION TO TEST
bt1 = time.clock()
#ll = deDupe(tlist)
#ll = f5(tlist)
print('LENS - ', len(tlist), len(ll) )
bt2 = time.clock()
btRUNb = bt2 - bt1
btRUNa = bt1 - bt0
print('--->SETUP TIME : ', btRUNa)
print('--->BENCHMARK TIME: ', btRUNb)
print('--->GRIDSIZE: ', tsize, ' - ', tsize*tsize*tsize)
CoDEmanX
committed
#BENCH()
######################################################################
############################### THE END ##############################
######################################################################