def fromXML(self, xmlObj):
"""
@param xmlObj: A xml object
@type xmlObj: L{lxml.etree._Element}
@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-WedgeInfo object.'
)
from pytom.alignment.structures import MaximisationResult
if xmlObj.tag == 'AlignmentList':
list_element = xmlObj
else:
list_element = xmlObj.xpath('AlignmentList')
list_element = list_element[0]
self._alignmentList = []
for child in list_element.iter('Result'):
result = MaximisationResult()
result.fromXML(child)
self._alignmentList.append(result)
def distanceOfShifts(self, oldAlignmentList):
"""
distanceOfShifts: Determines distance of current shifts from previous shifts
@param oldAlignmentList:
"""
from pytom.tools.maths import euclidianDistance, listMean, listStd
distance = []
numberResults = len(self)
oldListXML = oldAlignmentList.toXML()
for i in xrange(0, numberResults):
newResult = self[i]
particle = newResult.getParticle()
try:
oldResultXML = oldListXML.xpath(
'/AlignmentList/Result/Particle[@Filename="' +
particle.getFilename() + '"]/..')
oldResult = MaximisationResult()
oldResult.fromXML(oldResultXML[0])
except:
numberResults = numberResults - 1
continue
newShift = newResult.getShift()
oldShift = oldResult.getShift()
d = euclidianDistance(newShift.toVector(), oldShift.toVector())
distance.append(d)
return [listMean(distance), listStd(distance)]
class MaximisationResultMsg(Message):
result = -1
def setResult(self, result):
self.result = result
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:
raise TypeError(
'Is not a lxml.etree._Element! You must provide a valid XML-MaximisationResultMsg object.'
)
from pytom.alignment.structures import MaximisationResult
message = xmlObj.xpath('Message')
message = message[0]
self._sender = message.get('Sender')
self._recipient = message.get('Recipient')
self._timestamp = message.get('Timestamp')
self.result = MaximisationResult('', '', '', '', '')
self.result.fromXML(xmlObj)
def toXML(self):
"""
toXML : Compiles a XML from result object
@author: Thomas Hrabe
"""
from lxml import etree
resMsg = etree.Element("MaximisationResultMsg")
messageElement = etree.Element("Message",
Sender=self._sender,
Recipient=self._recipient,
Timestamp=self._timestamp.__str__())
resMsg.append(messageElement)
resultElement = self.result.toXML()
resMsg.append(resultElement)
return resMsg
def classifyResultScores(self, peakPercentage=10):
"""
classifyList: Classifies results according to their score value. Any result will remain unless it's score value is greater than the mean score value / percentage
@param peakPercentage: value of score. The formula is mean * peakPercentage / 100. Default value will be 10. Negative values are also valid.
@return: alignmentList of 'good' results. (if no result matches the criterion, all results will be returned)
"""
from pytom.alignment.structures import MaximisationResult
#get all score values from results through xpath
values = self.xpath('/AlignmentList/Result/Score/@Value')
mean = 0
for value in values:
mean = mean + float(value)
#determine mean score value
mean = mean / len(values)
classificationValue = mean * peakPercentage / 100
#select all results above threshold through xpath
goodResults = self.xpath('/AlignmentList/Result[Score/@Value >= ' +
str(classificationValue) + ']')
newResults = []
for resultXML in goodResults:
result = MaximisationResult()
result.fromXML(resultXML)
newResults.append(result)
newAl = AlignmentList()
if len(newResults) > 0:
newAl.setList(newResults)
else:
newAl = self
return newAl
def distanceOfRotations(self, oldAlignmentList):
"""
distanceOfRotations:Determines distance of current rotations from previous rotations
@param oldAlignmentList:
"""
from pytom.tools.maths import listMean, listStd
distance = []
numberResults = len(self)
oldListXML = oldAlignmentList.toXML()
for i in xrange(0, numberResults):
newResult = self[i]
particle = newResult.getParticle()
try:
#oldResult = oldAlignmentList.getResultByParticle(particle)
oldResultXML = oldListXML.xpath(
'/AlignmentList/Result/Particle[@Filename="' +
particle.getFilename() + '"]/..')
oldResult = MaximisationResult()
oldResult.fromXML(oldResultXML[0])
except:
numberResults = numberResults - 1
continue
newRotation = newResult.getRotation()
oldRotation = oldResult.getRotation()
newQuaternion = newRotation.toQuaternion()
oldQuaternion = oldRotation.toQuaternion()
d = newQuaternion.distance(oldQuaternion)
distance.append(d)
return [listMean(distance), listStd(distance)]
def getResultByParticle(self, particle, alXML=None):
"""
getResultByParticle: Returns alignment result of specified particle
@param particle: The particle
@type particle: Either str of L{pytom.basic.structures.Particle}
@rtype: L{pytom.alignment.structures.MaximizationResult}
"""
from pytom.basic.structures import Particle
if alXML == None:
alXML = self.toXML()
if particle.__class__ == Particle:
particleName = particle.getFilename()
else:
particleName = particle
#r = alXML.xpath('/AlignmentList/Result/Particle[@Filename="' + particleName + '"]/..')
#if len(r) == 0:
# raise Exception('Particle ' + particle.getFilename() + ' was not found in this alignment list!')
result = None
found = False
for res in self._alignmentList:
if found:
break
p = res.getParticle()
if p.getFilename() == particleName:
result = MaximisationResult()
result.fromStr(str(res))
found = True
if not found:
raise RuntimeError('Particle ' + particle.getFilename() +
' was not found in this alignment list!')
return result
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:
raise TypeError(
'Is not a lxml.etree._Element! You must provide a valid XML-MaximisationResultMsg object.'
)
from pytom.alignment.structures import MaximisationResult
message = xmlObj.xpath('Message')
message = message[0]
self._sender = message.get('Sender')
self._recipient = message.get('Recipient')
self._timestamp = message.get('Timestamp')
self.result = MaximisationResult('', '', '', '', '')
self.result.fromXML(xmlObj)
def copy(self):
return MaximisationResult(self._particle, self._reference, self._score,
self._shift, self._rotation,
self._angleObject)
def _expectation(self):
"""
_expectation : Compares two particles. Does not do any alignemnt unless job enables FRMAlignment, this function overloads ExMaxWorker._expectation.
@rtype: List of two objects
@return: [endShift,endRotation] contains the final shift and final rotation.
@author: Thomas Hrabe
"""
from pytom_volume import vol, shift, rotate, read
from pytom.alignment.structures import Peak, MaximisationResult
from pytom.basic.structures import Particle, Reference, Shift, Rotation, Wedge
from pytom.tools.macros import volumesSameSize
from pytom.alignment.alignmentFunctions import compareTwoVolumes
from pytom.angles.angleList import OneAngleList
from pytom.alignment.alignmentFunctions import FRMAlignmentWrapper
try:
from frm import frm_align_vol2
except ImportError:
self._doAlignment = False
if self._particle.__class__ == Particle:
from pytom_volume import read
particleFile = self._particle.getFilename()
particle = read(particleFile, 0, 0, 0, 0, 0, 0, 0, 0, 0,
self._binning, self._binning, self._binning)
else:
raise TypeError(
'Provided particle must be of type pytom.basic.structures.Particle'
)
if self._scoreObject.__class__ == str:
from pytom.score.score import Score
string = self._scoreObject
self._scoreObject = Score()
self._scoreObject.fromStr(string)
if self._reference.wasGeneratedBy(
self._particle) and self._reference.hasPreWedge(
) and self._reference.hasWeighting():
#substract particle from reference if information is available
[reference, self._referenceWeighting
] = self._reference.subtractParticle(self._particle,
self._binning)
referenceObject = self._reference
else:
if self._reference.__class__ == Reference:
from pytom_volume import read
referenceObject = self._reference
referenceFile = self._reference.getReferenceFilename()
reference = read(referenceFile, 0, 0, 0, 0, 0, 0, 0, 0, 0,
self._binning, self._binning, self._binning)
if self._referenceWeighting == str and len(
self._referenceWeighting) > 0:
self._referenceWeightingFile = self._referenceWeighting
if binning == 1:
from pytom_volume import read
self._referenceWeighting = read(self._referenceWeighting)
else:
from pytom.basic.files import readSubvolumeFromFourierspaceFile
self._referenceWeighting = readSubvolumeFromFourierspaceFile(
self._referenceWeightingFile, reference.sizeX(),
reference.sizeY(), reference.sizeZ())
self._mask.setBinning(self._binning)
pScore = self._particle.getScore()
if not pScore:
pScore = self._scoreObject
if self._doAlignment:
#process FRM alignment for each particle and class
peakPrior = self._scoreObject.getPeakPrior()
newShift, newRotation, score = FRMAlignmentWrapper(
particle, self._particle.getWedge(), reference, Wedge([0, 0]),
self._frmBandwidth,
int(self._preprocessing.getHighestFrequency()), self._mask,
self._scoreObject.getPeakPrior())
self._scoreObject.setValue(score)
result = MaximisationResult(
self._particle, referenceObject, self._scoreObject, newShift,
newRotation, OneAngleList(self._particle.getRotation()))
else:
#process classification without alignment only
peakV = compareTwoVolumes(
particle, reference, self._referenceWeighting,
self._particle.getWedge(),
OneAngleList(self._particle.getRotation()),
self._particle.getShift(), self._scoreObject, self._mask,
self._preprocessing, self._binning)
self._scoreObject.setValue(peakV)
result = MaximisationResult(
self._particle, referenceObject, self._scoreObject,
self._particle.getShift(), self._particle.getRotation(),
OneAngleList(self._particle.getRotation()))
return result