def fromXML(self, xmlObj):
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
raise RuntimeError(
'Is not a lxml.etree._Element! You must provide a valid XMLobject.'
)
if xmlObj.tag == 'Angles':
angleList_element = xmlObj
else:
RuntimeError(
'Is not an AngleList! You must provide a valid AngleList object.'
)
from pytom.basic.structures import Rotation
rotations = angleList_element.xpath('Rotation') # modified by chen
for rotation in rotations:
rot = Rotation(0, 0, 0)
rot.fromXML(rotation)
self._rotationList.append(rot)
class MaximisationResult(PyTomClass):
"""
MaximisationResult : Stores results of one maximisation process
"""
def __init__(self,
particle='',
reference=-1.0,
score=-1.0,
shift=-1.0,
rotation=-1.0,
angleObject=-1):
from pytom.basic.structures import Particle, Reference, Shift, Rotation
from numpy import long
if particle.__class__ == str:
self._particle = Particle(particle)
elif particle.__class__ == Particle:
self._particle = particle
else:
self._particle = Particle()
if reference.__class__ == str:
self._reference = Reference(reference)
elif reference.__class__ == Reference:
self._reference = reference
else:
self._reference = Reference()
if shift.__class__ == list:
self._shift = Shift(shift)
elif shift.__class__ == float:
self._shift = Shift()
else:
self._shift = shift
if rotation.__class__ == list:
self._rotation = Rotation(rotation)
elif rotation.__class__ == Rotation:
self._rotation = rotation
else:
self._rotation = Rotation()
if score.__class__ == float:
from pytom.score.score import xcfScore
self._score = xcfScore()
else:
self._score = score
if angleObject.__class__ == float or isinstance(
angleObject, (int, long)):
from pytom.angles.angleList import AngleList
self._angleObject = AngleList()
else:
self._angleObject = angleObject
def toParticle(self):
"""
toParticle: Converts this object to a Particle object.
@return:
@rtype: L{pytom.basic.structures.Particle}
"""
from pytom.basic.structures import Particle
particle = self._particle
particle.setRotation(self._rotation)
particle.setShift(self._shift)
particle.setScore(self._score)
return particle
def getParticle(self):
return self._particle
def getShift(self):
from pytom.basic.structures import Shift
if self._shift.__class__ == list:
return Shift(self._shift)
else:
return self._shift
def setShift(self, shift):
from pytom.basic.structures import Shift
assert shift.__class__ == Shift
self._shift = shift
def getAngleObject(self):
return self._angleObject
def getRotation(self):
from pytom.basic.structures import Rotation
if self._rotation.__class__ == list:
return Rotation(self._rotation[0], self._rotation[1],
self._rotation[2])
else:
return self._rotation.copy()
def getScore(self):
"""
getScore: Returns score object
"""
return self._score
def setRotation(self, rotation):
"""
setRotation:
@param rotation:
"""
from pytom.basic.structures import Rotation
if rotation.__class__ == list:
rotation = Rotation(rotation)
self._rotation = rotation
def fromXML(self, xmlObj):
"""
fromXML : Assigns values to result attributes from XML object
@param xmlObj: A xml object
@author: Thomas Hrabe
"""
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
from pytom.basic.exceptions import ParameterError
raise ParameterError(
'Is not a lxml.etree._Element! You must provide a valid XML object.'
)
from pytom.score.score import fromXML as fromXMLScore
from pytom.angles.angle import AngleObject
if xmlObj.tag == "Result":
result = xmlObj
else:
result = xmlObj.xpath('Result')
if len(result) == 0:
raise PyTomClassError(
"This XML is not an MaximisationResult. No Result provided."
)
result = result[0]
from pytom.basic.structures import Particle, Reference, Rotation, Shift
particle_element = result.xpath('Particle')[0]
p = Particle('')
p.fromXML(particle_element)
self._particle = p
r = result.xpath('Reference')
ref = Reference('')
ref.fromXML(r[0])
self._reference = ref
scoreXML = result.xpath('Score')[0]
self._score = fromXMLScore(scoreXML)
shiftXML = result.xpath('Shift')[0]
self._shift = Shift()
self._shift.fromXML(shiftXML)
rotationXML = result.xpath('Rotation')[0]
self._rotation = Rotation()
self._rotation.fromXML(rotationXML)
angleElement = result.xpath('Angles')
ang = AngleObject()
self._angleObject = ang.fromXML(angleElement[0])
def toXML(self):
"""
toXML : Compiles a XML from result object
@author: Thomas Hrabe
"""
from lxml import etree
resultElement = etree.Element("Result")
resultElement.append(self._particle.toXML())
if self._reference.hasGeneratedByInfo():
from pytom.basic.structures import Reference
newRef = Reference(self._reference.getReferenceFilename())
resultElement.append(newRef.toXML())
else:
resultElement.append(self._reference.toXML())
resultElement.append(self._shift.toXML())
resultElement.append(self._rotation.toXML())
resultElement.append(self._score.toXML())
resultElement.append(self._angleObject.toXML())
return resultElement
def copy(self):
return MaximisationResult(self._particle, self._reference, self._score,
self._shift, self._rotation,
self._angleObject)
class FoundParticle(PyTomClass):
"""
FoundParticle: Class for getting the particle according to the result score volume
"""
def __init__(self, pos=None, orient=None, score=None, filename=''):
"""
@param pos: pick position of the particle
@type pos: L{pytom.basic.structures.PickPosition}
@param orient: orientation of the pick particle
@type orient: L{pytom.basic.structures.Rotation}
@param score: score vaule of the picked particle
@type score: L{pytom.score.score.Score}
@param filename: filename of the found particle, if any
@type filename: string
"""
self.pos = pos
self.orient = orient
self.score = score
self.filename = filename
def getVolume(self):
"""
getVolume: Get volume of the found particle
@rtype: L{pytom_volume.vol}
"""
from pytom_volume import read
from pytom.tools.files import checkFileExists
if not checkFileExists(self._filename):
raise Exception('File ' + self._filename + ' does not exist!')
return read(self.filename)
def getPos(self):
return [ int(i) for i in self.pos.toVector()]
def toXML(self):
from lxml import etree
particle_element = etree.Element('FoundParticle', Filename = self.filename)
particle_element.append(self.pos.toXML())
particle_element.append(self.orient.toXML())
particle_element.append(self.score.toXML())
# class_element = etree.Element('Filename', Name = str(self.filename))
# particle_element.append(class_element)
return particle_element
def fromXML(self, xmlObj):
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
from pytom.basic.exceptions import ParameterError
raise ParameterError('You must provide a valid XML object.')
if xmlObj.tag == "FoundParticle":
main = xmlObj
else:
main = xmlObj.xpath('FoundParticle')
if len(main) == 0:
from pytom.basic.exceptions import PyTomClassError
raise PyTomClassError("This XML is not a FoundParticle.")
main = main[0]
from pytom.basic.structures import PickPosition, Rotation
from pytom.score.score import fromXML as fromXMLScore
self.filename = main.get('Filename')
p = main.xpath('PickPosition')[0]
self.pos = PickPosition()
self.pos.fromXML(p)
o = main.xpath('Rotation')[0]
self.orient = Rotation()
self.orient.fromXML(o)
s = main.xpath('Score')[0]
self.score = fromXMLScore(s)
def toParticle(self):
"""
toParticle: Converts this object to a Particle object.
@rtype: L{pytom.basic.structures.Particle}
"""
from pytom.basic.structures import Particle
return Particle(filename=self.filename, rotation=self.orient, pickPosition=self.pos, score=self.score)
def fromParticle(self, p):
self.filename = p.getFilename()
self.orient = p.getRotation()
self.pos = p.getPickPosition()
self.score = p.getScore()