Skip to content
Snippets Groups Projects
object_laplace_lightning.py 46 KiB
Newer Older
  • Learn to ignore specific revisions
  •         icList = voxelByRays(obINSULATOR, winmgr.ORIGIN, winmgr.GSCALE)
    
            print('<<<<<<------INSULATOR OBJECT CELL COUNT = ', len(icList) )
    
            #writeArrayToCubes(icList, winmgr.GSCALE, winmgr.ORIGIN)
    
        ###====== 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)        
    
            ###---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 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)    
    
        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")
    
    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")
    
    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"    
    
    
    ###---TESTING USER SETTINGS
    
        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"
    
    Brendon Murphy's avatar
    Brendon Murphy committed
        bl_options = {'DEFAULT_CLOSED'}
    
    
        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.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')
    
        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
    
        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()
    
        ### 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)
    
    ######################################################################
    ############################### THE END ##############################
    ######################################################################