xmlutil.py

一个通用的隐性马尔可夫C代码库 开发环境:C语言 简要说明:这是一个通用的隐性马尔可夫C代码库

                symbol.setAttribute('desc', "%s" % self.desc[key])
            writeContents(XMLDoc, symbol, "%s" % self.name[key])
            map.appendChild(symbol)
        XMLNode.appendChild(map)
   
    def buildList(self):
	return self.name.keys()
     
# -------------------------------------------
#  Exceptions

class HMMEdError(Exception):
    def __init__(self, message):
	print "\n\n Unknown error types. Please report \n\n"
	
class NotValidHMMType(HMMEdError):
    def __init__(self,message):
       print "\n\n Probabilities missing xception: " + str(message) + "\n"

class AlphabetErrorType(HMMEdError):
    def __init__(self,message):   
        print "\n\n Alphabet exception: " + str(message) + "\n"
	
	
class DiscreteHMMAlphabet(DOM_Map):
    def __init__(self):
        DOM_Map.__init__(self)
        self.hmm_type = 'discrete'

    def fromDOM(self, XMLNode):
        """Take dom subtree representing a <hmm:alphabet</hmm:alphabet> element"""
        self.initialize()
        # Not reading: hmm:low hmm:high
        if XMLNode.getAttribute("hmm:type") == self.hmm_type:
            self.symbolsFromDom(XMLNode)
        else:
            print "DiscreteHMMAlphabet wrong type %s" % XMLNode.getAttribute("hmm:type") 

    def toDOM(self, XMLDoc, XMLNode):
        hmmalphabet = XMLDoc.createElement("hmm:alphabet")
        hmmalphabet.setAttribute('hmm:type', 'discrete')
	hmmalphabet.setAttribute('hmm:low', "%s" % self.low())
        hmmalphabet.setAttribute('hmm:high', "%s" % self.high())
        map = XMLDoc.createElement("map")  
        for key in self.name.keys():
            symbol = XMLDoc.createElement("symbol")
            symbol.setAttribute('code', "%s" % key)
            if self.hasDesc and self.desc[key] != "":
                symbol.setAttribute('desc', "%s" % self.desc[key])
            writeContents(XMLDoc, symbol, "%s" % self.name[key])
            map.appendChild(symbol)
        hmmalphabet.appendChild(map)
	#  DOM_Map.toDOM(self, XMLDoc, hmmalphabet)
        XMLNode.appendChild(hmmalphabet)

    def toGHMM(self, XMLDoc, XMLNode):
        hmmalphabet = XMLDoc.createElement("alphabet")
        for key in self.name.keys():
            alphabet = XMLDoc.createElement("symbol")
            alphabet.setAttribute('id', "%s" % key)
            hmmalphabet.appendChild(alphabet)
        XMLNode.appendChild(hmmalphabet)
      
   
    def size(self):
        return len(self.name.keys())
    
    def buildList(self):
	return self.name.keys()

    def buildAlphabets(self, nrOfSymbols):
	""" Only fixed to 5 symbols for the moment """ 
	alphas = range(1, nrOfSymbols+1)
	alphas = map( lambda x: 'a'+ str(x), alphas)
	for code in range(1,nrOfSymbols+1):
	    self.addCode( code, alphas[code-1], desc = None)
 
	
class HMMClass(DOM_Map):
    def __init__(self):
        DOM_Map.__init__(self)
    
    def fromDOM(self, XMLNode):
        """Take dom subtree representing a <hmm:class></hmm:class> element"""
        self.initialize()
        self.symbolsFromDom(XMLNode)

    def toDOM(self, XMLDoc, XMLNode):
        hmmclass = XMLDoc.createElement("hmm:class")   
        DOM_Map.toDOM(self, XMLDoc, hmmclass)
        XMLNode.appendChild(hmmclass)

    def size(self):
        return len(self.name.keys())
            
class HMMState:

    def __init__(self, nodeIndex, itsHMM):

        self.initial  = Probability("0.0")
        self.label    =  ValidatingString("None")
        self.itsHMM   = itsHMM
	print type(self.label)
	
        self.index = nodeIndex # The node index in the underlying graph
        self.id    = ValidatingString("None") # identification by the canvas, not always the same
	
	self.state_class = DefaultedInt()
	self.state_class.setDefault(0,'')
	
        # XXX self.state_class.setPopup(itsHMM.hmmClass.name, itsHMM.hmmClass.name2code, 10)

	self.order = DefaultedInt()
        self.order.setDefault(1, 0) # the default state order is 0

        self.emissions = []

        self.tiedto = DefaultedString()
        self.tiedto.setDefault(1, '')
        self.desc = self.id

        self.reading_frame = PopupableInt(-1)
        code2name = {-1:'None', 0:'0', 1:'1', 2:'2'}
        name2code = {'None':-1, '0':0, '1':1, '2':2}
        self.reading_frame.setPopup(code2name, name2code, 4)

        self.duration = DefaultedInt()
        self.duration.setDefault(1, 0)

        self.background = PopupableInt(-1)
        self.background.setPopup(self.itsHMM.backgroundDistributions.code2name, self.itsHMM.backgroundDistributions.name2code, 10)

        self.editableAttr = ['label', 'initial', 'order', 'background']
        self.xmlAttr = self.editableAttr + ['ngeom', 'emissions']
        
    editableAttr = ['label', 'initial']
    xmlAttr = editableAttr + ['ngeom', 'emissions']
    # ['id', 'state_class', 'label', 'order', 'initial', 'tiedto', 'reading_frame', 'duration', 'background']

    #
    # Set_<Attribute> Methods: for integration with class editobj.Editor.set_value()
    # the name of the method must be in the form of set_<attr name>(self,value).
    # Otherwise, EditObj cannot propogate new values. (See the base method editobj.EntryEditor.set_value())
    # When necessary, we also update the Graph here.
    #
    def set_label(self, value):
        # Get the id2index from the Graph
        oldv = self.itsHMM.id2index[self.id]
        self.label = typed_assign(self.label, value)
        
        # We only show the label out of the editable items
        self.itsHMM.G.labeling[oldv] = "%s\n%s" % (self.id, self.label) # XXX Hack Aaaargh!
        self.itsHMM.itsEditor.UpdateVertexLabel(oldv, 0)


    def set_initial(self, value):
        self.initial = typed_assign(self.initial, value)

    def fromDOM(self, XMLNode):

        self.id = ValidatingString(XMLNode.attributes['id'].nodeValue.encode('ascii', 'replace'))
        
        self.index = self.itsHMM.G.AddVertex()
        
        datas = XMLNode.getElementsByTagName("data")
        for data in datas:
            dataKey = data.attributes['key'].nodeValue
            dataValue = data.firstChild.nodeValue

            #print dataValue
            
            #  if dataValue == None: # use default Value
            #     self.state_class = typed_assign(self.state_class, int(0))
            #  else:
            #      self.state_class = typed_assign(self.state_class, int(dataValue))

            if dataKey == 'class':
                self.state_class = typed_assign(self.state_class, int(0))
                    
            elif  dataKey == 'label':
                self.label = type(self.label)(dataValue.encode('ascii', 'replace'))

            elif  dataKey == 'order':
                if dataValue == None: # use default value
                    self.order = typed_assign(self.order, self.order.defaultValue)
                    self.order.useDefault = 1
                else:
                    self.order = typed_assign(self.order, int(dataValue))
                    self.order.useDefault = 0

            elif  dataKey == 'initial':
                self.initial = typed_assign(self.initial, float(dataValue))
                
            elif  dataKey == 'tiedto':
                
                if dataValue == None: # use default value
                    self.tiedto = typed_assign(self.tiedto, self.tiedto.defaultValue)
                    self.tiedto.useDefault = 1
                else:
                    self.tiedto = typed_assign(self.tiedto, dataValue.encode('ascii', 'replace'))
                    self.tiedto.useDefault = 0

            elif dataKey == 'reading-frame':
                self.reading_frame = typed_assign(self.reading_frame, int(dataValue))

            elif dataKey == 'background':
                self.background = typed_assign(self.background, self.itsHMM.backgroundDistributions.name2code[dataValue])

            elif dataKey == 'duration':
                self.duration = typed_assign(self.duration, int(dataValue))
                self.duration.useDefault = 0
                                    
            elif dataKey == 'ngeom':
                # We only use pos
                pos = XMLNode.getElementsByTagName('pos')[0] # Just one pos ...                
                self.pos = Point2D(float(pos.attributes['x'].nodeValue),
                                   float(pos.attributes['y'].nodeValue))
                
            elif dataKey == 'emissions':
                # collect all strings from childnodes
                dataValue = ""
                for child in data.childNodes:
                    dataValue += child.nodeValue
                self.emissions = listFromCSV(dataValue, types.FloatType)
                #print self.emissions
                    
            else:
                print "HMMState.fromDOM: unknown key %s of value %s" % (dataKey, dataValue)
        

    def toDOM(self, XMLDoc, XMLNode, initial_sum):
        node = XMLDoc.createElement("node")
        node.setAttribute('id', "%s" % self.id)

        # Mandatory elems
        writeData(XMLDoc, node, 'label', self.label)
        writeData(XMLDoc, node, 'class', self.state_class)
        writeData(XMLDoc, node, 'initial', self.initial / initial_sum)
       
	pos = self.itsHMM.G.embedding[self.index] 
        pos_elem = XMLDoc.createElement("pos")
        pos_elem.setAttribute('x', "%s" % pos.x)
        pos_elem.setAttribute('y', "%s" % pos.y)
        writeXMLData(XMLDoc, node, 'ngeom', pos_elem)

        if not self.order.useDefault:
            writeData(XMLDoc, node, 'order', self.order)

        if self.reading_frame != -1:
            writeData(XMLDoc, node, 'reading-frame', self.reading_frame)

        if self.background != -1:
            writeData(XMLDoc, node, 'background', self.itsHMM.backgroundDistributions.code2name[self.background])

        if not self.duration.useDefault:
            writeData(XMLDoc, node, 'duration', self.duration)
           
        if not self.tiedto == '':
            writeData(XMLDoc, node, 'tiedto', self.tiedto)
        else:
            if self.order.useDefault:
                order = 0
            else:
                order = self.order

            # XXX Produce uniform emission probs, if we dont have the correct number of
            # parameters
            
            size = self.itsHMM.hmmAlphabet.size()**(order+1)
            if len(self.emissions) != size:
                tmp = [1.0/self.itsHMM.hmmAlphabet.size()] * self.itsHMM.hmmAlphabet.size()
                if order == 0:
                    self.emissions = tmp
                else:
                    self.emissions = tmp * self.itsHMM.hmmAlphabet.size()**order
                    
                
            if order > 0:
                writeData(XMLDoc, node, 'emissions', csvFromList(self.emissions,
                                                                 self.itsHMM.hmmAlphabet.size()))
            else:
                writeData(XMLDoc, node, 'emissions', csvFromList(self.emissions))
            
        XMLNode.appendChild(node)