hmmeditor.py

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

        if self.modeltype & ghmmwrapper.kLabeledStates:
            self.graphMenu.add_command(label='Edit class labels', command=self.EditClassLabels)
        if self.modeltype & ghmmwrapper.kBackgroundDistributions:
            self.graphMenu.add_command(label='Edit background distributions', command=self.EditBackgroundDistributions)
        if self.modeltype & ghmmwrapper.kTiedEmissions:
            self.graphMenu.add_command(label='Edit tie groups', command=self.EditTieGroups)
        self.graphMenu.add_separator()
        self.graphMenu.add_checkbutton(label='Grid', command=self.ToggleGridding)
        self.menubar.add_cascade(label="HMM", menu=self.graphMenu, underline=0)

        self.master.configure(menu=self.menubar)

    def SetGraphMenuOptions(self):
        if not self.gridding:
            self.graphMenu.invoke(self.graphMenu.index('Grid'))	


    def CreateWidgets(self):
        toolbar = Frame(self, cursor='hand2', relief=FLAT)
        toolbar.pack(side=LEFT, fill=Y) # Allows horizontal growth

        extra = Frame(toolbar, cursor='hand2', relief=SUNKEN, borderwidth=2)
        extra.pack(side=TOP) # Allows horizontal growth
        extra.rowconfigure(5,weight=1)
        extra.bind("<Enter>", lambda e, gd=self:gd.DefaultInfo())

        px = 0 
        py = 3 

        self.toolVar = StringVar()
        self.lastTool = None

        # Load Icons
        # 0 = "inactive", 1 = "mouse over", 2 = "active"
        self.icons = {
            'AddOrMoveVertex':[PhotoImage(data=GatoIcons.vertex_1),
                               PhotoImage(data=GatoIcons.vertex_2),
                               PhotoImage(data=GatoIcons.vertex_3)],
            'AddEdge':[PhotoImage(data=GatoIcons.edge_1),
                       PhotoImage(data=GatoIcons.edge_2),
                       PhotoImage(data=GatoIcons.edge_3)],
            'DeleteEdgeOrVertex':[PhotoImage(data=GatoIcons.delete_1),
                                  PhotoImage(data=GatoIcons.delete_2),
                                  PhotoImage(data=GatoIcons.delete_3)],
            'SwapOrientation':[PhotoImage(data=GatoIcons.swap_1),
                               PhotoImage(data=GatoIcons.swap_2),
                               PhotoImage(data=GatoIcons.swap_3)],
            'EditWeight':[PhotoImage(data=GatoIcons.edit_1),
                          PhotoImage(data=GatoIcons.edit_2),
                          PhotoImage(data=GatoIcons.edit_3)],
            'EditProperties':[PhotoImage(data=GatoIcons.edit_1),
                              PhotoImage(data=GatoIcons.edit_2),
                              PhotoImage(data=GatoIcons.edit_3)] }
        self.buttons = {}
        values = ['AddOrMoveVertex','AddEdge','DeleteEdgeOrVertex',
                  'SwapOrientation','EditWeight', 'EditProperties']

        text = {'AddOrMoveVertex':'Add or move vertex','AddEdge':'Add edge',
                'DeleteEdgeOrVertex':'Delete edge or vertex',
                'SwapOrientation':'Swap orientation','EditWeight':'Edit Weight',
                'EditProperties':'Edit Properties'}

        row = 0
        for val in values:
            b = Radiobutton(extra, width=32, padx=px, pady=py, 
                            text=text[val],  
                            command=self.ChangeTool,
                            var = self.toolVar, value=val, 
                            indicator=0, image=self.icons[val][0],
                            selectcolor="#AFAFAF",)
            b.grid(row=row, column=0, padx=2, pady=2)
            self.buttons[val] = b
            b.bind("<Enter>", lambda e,gd=self:gd.EnterButtonCallback(e))
            b.bind("<Leave>", lambda e,gd=self:gd.LeaveButtonCallback(e))
            row += 1
            
        self.defaultButton = self.buttons['AddOrMoveVertex']
        # default doesnt work as config option
        GraphEditor.CreateWidgets(self)


    def MouseUp(self,event):
        if self.mode == 'AddOrMoveVertex':
            self.AddOrMoveVertexUp(event)
        elif self.mode == 'AddEdge':
            self.AddEdgeUp(event)
        elif self.mode == 'DeleteEdgeOrVertex':
            self.DeleteEdgeOrVertexUp(event)
        elif self.mode == 'SwapOrientation':
            self.SwapOrientationUp(event)
        elif self.mode == 'EditWeight':
            self.EditWeightUp(event)
        elif self.mode == 'EditProperties':
            self.EditPropertiesUp(event)


    def NewGraph(self):
        d = HMMTypeChooser(self.master)

        if d.etype == 'open':
            self.OpenGraph()
            return
        else:
            self.G = ObjectHMM.ObjectHMM(ObjectHMM.State, ObjectHMM.Transition, etype=d.etype)

        self.G.edit(self)

        self.graphName = "New"
        self.ShowGraph(self.G, self.graphName)
        #self.RegisterGraphInformer(HMMInformer(self.G))
        self.fileName = None
        self.SetTitle("HMMEd 0.8_beta1")
        self.modeltype = self.G.modelType
        self.makeMenuBar()
        self.SetGraphMenuOptions()

    def OpenGraph(self):
        file = askopenfilename(title="Open HMM",
                               defaultextension=".xml",
                               filetypes = (("XML", ".xml"),
                                            )
                               )
        if file is "":
            print "cancelled"
        else:
            self.fileName = file
            self.graphName = stripPath(file)
            e = extension(file)
            
            if e == 'xml':
                self.G.openXML(file)
            else:
                print "Unknown extension"
                return

            self.ShowGraph(self.G, self.graphName)
            #self.RegisterGraphInformer(HMMInformer(self.HMM))
            self.SetTitle("HMMEd 0.8_beta1 - " + self.graphName)
            self.modeltype = self.G.modelType
            self.makeMenuBar()
            
            if not self.gridding:
                self.graphMenu.invoke(self.graphMenu.index('Grid'))

    def SaveGraph(self):
        #self.dirty = 0
        if self.fileName != None:
            self.G.writeXML(self.fileName)
        else:
            self.SaveAsGraph()
            
    def SaveAsGraph(self):
        file = asksaveasfilename(title="Save HMM",
                                 defaultextension=".xml",
                                 filetypes = ( ("XML", ".xml"),
                                               )
                                 )
        if file is not "":
            self.fileName = file
            self.dirty = 0
            self.G.writeXML(self.fileName)
            self.graphName = stripPath(file)
            self.SetTitle("HMMEd 0.8_beta1 - " + self.graphName)


    def EditAlphabet(self):
        if self.G.modelType & ghmmwrapper.kHigherOrderEmissions and self.G.Order() > 0:
            print "not implemented, edit the alphabet before adding states"
        else:
            self.G.alphabet.editDialog(self, self.G)


    def EditPrior(self):
        if self.G.Order() == 0:
            return

        emission_probabilities = ProbEditorBasics.ProbDict({})
        for state in self.G.vertices.values():
            label  = str(state.id)
            weight = state.initial
            emission_probabilities.update({label:weight})

        emission_probabilities.renorm_to(1.0)

        e = ProbEditorBasics.emission_data(emission_probabilities)
        d = ProbEditorDialogs.emission_dialog(self, e, "initial probabilities")

        if d.success():
            # write back normalized probabilities
            emission_probabilities.renorm_to(1.0)
            for key in emission_probabilities.keys():
                state = self.G.vertices[int(key)]
                state.initial = typed_assign(state.initial, emission_probabilities[key])


    def EditClassLabels(self):
        self.G.label_alphabet.editDialog(self, self.G)


    def EditBackgroundDistributions(self):
        self.G.backgroundDistributions.editDialog(self, self.G)
        
    def EditTieGroups(self):
        self.G.tie_groups.editDialog(self, self.G)


    def EditWeightUp(self,event):
        if event.widget.find_withtag(CURRENT):
            widget = event.widget.find_withtag(CURRENT)[0]
            tags = self.canvas.gettags(widget)
            if "edges" in tags:
                (tail,head) = self.edge[widget]
                
                transition_probabilities=ProbEditorBasics.ProbDict({})
                for head in self.G.OutNeighbors(tail):
                    weight=self.G.GetEdgeWeight(0,tail,head)
                    label = "-> %d" % head
                    transition_probabilities.update({label:weight})
                    
                if transition_probabilities.sum==0:
                    key_list=transition_probabilities.keys()
                    for key in key_list:
                        transition_probabilities[key]=1.0/len(key_list)
                e = ProbEditorBasics.emission_data(transition_probabilities)
                d = ProbEditorDialogs.emission_dialog(self, e,
                                                      "transition probs from state %d" % tail)
                if d.success():
                    # write back normalized probabilities
                    for key in transition_probabilities.keys():
                        head = int(key[3:])
                        self.G.SetEdgeWeight(0, tail, head, transition_probabilities[key]/transition_probabilities.sum)

            else: # We have a vertex
                v = self.FindVertex(event)
                if v != None:
                    self.G.vertices[v].editEmissions(self.master)

    def EditPropertiesUp(self, event):
        if event.widget.find_withtag(CURRENT):
            widget = event.widget.find_withtag(CURRENT)[0]
            tags = self.canvas.gettags(widget)        
            if "edges" not in tags:
                v = self.FindVertex(event)
                if v != None:
                    self.G.vertices[v].editProperties(self.master)
                    self.UpdateVertexLabel(v)

    def AddVertex(self):
        """ Add an isolated vertex. Returns the id of the new vertex """
        id = ObjectGraph.AddVertex(self)
        self.G.edges[id].itsHMM = self.G
        return id

class Start:

    def __init__(self):
        graphEditor = SAGraphEditorToplevel()
        graphEditor.NewGraph()
        import logging
        log = logging.getLogger("HMMEditor.py")
        
        ################################################################################
if __name__ == '__main__':
    
    # Overide default colors for widgets ... maybe shouldnt be doing that for Windows?
    tk = Tk()
    tk.option_add('*ActiveBackground','#EEEEEE')
    tk.option_add('*background','#DDDDDD')
    tk.option_add('Tk*Scrollbar.troughColor','#CACACA')
    HMMEditor = HMMGraphEditor(tk)
    HMMEditor.NewGraph()
    import logging
    log = logging.getLogger("HMMEditor.py")
    HMMEditor.mainloop()