class CoordinatesTiltPair(TiltPairSet):
"""Represents a Coordinates Tilt Pair"""
ITEM_TYPE = TiltPair
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._angles = SetOfAngles()
self._micsPair = Pointer()
def getAngles(self):
return self._angles
def getMicsPair(self):
return self._micsPair.get()
def setAngles(self, setAngles):
self._angles = setAngles
def setMicsPair(self, micsPair):
self._micsPair.set(micsPair)
def getFiles(self):
filePaths = TiltPairSet.getFiles(self)
filePaths.update(self.getAngles().getFiles())
filePaths.update(self.getMicsPair().getFiles())
return filePaths
def _loadClassesDict(self):
return globals()
def close(self):
TiltPairSet.close(self)
self.getAngles().close()
def launch_viewer(request):
project = loadProject(request)
objectId = request.GET.get('objectId')
# Fix this, now we should use newer notation: . instead of ::
if '::' in objectId:
idParts = objectId.split("::")
if idParts[1] != 'None':
# We use the logic in Pointer.get to handle the 'extended'
# parts that can come as part of the id (eg: 2::outputAverages::1)
protObj = project.getObject(int(idParts[0]))
pointer = Pointer(value=protObj)
pointer.setExtendedParts(idParts[1:])
obj = pointer.get()
else:
#
obj = project.getObject(int(idParts[0]))
else:
obj = project.getObject(int(objectId))
if obj is not None:
if obj.isPointer():
obj = obj.get()
viewers = findViewers(obj.getClassName(), WEB_DJANGO)
if len(viewers) == 0:
views = []
if isinstance(obj, EMProtocol):
for _, output in obj.iterOutputAttributes(EMObject):
objViewers = findViewers(output.getClassName(), WEB_DJANGO)
if objViewers:
views += objViewers[0](project=project)._visualize(output) or []
if not views:
views = [MessageView("No viewers found for object type: %s" % obj.getClassName())]
urls = [viewToUrl(request, view) for view in views]
else:
viewerClass = viewers[0]
viewer = viewerClass(project=project, protocol=obj)
# Lets assume if there is a viewer for the protocol
# it will be a ProtocolViewer with a Form
if issubclass(viewerClass, ProtocolViewer):
urls = [viewerForm(project, obj, viewer, request)]
else:
views = viewer._visualize(obj)
urls = [viewToUrl(request, v) for v in views]
else:
views = [MessageView("Object not found to visualize")]
urls = [viewToUrl(request, view) for view in views]
jsonStr = json.dumps(urls, ensure_ascii=False)
return HttpResponse(jsonStr, content_type='application/javascript')
def testCtfdiscrepancyWorkflow(self):
""" Import 3 EMX files with micrographs and defocus and compare them
"""
emxFn1 = self.dataset.getFile('emxMicrographCtf1')
emxFn2 = self.dataset.getFile('emxMicrographCtf2')
emxFn3 = self.dataset.getFile('emxMicrographCtf3')
protEmxImport1 = self.newProtocol(
ProtImportMicrographs,
importFrom=ProtImportMicrographs.IMPORT_FROM_EMX,
samplingRate=1,
emxFile=emxFn1)
protEmxImport2 = self.newProtocol(
ProtImportMicrographs,
importFrom=ProtImportMicrographs.IMPORT_FROM_EMX,
samplingRate=1,
emxFile=emxFn2)
protEmxImport3 = self.newProtocol(
ProtImportMicrographs,
importFrom=ProtImportMicrographs.IMPORT_FROM_EMX,
samplingRate=1,
emxFile=emxFn3)
pl = PointerList([
Pointer(value=protEmxImport1, extended='outputCTF'),
Pointer(value=protEmxImport2, extended='outputCTF'),
Pointer(value=protEmxImport3, extended='outputCTF')
])
protCtfDiscrepancy = self.newProtocol(XmippProtCTFDiscrepancy)
protCtfDiscrepancy.inputCTFs.set(pl)
self.proj.saveProtocol(protEmxImport1)
self.proj.saveProtocol(protEmxImport2)
self.proj.saveProtocol(protEmxImport3)
self.proj.saveProtocol(protCtfDiscrepancy)
self.launchProtocol(protEmxImport1)
self.launchProtocol(protEmxImport2)
self.launchProtocol(protEmxImport3)
self.launchProtocol(protCtfDiscrepancy)
ctfsGold = SetOfCTF(filename=self.dataset.getFile('ctfsGold'))
ctfSetFn, ctfSetPairFn = protCtfDiscrepancy._getAnalyzeFiles()
ctfComputed = SetOfCTF(filename=ctfSetPairFn)
for ctf1, ctf2 in izip(ctfComputed, ctfsGold):
ctf1.getMicrograph().setFileName(
os.path.basename(ctf1.getMicrograph().getFileName()))
ctf2.getMicrograph().setFileName(
os.path.basename(ctf2.getMicrograph().getFileName()))
self.assertTrue(ctf1.equalAttributes(ctf2))
class CoordinatesTiltPair(EMSet):
"""Represents a Coordinates Tilt Pair"""
ITEM_TYPE = TiltPair
def __init__(self, **args):
EMSet.__init__(self, **args)
self._tilted = None#SetOfCoordinates()
self._untilted = None#SetOfCoordinates()
self._angles = SetOfAngles()
self._micsPair = Pointer()
def getUntilted(self):
return self._untilted
def getTilted(self):
return self._tilted
def getAngles(self):
return self._angles
def getMicsPair(self):
return self._micsPair.get()
def setUntilted(self, untilted):
self._untilted = untilted
def setTilted(self, tilted):
self._tilted = tilted
def setAngles(self, setAngles):
self._angles = setAngles
def setMicsPair(self, micsPair):
self._micsPair.set(micsPair)
def getFiles(self):
filePaths = set()
filePaths.add(self.getTilted().getFiles)
filePaths.add(self.getUntilted().getFiles)
return filePaths
def _loadClassesDict(self):
return globals()
def close(self):
self._tilted.close()
self._untilted.close()
EMSet.close(self)
def registerCoords(self, coordsDir):
""" This method is usually inherited by all Pickers
and it is used from the Java picking GUI to register
a new SetOfCoordinates when the user click on +Particles button.
"""
suffix = self.__getOutputSuffix()
outputName = self.OUTPUT_PREFIX + suffix
readSetOfCoordinates = pwutils.importFromPlugin(
'xmipp3.convert', 'readSetOfCoordinates')
inputset = self.getInputMicrographs()
# micrographs are the input set if protocol is not finished
outputset = self._createSetOfCoordinates(inputset, suffix=suffix)
readSetOfCoordinates(coordsDir, outputset.getMicrographs(), outputset)
summary = self.getSummary(outputset)
outputset.setObjComment(summary)
outputs = {outputName: outputset}
self._defineOutputs(**outputs)
# Using a pointer to define the relations is more robust to scheduling
# and id changes between the protocol run.db and the main project
# database. The pointer defined below points to the outputset object
self._defineSourceRelation(self.getInputMicrographsPointer(),
Pointer(value=self, extended=outputName))
self._store()
def recoverTSFromObj(child_obj, protocol):
p = protocol.getProject()
graph = p.getSourceGraph(False)
relations = p.mapper.getRelationsByName(RELATION_SOURCE)
n = graph.getNode(child_obj.strId())
connection = []
while n is not None and not n.getParent().isRoot():
n = n.getParent()
connection.append(n.pointer.getUniqueId())
connection.append(n.pointer.get().strId())
for rel in relations:
pObj = p.getObject(rel[OBJECT_PARENT_ID])
pExt = rel['object_parent_extended']
pp = Pointer(pObj, extended=pExt)
if pp.getUniqueId() in connection:
if isinstance(pObj, SetOfTiltSeries) and pObj.getFirstItem().getFirstItem().hasTransform():
return pObj
raise ValueError('Could not find any SetOfTiltSeries associated to %s.' % type(child_obj))
class ParticlesTiltPair(TiltPairSet):
"""Represents a Particles Tilt Pair"""
ITEM_TYPE = TiltPair
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._coordsPair = Pointer()
def getCoordsPair(self):
return self._coordsPair.get()
def setCoordsPair(self, coordsPair):
self._coordsPair.set(coordsPair)
def getFiles(self):
filePaths = TiltPairSet.getFiles(self)
filePaths.update(self.getCoordsPair().getFiles())
return filePaths
class ParticlesTiltPair(EMSet):
"""Represents a Particles Tilt Pair"""
ITEM_TYPE = TiltPair
def __init__(self, **args):
EMSet.__init__(self, **args)
self._tilted = None#SetOfImages()
self._untilted = None#SetOfImages()
self._coordsPair = Pointer()
def getUntilted(self):
return self._untilted
def getTilted(self):
return self._tilted
def getCoordsPair(self):
return self._coordsPair.get()
def setUntilted(self, untilted):
self._untilted = untilted
def setTilted(self, tilted):
self._tilted = tilted
def setCoordsPair(self, coordsPair):
self._coordsPair.set(coordsPair)
def getFiles(self):
filePaths = set()
filePaths.add(self.getTilted().getFiles)
filePaths.add(self.getUntilted().getFiles)
return filePaths
def _loadClassesDict(self):
return globals()
def close(self):
self._tilted.close()
self._untilted.close()
EMSet.close(self)
class ParticlesTiltPair(TiltPairSet):
"""Represents a Particles Tilt Pair"""
ITEM_TYPE = TiltPair
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._coordsPair = Pointer()
def getCoordsPair(self):
return self._coordsPair.get()
def setCoordsPair(self, coordsPair):
self._coordsPair.set(coordsPair)
def getFiles(self):
filePaths = TiltPairSet.getFiles(self)
filePaths.update(self.getCoordsPair().getFiles())
return filePaths
def test_fromRelionClassify2D(self):
""" Import an EMX file with Particles and defocus
"""
prot1 = self.newProtocol(
emprot.ProtImportParticles,
objLabel='from relion (classify 2d)',
importFrom=emprot.ProtImportParticles.IMPORT_FROM_RELION,
starFile=self.dsRelion.getFile(
'import/classify2d/extra/relion_it015_data.star'),
magnification=10000,
samplingRate=7.08,
haveDataBeenPhaseFlipped=True)
self.launchProtocol(prot1)
self.checkOutput(prot1, 'outputParticles', [
'outputParticles.hasAlignment2D()',
'outputParticles.isPhaseFlipped()'
])
self.checkOutput(prot1, 'outputClasses')
# Add tests for classes selector. representative
classSelector = self.newProtocol(
emprot.ProtClassesSelector,
objLabel='representatives from 2 mayor classes',
firstNElements=2,
extractRepresentative=True)
classSelector.inputClasses = Pointer(prot1, extended='outputClasses')
self.launchProtocol(classSelector)
self.assertSetSize(classSelector.output, size=2)
# Add tests for classes selector: items
classSelector2 = self.newProtocol(
emprot.ProtClassesSelector,
objLabel='items from 3 mayor classes',
firstNElements=3,
extractRepresentative=False)
classSelector2.inputClasses = Pointer(prot1, extended='outputClasses')
self.launchProtocol(classSelector2)
self.assertSetSize(classSelector2.output, size=1739)
def show(self, form):
if form.protocol.inputPDB.hasValue():
pdb = form.protocol.inputPDB.get()
print("pdb ", pdb._volume, str(pdb._volume))
if pdb._volume:
print("Setting ", str(pdb.getVolume()))
ptr = Pointer()
ptr.copy(form.protocol.inputPDB)
ptr.setExtended(ptr.getExtended() + "._volume")
# ptr.set(pdb.getVolume())
form.setVar('inputVol', ptr)
class CoordinatesTiltPair(TiltPairSet):
"""Represents a Coordinates Tilt Pair"""
ITEM_TYPE = TiltPair
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._angles = None
self._micsPair = Pointer()
def getAngles(self):
return self._angles
def getBoxSize(self):
return self.getUntilted().getBoxSize()
def getMicsPair(self):
return self._micsPair.get()
def setAngles(self, setAngles):
self._angles = setAngles
def setMicsPair(self, micsPair):
self._micsPair.set(micsPair)
def getFiles(self):
filePaths = TiltPairSet.getFiles(self)
filePaths.update(self.getAngles().getFiles())
filePaths.update(self.getMicsPair().getFiles())
return filePaths
def _loadClassesDict(self):
return globals()
def close(self):
TiltPairSet.close(self)
if self.getAngles():
self.getAngles().close()
def _loadOutputSet(self, SetClass, baseName):
setFile = self._getPath(baseName)
if os.path.exists(setFile):
outputSet = SetClass(filename=setFile)
outputSet.loadAllProperties()
outputSet.enableAppend()
else:
outputSet = SetClass(filename=setFile)
outputSet.setStreamState(outputSet.STREAM_OPEN)
outputSet.setBoxSize(self.getMainInput().getBoxSize())
# FIXME: The commented line below should work but it fails in streaming
# when extracting particles. The line below it fixs that error..
# inMicsPointer = self.getMainInput().getMicrographs()
inMicsPointer = Pointer(self.getMapper().getParent(
self.getMainInput().getMicrographs()),
extended='outputMicrographs')
outputSet.setMicrographs(inMicsPointer)
return outputSet
def _loadOutputSet(self, SetClass, baseName):
setFile = self._getPath(baseName)
if os.path.exists(setFile):
self.firstTime = False
outputSet = SetClass(filename=setFile)
outputSet.loadAllProperties()
outputSet.enableAppend()
else:
self.firstTime = True
outputSet = SetClass(filename=setFile)
outputSet.setStreamState(outputSet.STREAM_OPEN)
outputSet.setBoxSize(self.inputs.getBoxSize())
inMicsPointer = Pointer(self.getMapper().getParent(
self.inputs.getMicrographs()),
extended='outputMicrographs')
outputSet.setMicrographs(inMicsPointer)
return outputSet
def test_picking(self):
print("Run aitom picking")
protImportTomogram = self.newProtocol(
ProtImportTomograms,
filesPath=self.ds.getFile("single_particle"),
samplingRate=5)
self.launchProtocol(protImportTomogram)
# Create the picking protocol and link it.
protPicking = self.newProtocol(AiTomPicking)
protPicking.inputTomograms = Pointer(protImportTomogram,
extended="outputTomograms")
# Launch the picking
self.launchProtocol(protPicking)
# Check it has something
self.assertSetSize(protPicking.output3DCoordinates, 21509,
"There was a problem with coordinates 3d output")
def updateRelationsAndClose(cSet, mSet, first, label=''):
if os.path.exists(self._getPath('ctfs'+label+'.sqlite')):
micsAttrName = 'outputMicrographs'+label
self._updateOutputSet(micsAttrName, mSet, streamMode)
# Set micrograph as pointer to protocol to prevent pointee end up as another attribute (String, Booelan,...)
# that happens somewhere while scheduling.
cSet.setMicrographs(Pointer(self, extended=micsAttrName))
self._updateOutputSet('outputCTF'+label, cSet, streamMode)
if first:
self._defineTransformRelation(self.inputCTF.get().getMicrographs(),
mSet)
# self._defineTransformRelation(cSet, mSet)
self._defineTransformRelation(self.inputCTF, cSet)
self._defineCtfRelation(mSet, cSet)
mSet.close()
cSet.close()
def registerCoords(self, coordsDir):
""" This method is usually inherited by all Pickers
and it is used from the Java picking GUI to register
a new SetOfCoordinates when the user click on +Particles button.
"""
inputset = self.getInputMicrographs()
mySuffix = '_Manual_%s' % coordsDir.split('manualThresholding_')[1]
outputName = 'outputCoordinates' + mySuffix
outputset = self._createSetOfCoordinates(inputset, suffix=mySuffix)
readSetOfCoordinates(coordsDir, outputset.getMicrographs(), outputset)
# summary = self.getSummary(outputset)
# outputset.setObjComment(summary)
outputs = {outputName: outputset}
self._defineOutputs(**outputs)
# Using a pointer to define the relations is more robust to scheduling
# and id changes between the protocol run.db and the main project
# database. The pointer defined below points to the outputset object
self._defineSourceRelation(self.getInputMicrographs(),
Pointer(value=self, extended=outputName))
self._store()
def __init__(self, **args):
EMSet.__init__(self, **args)
self._tilted = None#SetOfImages()
self._untilted = None#SetOfImages()
self._coordsPair = Pointer()
def __init__(self, **args):
EMSet.__init__(self, **args)
self._tilted = None#SetOfCoordinates()
self._untilted = None#SetOfCoordinates()
self._angles = SetOfAngles()
self._micsPair = Pointer()
def create_service_project(request):
if request.is_ajax():
import os
from pyworkflow.object import Pointer
from pyworkflow.em.protocol import ProtUnionSet, ProtImportAverages
from pyworkflow.em.packages.xmipp3 import XmippProtRansac, XmippProtReconstructSignificant, XmippProtAlignVolumeForWeb
from pyworkflow.em.packages.eman2 import EmanProtInitModel
from pyworkflow.em.packages.simple import ProtPrime
# Create a new project
projectName = request.GET.get('projectName')
# Filename to use as test data
testDataKey = request.GET.get('testData')
#customMenu = os.path.join(os.path.dirname(os.environ['SCIPION_PROTOCOLS']), 'menu_initvolume.conf')
manager = getServiceManager('myfirstmap')
writeCustomMenu(manager.protocols)
project = manager.createProject(projectName, runsView=1,
hostsConf=manager.hosts,
protocolsConf=manager.protocols
)
project.getSettings().setLifeTime(14)
project.saveSettings()
#copyFile(customMenu, project.getPath('.config', 'protocols.conf'))
# 1. Import averages
# If using test data execute the import averages run
# options are set in 'project_utils.js'
dsMDA = DataSet.getDataSet('initial_volume')
if testDataKey :
fn = dsMDA.getFile(testDataKey)
newFn = join(project.uploadPath, basename(fn))
copyFile(fn, newFn)
label_import = 'import averages ('+ testDataKey +')'
protImport = project.newProtocol(ProtImportAverages, objLabel=label_import)
protImport.filesPath.set(newFn)
protImport.samplingRate.set(1.)
project.launchProtocol(protImport, wait=True)
else:
protImport = project.newProtocol(ProtImportAverages, objLabel='import averages')
project.saveProtocol(protImport)
# 2a. Ransac
protRansac = project.newProtocol(XmippProtRansac)
protRansac.setObjLabel('xmipp - ransac')
protRansac.inputSet.set(protImport)
protRansac.inputSet.setExtended('outputAverages')
if testDataKey :
setProtocolParams(protRansac, testDataKey)
project.saveProtocol(protRansac)
# 2b. Eman
protEmanInitVol = project.newProtocol(EmanProtInitModel)
protEmanInitVol.setObjLabel('eman - initial vol')
protEmanInitVol.inputSet.set(protImport)
protEmanInitVol.inputSet.setExtended('outputAverages')
if testDataKey :
setProtocolParams(protEmanInitVol, testDataKey)
project.saveProtocol(protEmanInitVol)
# 2c. Significant
protSignificant = project.newProtocol(XmippProtReconstructSignificant)
protSignificant.setObjLabel('xmipp - significant')
protSignificant.inputSet.set(protImport)
protSignificant.inputSet.setExtended('outputAverages')
if testDataKey :
setProtocolParams(protSignificant, testDataKey)
project.saveProtocol(protSignificant)
# 3. Join result volumes
p1 = Pointer()
p1.set(protRansac)
p1.setExtended('outputVolumes')
p2 = Pointer()
p2.set(protEmanInitVol)
p2.setExtended('outputVolumes')
p3 = Pointer()
p3.set(protSignificant)
p3.setExtended('outputVolume')
protJoin = project.newProtocol(XmippProtAlignVolumeForWeb)
protJoin.setObjLabel('align volumes')
protJoin.inputVolumes.append(p1)
protJoin.inputVolumes.append(p2)
protJoin.inputVolumes.append(p3)
# protJoin.inputVolumes.append(p4)
project.saveProtocol(protJoin)
protValidate = project.newProtocol(XmippProtValidateNonTilt)
protValidate.setObjLabel('validate nontilt')
protValidate.inputVolumes.set(protJoin)
protValidate.inputVolumes.setExtended('outputVolumes')
protValidate.inputParticles.set(protImport)
protValidate.inputParticles.setExtended('outputAverages')
protValidate.numberOfThreads.set(8)
if testDataKey :
setProtocolParams(protValidate, testDataKey)
# protJoin.inputVolumes.append(p4)
project.saveProtocol(protValidate)
return HttpResponse(mimetype='application/javascript')
def create_service_project(request):
if request.is_ajax():
# Create a new project
projectName = getVarFromRequest(request, PROJECT_NAME)
# Filename to use as test data
testDataKey = request.GET.get('testData')
manager = getServiceManager(MYFIRSTMAP_SERVICE)
writeCustomMenu(manager.protocols)
project = manager.createProject(projectName, runsView=1,
hostsConf=manager.hosts,
protocolsConf=manager.protocols,
chdir=False)
project.getSettings().setLifeTime(336) # 14 days * 24 hours
project.saveSettings()
#copyFile(customMenu, project.getPath('.config', 'protocols.conf'))
# 1. Import averages
# If using test data execute the import averages run
# options are set in 'project_utils.js'
dsMDA = DataSet.getDataSet('initial_volume')
if testDataKey :
fn = dsMDA.getFile(testDataKey)
newFn = getImageFullPath(project.path, join(project.uploadPath, basename(fn)))
copyFile(fn, newFn)
label_import = 'import averages ('+ testDataKey +')'
protImport = project.newProtocol(ProtImportAverages, objLabel=label_import)
protImport.filesPath.set(newFn)
protImport.samplingRate.set(1.)
project.launchProtocol(protImport, wait=True, chdir=False)
else:
protImport = project.newProtocol(ProtImportAverages, objLabel='import averages')
project.saveProtocol(protImport)
# 2a. Ransac
protRansac = project.newProtocol(XmippProtRansac)
protRansac.setObjLabel('xmipp - ransac')
protRansac.inputSet.set(protImport)
protRansac.inputSet.setExtended('outputAverages')
setProtocolParams(protRansac, testDataKey)
project.saveProtocol(protRansac)
# 2b. Eman
protEmanInitVol = project.newProtocol(EmanProtInitModel)
protEmanInitVol.setObjLabel('eman - initial vol')
protEmanInitVol.inputSet.set(protImport)
protEmanInitVol.inputSet.setExtended('outputAverages')
setProtocolParams(protEmanInitVol, testDataKey)
project.saveProtocol(protEmanInitVol)
# 2c. Significant
protSignificant = project.newProtocol(XmippProtReconstructSignificant)
protSignificant.setObjLabel('xmipp - significant')
protSignificant.inputSet.set(protImport)
protSignificant.inputSet.setExtended('outputAverages')
setProtocolParams(protSignificant, testDataKey)
project.saveProtocol(protSignificant)
# 3. Join result volumes
p1 = Pointer()
p1.set(protRansac)
p1.setExtended('outputVolumes')
p2 = Pointer()
p2.set(protEmanInitVol)
p2.setExtended('outputVolumes')
p3 = Pointer()
p3.set(protSignificant)
p3.setExtended('outputVolume')
protJoin = project.newProtocol(XmippProtAlignVolumeForWeb)
protJoin.setObjLabel('align volumes')
protJoin.inputVolumes.append(p1)
protJoin.inputVolumes.append(p2)
protJoin.inputVolumes.append(p3)
project.saveProtocol(protJoin)
# protValidate = project.newProtocol(XmippProtValidateNonTilt)
# protValidate.setObjLabel('validate nontilt')
# protValidate.inputVolumes.set(protJoin)
# protValidate.inputVolumes.setExtended('outputVolumes')
# protValidate.inputParticles.set(protImport)
# protValidate.inputParticles.setExtended('outputAverages')
# protValidate.numberOfThreads.set(8)
# if testDataKey :
# setProtocolParams(protValidate, testDataKey)
# # protJoin.inputVolumes.append(p4)
# project.saveProtocol(protValidate)
return HttpResponse(content_type='application/javascript')
def test_import_volume(self):
""" 1) Import single volume and set origin in default position (the
volume will be centered in the center of coordinates)
"""
args = {'filesPath': self.dsXmipp.getFile('volumes/'),
'filesPattern': 'volume_1_iter_002.mrc',
'setHalfMaps': False,
'setOrigCoord': False,
'samplingRate': 2.1,
}
# Id's should be set increasing from 1 if ### is not in the
# pattern
prot1 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot1.setObjLabel('import vol,\n default origin,\n chimera show '
'axis,\n vol origin in coord origin')
self.launchProtocol(prot1)
volume = prot1.outputVolume
t = volume.getOrigin()
x, y, z = t.getShifts()
# x, y, z in Angstroms
# Chimera will show (x, y, z) divided by the samplingRate
# in pixels = (32, 32, 32)
self.assertEqual(-67.2, x)
self.assertEqual(-67.2, y)
self.assertEqual(-67.2, z)
# """ 2) Import single volume and set origin in userDefined position
# """
args = {'filesPath': self.dsXmipp.getFile('volumes/'),
'filesPattern': 'volume_1_iter_002.mrc',
'setHalfMaps': False,
'setOrigCoord': True,
'samplingRate': 2.1,
'x': 16.8,
'y': 33.6,
'z': 50.4
}
# Id's should be set increasing from 1 if ### is not in the
# pattern
prot2 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot2.setObjLabel('import vol,\n user origin,\n chimera show axis')
self.launchProtocol(prot2)
volume = prot2.outputVolume
t = volume.getOrigin()
x, y, z = t.getShifts()
# Assert path is relative
self.assertFalse(os.path.isabs(volume.getFileName()),
"single volume path is not relative")
# x, y, z in Angstroms
# in Chimera we will see (x, y, z) divided by the samplingRate
# in pixels = (8, 16, 24)
self.assertEqual(-16.8, x)
self.assertEqual(-33.6, y)
self.assertEqual(-50.4, z)
# """ 3) Import single volume and set origin in userDefined position (the
# volume will be centered in the center of coordinates because
# coordinates are the default ones)
# """
args = {'filesPath': self.dsXmipp.getFile('volumes/'),
'filesPattern': 'volume_1_iter_002.mrc',
'setHalfMaps': False,
'setOrigCoord': True,
'samplingRate': 2.1,
'x': 67.2,
'y': 67.2,
'z': 67.2
}
# Id's should be set increasing from 1 if ### is not in the
# pattern
prot2 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot2.setObjLabel('import vol,\n user origin,\n chimera show axis')
self.launchProtocol(prot2)
volume = prot2.outputVolume
t = volume.getOrigin()
x, y, z = t.getShifts()
# x, y, z in Angstroms
# in Chimera we will see (x, y, z) divided by the samplingRate
# in pixels = (8, 16, 24)
self.assertEqual(-67.2, x)
self.assertEqual(-67.2, y)
self.assertEqual(-67.2, z)
# """ 4) Import two volumes and set origin in default position
# """
args = {'filesPath': self.dsXmipp.getFile('volumes/'),
'filesPattern': 'volume_*mrc',
'setHalfMaps': False,
'setOrigCoord': False,
'samplingRate': 2.1,
}
# Id's should be set increasing from 1 if ### is not in the
# pattern
prot3 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot3.setObjLabel('import 2 vols,\n default origin,\n chimera no '
'axis')
self.launchProtocol(prot3)
for volume in prot3.outputVolumes:
t = volume.getOrigin()
x, y, z = t.getShifts()
self.assertEqual(-67.2, x)
self.assertEqual(-67.2, y)
self.assertEqual(-67.2, z)
# Assert path is relative
self.assertFalse(os.path.isabs(volume.getFileName()),
"volume path is not relative")
# """ 5) Import two volumes and set origin in userDefined position
# """
args = {'filesPath': self.dsXmipp.getFile('volumes/'),
'filesPattern': 'volume_*mrc',
'setHalfMaps': False,
'setOrigCoord': True,
'samplingRate': 2.1,
'x': 16.8,
'y': 33.6,
'z': 50.4
}
# Id's should be set increasing from 1 if ### is not in the
# pattern
prot4 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot4.setObjLabel('import 2 vols,\n user origin,\n chimera no axis')
self.launchProtocol(prot4)
for volume in prot4.outputVolumes:
t = volume.getOrigin()
x, y, z = t.getShifts()
self.assertEqual(-16.8, x)
self.assertEqual(-33.6, y)
self.assertEqual(-50.4, z)
# """ 6) Import three volumes (mrc stack) and set origin in userDefined
# position
# """
# Id's should be taken from filename
args['filesPath'] = self.dsRelion.getFile('import/case2/'
'relion_volumes.mrc')
args['filesPattern'] = ''
prot2 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot2.setObjLabel('import 3 vols from mrc stack,\n user origin,'
'\n chimera no axis')
self.launchProtocol(prot2)
# Check the number of output volumes and dimensions
self.assertEqual(3, prot2.outputVolumes.getSize())
self.assertEqual(60, prot2.outputVolumes.getDim()[0])
# """ 7) Import three volumes (spider stack) and set origin in
# userDefined position
# """
# Id's should be taken from filename
args['filesPath'] = self.dsRelion.getFile('import/case2/'
'relion_volumes.stk')
args['filesPattern'] = ''
prot3 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot3.setObjLabel('import 3 vols from spider stack\n user origin,'
'\n chimera no axis')
self.launchProtocol(prot3)
# Check the number of output volumes and dimensions
self.assertEqual(3, prot3.outputVolumes.getSize())
self.assertEqual(60, prot3.outputVolumes.getDim()[0])
# """ 8)To test old data where volumes have no origin at all"""
args = {'filesPath': self.dsXmipp.getFile('volumes/'),
'filesPattern': 'volume_1_iter_002.mrc',
'setHalfMaps': False,
# 'setOrigCoord': False,
'samplingRate': 2.1,
}
prot4 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot4.setObjLabel('import vol,\n no origin at all, legacy data,'
'\n chimera show '
'axis,\n vol origin in coord origin')
self.launchProtocol(prot4)
volume = prot4.outputVolume
volume.setOrigin(None)
# The volume has no origin
t = volume.getOrigin(force=True)
x, y, z = t.getShifts()
# x, y, z in Angstroms
# Chimera will show (x, y, z) divided by the samplingRate
# in pixels = (32, 32, 32)
self.assertEqual(-67.2, x)
self.assertEqual(-67.2, y)
self.assertEqual(-67.2, z)
# TODO: associate origen coordinates from header file
# args = {'filesPath': self.dsModBuild.getFile('volumes/1ake_4-5A.mrc'),
# 'samplingRate': 1.5,
# 'setDefaultOrigin': False,
# 'x': ,
# 'y': ,
# 'z':
# }
#
# protImportVol = self.newProtocol(emprot.ProtImportVolumes, **args)
# protImportVol.setObjLabel('import vol 1ake_4-5A,\n header origin,\n chimera show axis')
# self.launchProtocol(protImportVol)
# volume = protImportVol.outputVolume
#
# # Id's should be set increasing from 1 if ### is not in the
# # pattern
#
# t = volume.getOrigin()
# x, y, z = t.getShifts()
# # x, y, z in Angstroms
# # in Chimera we will see (x, y, z) divided by the samplingRate
# self.assertEqual(-11.99, x)
# self.assertEqual(7.88, y)
# self.assertEqual(-10.90, z)
# """ 9) Import 3D map from EMDB """
from pwem.protocols.protocol_import.volumes import ProtImportVolumes
args = {'importFrom': ProtImportVolumes.IMPORT_FROM_EMDB,
'emdbId': 10676
}
prot5 = self.newProtocol(emprot.ProtImportVolumes, **args)
prot5.setObjLabel('import vol,\n import from EMDB')
self.launchProtocol(prot5)
volume = prot5.outputVolume
# volume.setOrigin(None)
# The volume has no origin
t = volume.getOrigin(force=True)
x, y, z = t.getShifts()
self.assertTrue(os.path.exists(prot5._getExtraPath('emd_10676.map')))
# TODO: I should check origin but all 3D map
# I have tried to download have origin =0 :-(
# self.assertEqual(-67.2, x)
# self.assertEqual(-67.2, y)
# self.assertEqual(-67.2, z)
# Test join sets work with volumes
unionProt = self.newProtocol(emprot.ProtUnionSet,
inputType=emprot.ProtUnionSet.TYPE_VOLUME_INDEX)
# Set the input volumes
unionProt.inputSets.append (Pointer(prot2, extended="outputVolumes.1"))
unionProt.inputSets.append(Pointer(prot3, extended="outputVolumes.1"))
unionProt.setObjLabel("Single volumes union")
self.launchProtocol(unionProt)
self.assertSetSize(unionProt.outputSet, 2, msg="Union of 2 volumes does not work.")
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._coordsPair = Pointer()
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._angles = None
self._micsPair = Pointer()
def getInputMicrographsPointer(self):
ptr = Pointer()
ptr.set(self.getInputMicrographs())
return ptr
prot2 = getProtocolFromDb(prot.getProject().path, prot.getDbPath(),
prot.getObjId())
# Close DB connections
prot2.getProject().closeMapper()
prot2.closeMappers()
return prot2
def checkStreamOutput(self, prots, outputName):
for prot in prots:
if not prot.hasAttribute(outputName):
return False
return True
def prepareInput(self, case, nCoordSets=3):
protImpMics = self._runInportMicrographs()
protImpCoords = self._runImportCoordinates(protImpMics, case)
protsStreamCoords = []
for i in range(nCoordSets):
protsStreamCoords.append(
self._runStreamCoordinates(protImpCoords, i))
for i in range(nCoordSets):
self._waitOutput(protsStreamCoords[i], "outputCoordinates")
inpCoords = []
for prot in protsStreamCoords:
point = Pointer(prot, extended="outputCoordinates")
inpCoords.append(point)
return inpCoords
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._coordsPair = Pointer()
def create_service_project(request):
if request.is_ajax():
import os
from pyworkflow.object import Pointer
from pyworkflow.em.protocol import ProtUnionSet, ProtImportAverages
from pyworkflow.em.packages.xmipp3 import XmippProtRansac, XmippProtReconstructSignificant, XmippProtAlignVolumeForWeb
from pyworkflow.em.packages.eman2 import EmanProtInitModel
from pyworkflow.em.packages.simple import ProtPrime
# Create a new project
projectName = request.GET.get('projectName')
# Filename to use as test data
testDataKey = request.GET.get('testData')
#customMenu = os.path.join(os.path.dirname(os.environ['SCIPION_PROTOCOLS']), 'menu_initvolume.conf')
manager = getServiceManager('myfirstmap')
writeCustomMenu(manager.protocols)
project = manager.createProject(projectName,
runsView=1,
hostsConf=manager.hosts,
protocolsConf=manager.protocols)
project.getSettings().setLifeTime(336) # 14 days * 24 hours
project.saveSettings()
#copyFile(customMenu, project.getPath('.config', 'protocols.conf'))
# 1. Import averages
# If using test data execute the import averages run
# options are set in 'project_utils.js'
dsMDA = DataSet.getDataSet('initial_volume')
if testDataKey:
fn = dsMDA.getFile(testDataKey)
newFn = join(project.uploadPath, basename(fn))
copyFile(fn, newFn)
label_import = 'import averages (' + testDataKey + ')'
protImport = project.newProtocol(ProtImportAverages,
objLabel=label_import)
protImport.filesPath.set(newFn)
protImport.samplingRate.set(1.)
project.launchProtocol(protImport, wait=True)
else:
protImport = project.newProtocol(ProtImportAverages,
objLabel='import averages')
project.saveProtocol(protImport)
# 2a. Ransac
protRansac = project.newProtocol(XmippProtRansac)
protRansac.setObjLabel('xmipp - ransac')
protRansac.inputSet.set(protImport)
protRansac.inputSet.setExtended('outputAverages')
if testDataKey:
setProtocolParams(protRansac, testDataKey)
project.saveProtocol(protRansac)
# 2b. Eman
protEmanInitVol = project.newProtocol(EmanProtInitModel)
protEmanInitVol.setObjLabel('eman - initial vol')
protEmanInitVol.inputSet.set(protImport)
protEmanInitVol.inputSet.setExtended('outputAverages')
if testDataKey:
setProtocolParams(protEmanInitVol, testDataKey)
project.saveProtocol(protEmanInitVol)
# 2c. Significant
protSignificant = project.newProtocol(XmippProtReconstructSignificant)
protSignificant.setObjLabel('xmipp - significant')
protSignificant.inputSet.set(protImport)
protSignificant.inputSet.setExtended('outputAverages')
if testDataKey:
setProtocolParams(protSignificant, testDataKey)
project.saveProtocol(protSignificant)
# 3. Join result volumes
p1 = Pointer()
p1.set(protRansac)
p1.setExtended('outputVolumes')
p2 = Pointer()
p2.set(protEmanInitVol)
p2.setExtended('outputVolumes')
p3 = Pointer()
p3.set(protSignificant)
p3.setExtended('outputVolume')
protJoin = project.newProtocol(XmippProtAlignVolumeForWeb)
protJoin.setObjLabel('align volumes')
protJoin.inputVolumes.append(p1)
protJoin.inputVolumes.append(p2)
protJoin.inputVolumes.append(p3)
# protJoin.inputVolumes.append(p4)
project.saveProtocol(protJoin)
# protValidate = project.newProtocol(XmippProtValidateNonTilt)
# protValidate.setObjLabel('validate nontilt')
# protValidate.inputVolumes.set(protJoin)
# protValidate.inputVolumes.setExtended('outputVolumes')
# protValidate.inputParticles.set(protImport)
# protValidate.inputParticles.setExtended('outputAverages')
# protValidate.numberOfThreads.set(8)
# if testDataKey :
# setProtocolParams(protValidate, testDataKey)
# # protJoin.inputVolumes.append(p4)
# project.saveProtocol(protValidate)
return HttpResponse(mimetype='application/javascript')
def __init__(self, **kwargs):
TiltPairSet.__init__(self, **kwargs)
self._angles = SetOfAngles()
self._micsPair = Pointer()
