def test_AngleEMList_focusRotation(self):
from pytom.angles.globalSampling import GlobalSampling
from pytom_volume import vol
import os
v = vol(3, 2, 1)
v.setAll(1)
v.write('./angs.em')
ang = GlobalSampling('angs.em', True)
os.system('rm angs.em')
ang2 = ang.focusRotation([1, 1, 1])
self.assertTrue(ang2.__class__ == GlobalSampling)
def test_GlobalLocalCombined(self):
from pytom.angles.combined import GlobalLocalCombined
from pytom.angles.localSampling import LocalSampling
from pytom.angles.globalSampling import GlobalSampling
ls = LocalSampling(1.0, 3.0, 123.370865619, 134.740207266,
95.2352127297)
gs = GlobalSampling('angles_07_45123.em')
gl = GlobalLocalCombined(gs, ls)
def readAll(self):
"""
readAll: Read all the specified files from the disk (except the original volume)
"""
from pytom.localization.structures import Volume, Orientation
self.result = Volume(self.resultFilename).getVolume()
self.orient = Orientation(self.orientFilename).getVolume()
if self.angleListFilename != '':
from pytom.angles.globalSampling import GlobalSampling
self.angleList = GlobalSampling(
self.angleListFilename).getRotations()
def fromXML(self,xmlObj):
from lxml.etree import _Element
from pytom.angles.globalSampling import GlobalSampling
from pytom.angles.localSampling import LocalSampling
if xmlObj.__class__ != _Element:
raise TypeError('You must provide a valid XML-AngleEquidistant object.')
self._currentSamplingIsGlobal = bool(xmlObj.get('currentIsGlobal'))
globalXML = xmlObj.xpath("Angles[@Type='GlobalSampling']")
if len(globalXML) == 0:
globalXML = xmlObj.xpath("Angles[@Type='FromEMFile']")
globalSampling = GlobalSampling()
globalSampling.fromXML(globalXML[0])
self._globalSampling = globalSampling
localXML = xmlObj.xpath("Angles[@Type='LocalSampling']")
if len(localXML) == 0:
localXML = xmlObj.xpath("Angles[@Type='EquidistantList']")
localSampling = LocalSampling()
localSampling.fromXML(localXML[0])
self._localSampling = localSampling
def fromXML(self,xmlObj, verbose=False):
"""
fromXML: Creates any AngleObject child depending xmlObj
@param xmlObj: a XML DOM object
@param verbose: verbose mode?
@type verbose: L{bool}
@return: an Angle List as defined by xmlObj
@author: Thomas Hrabe
G{callgraph}
"""
angType = xmlObj.get('Type')
if angType == 'Eulerian':
from pytom.angles.angleList import EulerAngleList
ang = EulerAngleList()
ang.fromXML(xmlObj)
elif angType == 'Equidistant':
from pytom.angles.localSampling import LocalSampling
ang = LocalSampling()
ang.fromXML(xmlObj)
elif angType == 'AV3Sampling':
from pytom.angles.localSampling import AV3Sampling
ang = AV3Sampling()
ang.fromXML(xmlObj)
elif angType == 'ExtendedInplaneSampling':
from pytom.angles.localSampling import ExtendedInplaneSampling
ang = ExtendedInplaneSampling()
ang.fromXML(xmlObj)
elif angType == 'GlobalSampling':
from pytom.angles.globalSampling import GlobalSampling
ang = GlobalSampling()
ang.fromXML(xmlObj)
elif angType == 'FromEMFile':
from pytom.angles.globalSampling import GlobalSampling
ang = GlobalSampling()
ang.fromXML(xmlObj)
elif angType == 'AngleList':
from pytom.angles.angleList import AngleList
ang = AngleList()
ang.fromXML(xmlObj)
elif angType == 'OneAngleList':
from pytom.angles.angleList import OneAngleList
ang = OneAngleList()
ang.fromXML(xmlObj)
elif angType == 'LocalSampling':
from pytom.angles.localSampling import LocalSampling
ang = LocalSampling()
ang.fromXML(xmlObj)
#elif angType == 'RestrictedInplaneLocalSampling':
# from pytom.angles.localSampling import InplaneLocalSampling
# ang = RestrictedInplaneEuidistantList()
# ang.fromXML(xmlObj)
elif angType == 'EquidistantList':
from pytom.angles.localSampling import LocalSampling
ang = LocalSampling()
ang.fromXML(xmlObj)
#elif angType == 'RestrictedInplaneEuidistantList':
# from pytom.angles.localSampling import RestrictedInplaneLocalSampling
# ang = RestrictedInplaneEuidistantList()
# ang.fromXML(xmlObj)
elif angType == 'Combined':
from pytom.angles.combined import GlobalLocalCombined
ang = GlobalLocalCombined()
ang.fromXML(xmlObj)
else:
raise TypeError('Type ' +angType+' not available in Angles.')
if verbose:
print("AngleObject.fromXML: Returned AngleObject: "+str(ang))
self.ang = ang
return ang
def interpretRequestParameters(parameters):
from pytom.localization.peak_job import PeakJob
from pytom.localization.structures import Volume
from pytom.basic.structures import Mask, Reference, WedgeInfo
from pytom.angles.globalSampling import GlobalSampling
from pytom.basic.structures import BandPassFilter
from pytom.frontend.serverpages.serverMessages import FileMessage
if 'tomo' in parameters:
vol = Volume(parameters['tomo'])
else:
raise RuntimeError('Parameter missing in request!')
if 'ref' in parameters:
ref = Reference(parameters['ref'])
else:
raise RuntimeError('Parameter missing in request!')
if 'mask' in parameters:
mask = Mask(parameters['mask'])
else:
raise RuntimeError('Parameter missing in request!')
if 'angle' in parameters:
ang = GlobalSampling(parameters['angle'])
else:
raise RuntimeError('Parameter missing in request!')
if 'dest' in parameters:
dest = parameters['dest']
else:
dest = './'
if 'low' in parameters:
low = float(parameters['low'])
else:
raise RuntimeError('Parameter missing in request!')
if 'high' in parameters:
high = float(parameters['high'])
else:
raise RuntimeError('Parameter missing in request!')
if 'smooth' in parameters:
smooth = float(parameters['smooth'])
else:
raise RuntimeError('Parameter missing in request!')
if 'w1' in parameters:
w1 = float(parameters['w1'])
else:
raise RuntimeError('Parameter missing in request!')
if 'w2' in parameters:
w2 = float(parameters['w2'])
else:
raise RuntimeError('Parameter missing in request!')
if 'x' in parameters:
x = float(parameters['x'])
else:
x = 0
if 'y' in parameters:
y = float(parameters['y'])
else:
y = 0
if 'z' in parameters:
z = float(parameters['z'])
else:
z = 0
bp = BandPassFilter(low, high, smooth)
wedge = WedgeInfo([w1, w2])
from pytom.score.score import FLCFScore
sc = FLCFScore()
job = PeakJob(vol,
ref,
mask,
wedge,
ang,
dstDir=dest,
score=sc,
bandpass=bp)
jobXMLFile = ''
if 'jobFile' in parameters:
jobXMLFile = parameters['jobFile']
job.toXMLFile(jobXMLFile)
if jobXMLFile[-4:] == '.xml':
jobRunFile = jobXMLFile[0:-4]
else:
jobRunFile = jobXMLFile
createRunscripts(jobRunFile + '.sh', jobXMLFile, x, y, z)
return FileMessage('LocalizationJob', jobXMLFile, 'created')
if not checkDirExists(destination):
raise RuntimeError('Destination directory ' + destination +
' does not exist!')
from pytom.basic.structures import Mask, Reference, Wedge, BandPassFilter
from pytom.localization.structures import Volume
from pytom.angles.globalSampling import GlobalSampling
from pytom.score.score import FLCFScore
from pytom.localization.peak_job import PeakJob
from pytom.frontend.serverpages.createLocalizationJob import createRunscripts
v = Volume(volume)
r = Reference(reference)
m = Mask(mask)
w = Wedge([float(wedge1), float(wedge2)])
a = GlobalSampling(angles)
job = PeakJob(volume=v,
reference=r,
mask=m,
wedge=w,
rotations=a,
score=FLCFScore(),
jobID=0,
members=1,
dstDir=destination,
bandpass=BandPassFilter(0, float(band), 0))
job.toXMLFile(jobName)
createRunscripts(jobName[:-3] + 'sh', jobName, int(sx), int(sy), int(sz))
@param splitType: split type of the job
@type splitType: "Ang" or "Vol"
"""
def __init__(self, jobID=-1, originalJobID=-1, splitType=None):
self.jobID = jobID
self.originalJobID = originalJobID
self.splitType = splitType
if __name__ == '__main__':
from pytom.basic.structures import Mask, Reference, WedgeInfo
from pytom.localization.structures import Volume
from pytom.score.score import FLCFScore, xcfScore
from pytom.localization.peak_job import PeakJob
v = Volume('/fs/pool/pool-foerster/apps/src/molmatch/test/testvol.em')
ref = Reference('/fs/pool/pool-foerster/apps/src/molmatch/test/templ.em')
m = Mask('/fs/pool/pool-foerster/apps/src/molmatch/test/mask_15.em', True)
w = WedgeInfo(0)
s = FLCFScore()
from pytom.angles.globalSampling import GlobalSampling
r = GlobalSampling(
'/fs/home/ychen/develop/pytom/trunk/pytom/pytomc/libs/libtomc/data/common_data/angles_90_26.em'
)
job = PeakJob(v, ref, m, w, r, s)
job.toXMLFile('JobInfo.xml')
job.toHTMLFile('JobInfo.html')
def interpretRequestParameters(parameters):
"""
interpretRequestParameters
"""
from pytom.basic.structures import ParticleList, SampleInformation, Reference, Mask, Wedge, PointSymmetry
from pytom.alignment.preprocessing import Preprocessing
from pytom.frontend.serverpages.serverMessages import FileMessage
particleList = ParticleList('.')
if 'plXML' in parameters:
particleList.fromXMLFile(parameters['plXML'])
elif 'plDIR' in parameters:
particleList = ParticleList(parameters['plDIR'])
particleList.loadDirectory()
else:
raise RuntimeError('ParticleList parameter missing in request!')
sampleInfo = SampleInformation()
if 'pixSize' in parameters:
sampleInfo.setPixelSize(parameters['pixSize'])
else:
raise RuntimeError('Pixelsize parameter missing in request!')
if 'partDia' in parameters:
sampleInfo.setParticleDiameter(parameters['partDia'])
else:
raise RuntimeError('Particle diameter missing in request!')
reference = ''
if 'ref' in parameters:
reference = Reference(parameters['ref'])
else:
raise RuntimeError('Reference parameter missing in request!')
if 'mask' in parameters:
mask = Mask(parameters['mask'])
else:
raise RuntimeError('Mask parameter missing in request!')
angles = None
if 'sampling' in parameters:
if parameters['sampling'] == 'GLOBAL':
from pytom.angles.globalSampling import GlobalSampling
if 'angFile' in parameters:
angles = GlobalSampling(parameters['angFile'])
else:
raise RuntimeError('Angle file missing in request!')
else:
from pytom.angles.localSampling import LocalSampling
if 'angStart' in parameters:
startIncrement = int(parameters['angStart'])
else:
raise RuntimeError('Angle start missing in request!')
if 'angShells' in parameters:
shells = int(parameters['angShells'])
else:
raise RuntimeError('Angle shells missing in request!')
if 'angInc' in parameters:
shellIncrement = int(parameters['angInc'])
else:
raise RuntimeError('Angle increment missing in request!')
angles = LocalSampling(shells=shells, increment=startIncrement)
else:
raise RuntimeError('Sampling completely missing in request!')
if not 'lowestF' in parameters:
raise RuntimeError('Lowest frequency parameter missing in request!')
if not 'highestF' in parameters:
raise RuntimeError('Highest frequency parameter missing in request!')
if not 'filtSm' in parameters:
raise RuntimeError('Filter smooth parameter missing in request!')
preprocessing = Preprocessing(float(parameters['lowestF']),
float(parameters['highestF']),
float(parameters['filtSm']))
adaptive = True
if 'adapt' in parameters:
fscCriterion = 0.5
resOffset = 0.1
angleFactor = 0.5
adaptive = parameters['adapt'] == 'ON'
if parameters['adapt'] == 'ON':
if 'adResC' in parameters:
fscCriterion = float(parameters['adResC'])
else:
raise RuntimeError('Resolution criterion missing in request!')
if 'adResOf' in parameters:
resOffset = parameters['adResOf']
else:
raise RuntimeError(
'Resolution offset parameter missing in request!')
if 'angFac' in parameters:
angleFactor = float(parameters['angFac'])
else:
raise RuntimeError(
'Angular factor parameter missing in request!')
else:
raise RuntimeError('Adaptive parameter missing in request!')
score = None
if 'score' in parameters:
if parameters['score'] == 'xcf':
from pytom.score.score import xcfScore as scoreClass
elif parameters['score'] == 'nxcf':
from pytom.score.score import nxcfScore as scoreClass
elif parameters['score'] == 'flcf':
from pytom.score.score import FLCFScore as scoreClass
score = scoreClass()
else:
raise RuntimeError('Score parameter missing in request!')
if 'pkPriRad' in parameters:
radius = float(parameters['pkPriRad'])
else:
raise RuntimeError('Peak distance parameter missing in request!')
if 'pkSmooth' in parameters:
smooth = float(parameters['pkSmooth'])
else:
raise RuntimeError('Peak distance smooth missing in request!')
score.setPeakPrior(radius=radius, smooth=smooth)
if 'iter' in parameters:
iterations = int(parameters['iter'])
else:
raise RuntimeError('Number of iterations missing in request!')
if 'binning' in parameters:
binning = int(parameters['binning'])
else:
raise RuntimeError('Scaling parameter missing in request!')
if 'dest' in parameters:
destination = parameters['dest']
else:
raise RuntimeError('Destination parameter missing in request!')
from pytom.alignment.ExMaxAlignment import ExMaxJob
job = ExMaxJob(particleList, destination, reference, score, angles, mask,
PointSymmetry(1), 1, iterations, preprocessing, -1, binning,
sampleInfo, fscCriterion, adaptive, resOffset, angleFactor)
#print job
jobXMLFile = ''
if 'jobFile' in parameters:
jobXMLFile = parameters['jobFile']
job.toXMLFile(jobXMLFile)
if jobXMLFile[-4:] == '.xml':
jobRunFile = jobXMLFile[0:-4]
else:
jobRunFile = jobXMLFile
createRunscripts(jobRunFile + '.sh', jobXMLFile)
return FileMessage('AlignmentJob', jobXMLFile, 'created')