def _updateParticle(self, particle, row): #fn = particle.getFileName() # fnOut = self.getFileNameNoisyStk() # particle.setFileName(fnOut) index, filename = xmippToLocation(row.getValue(md.MDL_IMAGE)) particle.setLocation(index, filename)
def _updateClass(self, item): classId = item.getObjId() classRow = findRow(self.mdClasses, xmippLib.MDL_REF2, classId) representative = item.getRepresentative() representative.setTransform(rowToAlignment(classRow, ALIGN_PROJ)) representative.setLocation(xmippToLocation(classRow.getValue(xmippLib.MDL_IMAGE))) setXmippAttributes(representative, classRow, xmippLib.MDL_ANGLE_ROT) setXmippAttributes(representative, classRow, xmippLib.MDL_ANGLE_TILT) setXmippAttributes(representative, classRow, xmippLib.MDL_CLASS_COUNT) self.averageSet.append(representative) reprojection = Image() reprojection.setLocation(xmippToLocation(classRow.getValue(xmippLib.MDL_IMAGE1))) item.reprojection = reprojection
def performNmaStep(self, atomsFn, modesFn): sampling = self.inputParticles.get().getSamplingRate() discreteAngularSampling = self.discreteAngularSampling.get() trustRegionScale = self.trustRegionScale.get() odir = self._getTmpPath() imgFn = self.imgsFn args = "-i %(imgFn)s --pdb %(atomsFn)s --modes %(modesFn)s --sampling_rate %(sampling)f " args += "--discrAngStep %(discreteAngularSampling)f --odir %(odir)s --centerPDB " args += "--trustradius_scale %(trustRegionScale)d --resume " if self.getInputPdb().getPseudoAtoms(): args += "--fixed_Gaussian " if self.alignmentMethod == NMA_ALIGNMENT_PROJ: args += "--projMatch " self.runJob("xmipp_nma_alignment", args % locals()) cleanPath(self._getPath('nmaTodo.xmd')) inputSet = self.inputParticles.get() mdImgs = md.MetaData(self.imgsFn) for objId in mdImgs: imgPath = mdImgs.getValue(md.MDL_IMAGE, objId) index, fn = xmippToLocation(imgPath) # Conside the index is the id in the input set particle = inputSet[index] mdImgs.setValue(md.MDL_IMAGE, getImageLocation(particle), objId) mdImgs.setValue(md.MDL_ITEM_ID, long(particle.getObjId()), objId) mdImgs.write(self.imgsFn)
def _fillClasses(self, outputClasses): """ Create the SetOfClasses2D """ inputSet = self.inputClasses.get().getImages() myRep = md.MetaData('classes@' + self._getExtraPath( 'final_classes.xmd')) for row in md.iterRows(myRep): fn = row.getValue(md.MDL_IMAGE) rep = Particle() rep.setLocation(xmippToLocation(fn)) repId = row.getObjId() newClass = Class2D(objId=repId) newClass.setAlignment2D() newClass.copyInfo(inputSet) newClass.setAcquisition(inputSet.getAcquisition()) newClass.setRepresentative(rep) outputClasses.append(newClass) i=1 mdBlocks = md.getBlocksInMetaDataFile(self._getExtraPath( 'final_classes.xmd')) for block in mdBlocks: if block.startswith('class00'): mdClass = md.MetaData(block + "@" + self._getExtraPath( 'final_classes.xmd')) imgClassId = i newClass = outputClasses[imgClassId] newClass.enableAppend() for row in md.iterRows(mdClass): part = rowToParticle(row) newClass.append(part) i+=1 newClass.setAlignment2D() outputClasses.update(newClass)
def _loadClassesInfo(self, filename, blockId): """ Read some information about the produced 2D classes from the metadata file. """ self._classesInfo = {} # store classes info, indexed by class id mdClasses = md.MetaData(filename) for classNumber, row in enumerate(md.iterRows(mdClasses)): index, fn = xmippToLocation(row.getValue(md.MDL_IMAGE)) self._classesInfo[blockId] = (index, fn, row.clone())
def __setXmippImage(label): attr = '_xmipp_' + xmippLib.label2Str(label) if not hasattr(particle, attr): img = Image() setattr(particle, attr, img) img.setSamplingRate(particle.getSamplingRate()) else: img = getattr(particle, attr) img.setLocation(xmippToLocation(row.getValue(label)))
def _updateItem(self, item, row): """ Implement this function to do some update actions over each single item that will be stored in the output Set. """ # By default update the item location (index, filename) # with the new binary data location (after preprocessing) newFn = row.getValue(md.MDL_IMAGE) newLoc = xmippToLocation(newFn) item.setLocation(newLoc)
def _updateItem(self, item, row): """ Implement this function to do some update actions over each single item that will be stored in the output Set. """ # By default update the item location (index, filename) with the new binary data location newFn = row.getValue(md.MDL_IMAGE) newLoc = xmippToLocation(newFn) item.setLocation(newLoc) # Also remove alignment info item.setTransform(None)
def _loadClassesInfo(self): """ Read some information about the produced 2D classes from the metadata file. """ self._classesInfo = {} # store classes info, indexed by class id for classNumber, row in enumerate(md.iterRows(self.mdOut)): index, fn = xmippToLocation(row.getValue(md.MDL_IMAGE)) c = row.getValue(md.MDL_DIMRED) # Store info indexed by id, we need to store the row.clone() since # the same reference is used for iteration self._classesInfo[classNumber + 1] = (index, fn, row.clone(), c)
def copyDeformationsStep(self, deformationMd): copyFile(deformationMd, self.imgsFn) # We need to update the image name with the good ones # and the same with the ids. inputSet = self.inputParticles.get() mdImgs = md.MetaData(self.imgsFn) for objId in mdImgs: imgPath = mdImgs.getValue(md.MDL_IMAGE, objId) index, fn = xmippToLocation(imgPath) # Conside the index is the id in the input set particle = inputSet[index] mdImgs.setValue(md.MDL_IMAGE, getImageLocation(particle), objId) mdImgs.setValue(md.MDL_ITEM_ID, long(particle.getObjId()), objId) mdImgs.write(self.imgsFn)
def readPartsFromMics(self, micList, outputParts): """ Read the particles extract for the given list of micrographs and update the outputParts set with new items. """ p = Particle() for mic in micList: # We need to make this dict because there is no ID in the .xmd file coordDict = {} for coord in self.coordDict[mic.getObjId()]: pos = self._getPos(coord) if pos in coordDict: print( "WARNING: Ignoring duplicated coordinate: %s, id=%s" % (coord.getObjId(), pos)) coordDict[pos] = coord added = set() # Keep track of added coords to avoid duplicates fnMicXmd = self._getMicXmd(mic) if exists(fnMicXmd): for row in md.iterRows(fnMicXmd): pos = (row.getValue(md.MDL_XCOOR), row.getValue(md.MDL_YCOOR)) coord = coordDict.get(pos, None) if coord is not None and coord.getObjId() not in added: # scale the coordinates according to particles dimension. coord.scale(self.getBoxScale()) p.copyObjId(coord) p.setLocation( xmippToLocation(row.getValue(md.MDL_IMAGE))) p.setCoordinate(coord) p.setMicId(mic.getObjId()) p.setCTF(mic.getCTF()) # adding the variance and Gini coeff. value of the mic zone setXmippAttributes(p, row, md.MDL_SCORE_BY_VAR) setXmippAttributes(p, row, md.MDL_SCORE_BY_GINI) if row.containsLabel(md.MDL_ZSCORE_DEEPLEARNING1): setXmippAttributes(p, row, md.MDL_ZSCORE_DEEPLEARNING1) # disabled particles (in metadata) should not add to the # final set if row.getValue(md.MDL_ENABLED) > 0: outputParts.append(p) added.add(coord.getObjId()) # Release the list of coordinates for this micrograph since it # will not be longer needed del self.coordDict[mic.getObjId()]
def _processRow(self, particle, row): def __setXmippImage(label): attr = '_xmipp_' + xmippLib.label2Str(label) if not hasattr(particle, attr): img = Image() setattr(particle, attr, img) img.setSamplingRate(particle.getSamplingRate()) else: img = getattr(particle, attr) img.setLocation(xmippToLocation(row.getValue(label))) particle.setLocation(xmippToLocation(row.getValue(xmippLib.MDL_IMAGE))) #__setXmippImage(xmippLib.MDL_IMAGE) #__setXmippImage(xmippLib.MDL_IMAGE_REF) setXmippAttributes(particle, row, xmippLib.MDL_IMAGE_ORIGINAL, xmippLib.MDL_IMAGE_REF)
def _updateItemAlign(self, item, row): newFn = row.getValue(md.MDL_IMAGE) newLoc = xmippToLocation(newFn) item.setLocation(newLoc) item.setTransform(None)
def _processMovie(self, movie): movId = movie.getObjId() x, y, n = movie.getDim() iniFrame, lastFrame, _ = movie.getFramesRange() frame0, frameN = self._getRange(movie) boxSize = self.boxSize.get() if movie.hasAlignment() and self.applyAlignment: shiftX, shiftY = movie.getAlignment().getShifts() # lists. else: shiftX = [0] * (lastFrame - iniFrame + 1) shiftY = shiftX stkIndex = 0 movieStk = self._getMovieName(movie, '.stk') movieMdFile = self._getMovieName(movie, '.xmd') movieMd = md.MetaData() frameMd = md.MetaData() frameMdImages = md.MetaData() frameRow = md.Row() if self._hasCoordinates(movie): imgh = ImageHandler() for frame in range(frame0, frameN + 1): indx = frame - iniFrame frameName = self._getFnRelated('frameMic', movId, frame) frameMdFile = self._getFnRelated('frameMdFile', movId, frame) coordinatesName = self._getFnRelated('frameCoords', movId, frame) frameImages = self._getFnRelated('frameImages', movId, frame) frameStk = self._getFnRelated('frameStk', movId, frame) self._writeXmippPosFile(movie, coordinatesName, shiftX[indx], shiftY[indx]) self.info("Writing frame: %s" % frameName) # TODO: there is no need to write the frame and then operate # the input of the first operation should be the movie movieName = imgh.fixXmippVolumeFileName(movie) imgh.convert((frame, movieName), frameName) if self.doRemoveDust: self.info("Removing Dust") self._runNoDust(frameName) self.info("Extracting particles") args = '-i %(frameName)s --pos %(coordinatesName)s ' \ '-o %(frameImages)s --Xdim %(boxSize)d' % locals() if self.doInvert: args += " --invert" if self.doBorders: args += " --fillBorders" args += " --downsampling %f " % self.getBoxScale() self.runJob('xmipp_micrograph_scissor', args) cleanPath(frameName) self.info("Combining particles into one stack.") frameMdImages.read(frameMdFile) frameMd.read('particles@%s' % coordinatesName) frameMd.merge(frameMdImages) for objId in frameMd: stkIndex += 1 frameRow.readFromMd(frameMd, objId) location = xmippToLocation(frameRow.getValue(md.MDL_IMAGE)) newLocation = (stkIndex, movieStk) imgh.convert(location, newLocation) # Fix the name to be accessible from the Project directory # so we know that the movie stack file will be moved # to final particles folder newImageName = '%d@%s' % newLocation frameRow.setValue(md.MDL_IMAGE, newImageName) frameRow.setValue(md.MDL_MICROGRAPH_ID, long(movId)) frameRow.setValue(md.MDL_MICROGRAPH, str(movId)) frameRow.setValue(md.MDL_FRAME_ID, long(frame)) frameRow.setValue(md.MDL_PARTICLE_ID, frameRow.getValue(md.MDL_ITEM_ID)) frameRow.writeToMd(movieMd, movieMd.addObject()) movieMd.addItemId() movieMd.write(movieMdFile) cleanPath(frameStk) if self.doNormalize: numberOfFrames = frameN - frame0 + 1 self._runNormalize(movieStk, numberOfFrames)
def _updateLocation(self, item, row): index, filename = xmippToLocation(row.getValue(md.MDL_IMAGE)) item.setLocation(index, filename)
def _updateItem(self, item, row): # By default update the item location (index, filename) with the new binary data location newFn = row.getValue(md.MDL_IMAGE) newLoc = xmippToLocation(newFn) item.setLocation(newLoc) item.setTransform(None)
def _preprocessClass(self, classItem, classRow): classItem.average = Particle() classItem.average.setLocation( xmippToLocation(classRow.getValue(emlib.MDL_IMAGE2)))
def _processRow(self, particle, row): particle.setLocation(xmippToLocation(row.getValue(xmippLib.MDL_IMAGE))) if self.model.get() == ITER_TRAIN: setXmippAttributes(particle, row, xmippLib.MDL_CORR_DENOISED_PROJECTION)