Python pyformex.debug函数代码示例

def setToolbarPlacement(store=None):
    """Ask placement of toolbars.

    Items in list should be existing toolbar widgets.
    """
    if store is None:
        store = GD.cfg
    toolbar = [ GD.gui.modebar, GD.gui.viewbar ]
    setting = ['gui/modebar', 'gui/viewbar' ]
    options = [ None, 'default', 'left', 'right', 'top', 'bottom' ]
    label = [ str(tb.windowTitle()) for tb in toolbar ]
    current = [ store[s] for s in setting ]
    itemlist = [(l, options[1], 'select', options) for (l,c) in zip(label,setting)]
    itemlist.append(('Store these settings as defaults', False))
    res = widgets.InputDialog(itemlist,'Config Dialog',GD.gui).getResult()
    if res:
        GD.debug(res)
        if res['Store these settings as defaults']:
            # The following  does not work for our Config class!
            #    store.update(res)
            # Therefore, we set the items individually
            for s,l in zip(setting,label):
                val = res[l]
                if val == "None":
                    val = None
                store[s] = val
        GD.debug(store)

 def __init__(self):
     """Initialize an empty canvas with default settings."""
     self.actors = ActorList(self,'actor')
     self.highlights = ActorList(self,'highlight')
     self.annotations = ActorList(self,'annotation')
     self.decorations = ActorList(self,'decoration')
     self.triade = None
     self.bbox = None
     self.resetLighting()
     self.resetLights()
     self.setBbox()
     self.settings = CanvasSettings()
     self.mode2D = False
     self.rendermode = 'wireframe'
     self.polygonfill = False
     self.lighting = True
     self.avgnormals = False
     self.alphablend = False
     self.dynamouse = True  # dynamic mouse action works on mouse move
     self.dynamic = None    # what action on mouse move
     self.camera = None
     self.view_angles = camera.view_angles
     self.cursor = None
     self.focus = False
     GD.debug("Canvas Setting:\n%s"% self.settings)

def setToolbarPlacement(store=None):
    """Ask placement of toolbars.

    Items in list should be existing toolbar widgets.
    """
    if store is None:
        store = GD.cfg
    toolbar = GD.GUI.toolbardefs
    label = [i[0] for i in toolbar]
    setting = ["gui/%s" % i[1] for i in toolbar]
    options = [None, "default", "left", "right", "top", "bottom"]
    current = [store[s] for s in setting]
    itemlist = [(l, options[1], "select", options) for (l, c) in zip(label, setting)]
    itemlist.append(("Store these settings as defaults", False))
    res = widgets.InputDialog(itemlist, "Config Dialog", GD.GUI).getResult()
    if res:
        GD.debug(res)
        if res["Store these settings as defaults"]:
            # The following  does not work for our Config class!
            #    store.update(res)
            # Therefore, we set the items individually
            for s, l in zip(setting, label):
                val = res[l]
                if val == "None":
                    val = None
                store[s] = val
        GD.debug(store)

def drawFaces(x,e,faces,mode,color=None,alpha=1.0):
    """Draw the faces of a geometry.

    This function draws the faces of a geometry collection, usually of a higher
    dimensionality (i.c. a volume).
    The faces are identified by a constant indices into all element vertices.

    The geometry is specified by x or (x,e)
    The faces are specified by a list of lists. Each list defines a single
    face of the solid, in local vertex numbers (0..nplex-1). The faces are
    sorted and collected according to their plexitude before drawing them. 
    """
    GD.debug("drawFaces")
    # We may have faces with different plexitudes!
    for fac in olist.collectOnLength(faces).itervalues():
        fa = asarray(fac)
        nplex = fa.shape[1]
        if e is None:
            coords = x[:,fa,:]
            elems = None
        else:
            coords = x
            elems = e[:,fa]
        GD.debug("COORDS SHAPE: %s" % str(coords.shape))
        if elems is not None:
            GD.debug("ELEMS SHAPE: %s" % str(elems.shape))
        if color is not None and color.ndim==3:
            GD.debug("COLOR SHAPE BEFORE EXTRACTING: %s" % str(color.shape))
            # select the colors of the matching points
            color = color[:,fa,:]
            color = color.reshape((-1,)+color.shape[-2:])
            GD.debug("COLOR SHAPE AFTER EXTRACTING: %s" % str(color.shape))
        draw_parts(coords,elems,mode,color,alpha)

 def draw(self,*args,**kargs):
     clear()
     GD.debug("Drawing SELECTION: %s" % self.names)
     self._actors = draw(self.names,clear=False,shrink=self.shrink,*args,**kargs)
     for i,a in enumerate(self.annotations):
         if a[1]:
             self.drawAnnotation(i)

def startGui(args=[]):
    """Start the gui"""
    if pf.GUI is None:
        pf.debug("Starting the pyFormex GUI")
        from gui import guimain
        if guimain.startGUI(args) == 0:
            guimain.runGUI()

def draw_parts(x,e,mode,color=None,alpha=1.0):
    """Draw a collection of faces.

    (x,e) are one of:
    - x is a (nelems,nfaces,nplex,3) shaped coordinates and e is None,
    - x is a (ncoords,3) shaped coordinates and e is a (nelems,nfaces,nplex)
    connectivity array.
       
    Each of the nfaces sets of nplex points defines a polygon. 

    If color is given it is an (nel,3) array of RGB values. This function
    will multiplex the colors, so that n faces are drawn in the same color.
    This is e.g. convenient when drawing faces of a solid element.
    """
    if e is None:
        nfaces,nplex = x.shape[1:3]
        x = x.reshape(-1,nplex,3)
    else:
        nfaces,nplex = e.shape[1:3]
        e = e.reshape(-1,nplex)

    if color is not None:
        if color.ndim < 3:
            GD.debug("COLOR SHAPE BEFORE MULTIPLEXING %s" % str(color.shape))
            color = color_multiplex(color,nfaces)
            GD.debug("COLOR SHAPE AFTER  MULTIPLEXING %s" % str(color.shape))

    drawPolygons(x,e,mode,color,alpha)

def flyAlong(path='flypath',upvector=[0.,1.,0.],sleeptime=None):
    """Fly through the scene along the flypath."""
    if type(path) is str:
        path = named(path)
    if not path:
        warning("You have to define a flypath first!")
        return
    if path.nplex() != 2:
        warning("The flypath should be a plex-2 Formex!")
        
    for eye,center in path:
        GD.debug("Eye: %s; Center: %s" % (eye,center))
        GD.canvas.camera.lookAt(eye,center,upvector)
        GD.canvas.display()
        GD.canvas.update()
        image.saveNext()
        if sleeptime is None:
            sleeptime = GD.cfg['draw/flywait']
        sleeptime = float(sleeptime)
        if sleeptime > 0.0:
            sleep(sleeptime)

    GD.canvas.camera.setCenter(*center)
    GD.canvas.camera.setDist(coords.length(center-eye))
    GD.canvas.update()

 def draw(self,**kargs):
     clear()
     pf.debug("Drawing SELECTION: %s" % self.names,pf.DEBUG.DRAW)
     self._actors = draw(self.names,clear=False,shrink=self.shrink,wait=False,**kargs)
     for f in self.annotations:
         pf.debug("Drawing ANNOTATION: %s" % f,pf.DEBUG.DRAW)
         self.drawAnnotation(f)

def viewportSettings():
    """Interactively set the viewport settings."""
    mode = GD.canvas.rendermode
    modes = canvas.Canvas.rendermodes
    s = GD.canvas.settings
    if s.bgcolor2 is None:
        s.bgcolor2 = s.bgcolor
    itemlist = [('rendermode', mode, 'select', modes),
                ('linewidth', s.linewidth, 'float'),
                ('bgcolor', s.bgcolor, 'color'),
                ('bgcolor2', s.bgcolor2, 'color'),
                ('fgcolor', s.fgcolor, 'color'),
                ('slcolor', s.slcolor, 'color'),
                ('Store these settings as defaults', False),
                ]
    res = widgets.InputDialog(itemlist,'Config Dialog').getResult()
    if res:
        GD.debug(res)
        GD.canvas.updateSettings(res)
        GD.canvas.setRenderMode(res['rendermode'])
        #GD.canvas.clear()
        GD.canvas.redrawAll()
        GD.canvas.update()
        if res['Store these settings as defaults']:
            GD.cfg.update(GD.canvas.settings.__dict__,name='canvas')

def createMovie(encoder='ffmpeg'):
    """Create a movie from a saved sequence of images.

    encoder is one of: 'ffmpeg, mencoder, convert'
    """
    if not multisave:
        pf.warning('You need to start multisave mode first!')
        return

    names,format,quality,window,border,hotkey,autosave,rootcrop = multisave
    glob = names.glob()
    ## if glob.split('.')[-1] != 'jpg':
    ##     pf.warning("Currently you need to save in 'jpg' format to create movies")
    ##     return

    if encoder == 'convert':
        cmd = "convert -delay 1 -colors 256 %s output.gif" % names.glob()
    elif encoder == 'mencoder':
        cmd = "mencoder -ovc lavc -fps 5 -o output.avi %s" % names.glob()
    elif encoder == 'mencoder1':
        cmd = "mencoder \"mf://%s\" -mf fps=10 -o output1.avi -ovc lavc -lavcopts vcodec=msmpeg4v2:vbitrate=800" % names.glob()
    else:
        cmd = "ffmpeg -qscale 1 -r 1 -i %s output.mp4" % names.glob()
    pf.debug(cmd)
    utils.runCommand(cmd)

def runGUI():
    """Go into interactive mode"""
    
    egg = pf.cfg.get('gui/easter_egg',None)
    pf.debug('EGG: %s' % str(egg))
    if egg:
        pf.debug('EGG')
        if type(egg) is str:
            pye = egg.endswith('pye')
            egg = file(egg).read()
        else:
            pye = True
            egg = ''.join(egg)
        draw.playScript(egg,pye=True)

    if os.path.isdir(pf.cfg['workdir']):
        # Make the workdir the current dir
        os.chdir(pf.cfg['workdir'])
        pf.debug("Setting workdir to %s" % pf.cfg['workdir'])
    else:
        # Save the current dir as workdir
        prefMenu.updateSettings({'workdir':os.getcwd(),'Save changes':True})

    pf.interactive = True
    pf.debug("Start main loop")

    #utils.procInfo('runGUI')
    #from multiprocessing import Process
    #p = Process(target=pf.app.exec_)
    #p.start()
    #res = p.join()
    res = pf.app.exec_()
    pf.debug("Exit main loop with value %s" % res)
    return res

    def save(self,quiet=False):
        """Save the project to file."""
        if 'w' not in self.access:
            pf.debug("Not saving because Project file opened readonly",pf.DEBUG.PROJECT)
            return

        if not quiet:
            print("Project variables changed: %s" % self.hits)

        if self.filename is None:
            import tempfile
            fd,fn = tempfile.mkstemp(prefix='pyformex_',suffix='.pyf')
            self.filename = fn
        else:
            if not quiet:
                print("Saving project %s with mode %s and compression %s" % (self.filename,self.mode,self.gzip))
            #print("  Contents: %s" % self.keys())
        f = open(self.filename,'w'+self.mode)
        # write header
        f.write("%s\n" % self.header_data())
        f.flush()
        if self.mode == 'b':
            # When using binary, can as well use highest protocol
            protocol = cPickle.HIGHEST_PROTOCOL
        else:
            protocol = 0
        if self.gzip:
            pyf = gzip.GzipFile(mode='w'+self.mode,compresslevel=self.gzip,fileobj=f)
            cPickle.dump(self,pyf,protocol)
            pyf.close()
        else:
            cPickle.dump(self,f,protocol)
        f.close()
        self.hits = 0

def viewportSettings():
    """Interactively set the viewport settings."""
    mode = pf.canvas.rendermode
    modes = canvas.Canvas.rendermodes
    s = pf.canvas.settings
    if s.bgcolor2 is None:
        s.bgcolor2 = s.bgcolor
    itemlist = [I('rendermode', mode, choices=modes),
                I('linewidth', s.linewidth, itemtype='float'),
                I('bgcolor', s.bgcolor, itemtype='color'),
                I('bgcolor2', s.bgcolor2, itemtype='color'),
                I('fgcolor', s.fgcolor, itemtype='color'),
                I('slcolor', s.slcolor, itemtype='color'),
                I('Store these settings as defaults', False),
                ]
    res = widgets.InputDialog(itemlist,'Config Dialog').getResult()
    if res:
        pf.debug(res)
        pf.canvas.setRenderMode(res['rendermode'])
        pf.canvas.settings.update(res,strict=False)
        #pf.canvas.clear()
        pf.canvas.redrawAll()
        pf.canvas.update()
        if res['Store these settings as defaults']:
            pf.cfg.update(pf.canvas.settings.__dict__,name='canvas')

def refLookup(key):
    """Lookup a key in the reference configuration."""
    try:
        return pyformex.refcfg[key]
    except:
        pyformex.debug("!There is no key '%s' in the reference config!"%key)
        return None