def resolution(self, embeddingData, image1, image2, apix):
np.random.seed(3)
self.apix = float(apix)
#****************************
#**** do two embeddings *****
#****************************
if embeddingData is not None:
#split the localizations randomly in 2 half sets
numLocalizations = embeddingData.shape[0]
self.dimension = embeddingData.shape[1]
sizeHalfSet = int(numLocalizations / 2)
permutedSequence = np.random.permutation(
np.arange(numLocalizations))
self.embeddingsHalf1 = embeddingData[
permutedSequence[0:sizeHalfSet], :]
self.embeddingsHalf2 = embeddingData[
permutedSequence[sizeHalfSet:], :]
self.embedding = embeddingData
self.make_half_maps()
#****************************
#***** use two images *******
#****************************
elif image1 is not None:
self.halfMap1 = image1
self.halfMap2 = image2
self.hannWindow = FDRutil.makeHannWindow(self.halfMap1)
maskData = self.hannWindow
self.fullMap = self.halfMap1 + self.halfMap2
self.frequencyMap = FSCutil.calculate_frequency_map(self.halfMap1)
tmpResVec, FSC, _, _, qVals_FDR, resolution_FDR, _ = FSCutil.FSC(
self.halfMap1, self.halfMap2, maskData, self.apix, 0.143, 1, False,
True, None, True)
self.resolution = resolution_FDR
self.FSCdata = FSC
#self.calcTTest();
self.qVals = qVals_FDR
self.resVec = tmpResVec
self.filterMap()
self.writeFSC()
def loopOverMap(iSeq, queue, paddedMask, paddedHalfMap1, paddedHalfMap2,
boxSize, sizeMap, stepSize, halfBoxSize, hannWindow, apix,
cutoff, numAsymUnits, permutedCorCoeffs):
# ********************************************
# ******* iterate over the map and calc ******
# ************ local resolutions *************
# ********************************************
locRes = np.zeros((len(range(boxSize, boxSize + sizeMap[0], stepSize)),
len(range(boxSize, boxSize + sizeMap[1], stepSize)),
len(range(boxSize, boxSize + sizeMap[2], stepSize))))
for i in iSeq:
iInd = int((i - boxSize) / stepSize)
jInd = 0
for j in range(boxSize, boxSize + sizeMap[1], stepSize):
kInd = 0
for k in range(boxSize, boxSize + sizeMap[2], stepSize):
if paddedMask[i, j, k] > 0.99:
window_halfmap1 = paddedHalfMap1[i - halfBoxSize:i -
halfBoxSize + boxSize,
j - halfBoxSize:j -
halfBoxSize + boxSize,
k - halfBoxSize:k -
halfBoxSize + boxSize]
window_halfmap2 = paddedHalfMap2[i - halfBoxSize:i -
halfBoxSize + boxSize,
j - halfBoxSize:j -
halfBoxSize + boxSize,
k - halfBoxSize:k -
halfBoxSize + boxSize]
# apply hann window
window_halfmap1 = window_halfmap1 * hannWindow
window_halfmap2 = window_halfmap2 * hannWindow
_, _, _, _, _, tmpRes, _ = FSCutil.FSC(
window_halfmap1, window_halfmap2, None, apix, cutoff,
numAsymUnits, True, False, permutedCorCoeffs, False)
locRes[iInd, jInd, kInd] = tmpRes
else:
locRes[iInd, jInd, kInd] = 0.0
kInd = kInd + 1
jInd = jInd + 1
#push back the local resolution map to the list
queue.put(locRes)
def localResolution(self, embeddingData, image1, image2, apix, stepSize,
boxSize, lowRes):
np.random.seed(3)
self.apix = float(apix)
#****************************
#**** do two embeddings *****
#****************************
if embeddingData is not None:
#split the localizations randomly in 2 half sets
numLocalizations = embeddingData.shape[0]
self.dimension = embeddingData.shape[1]
sizeHalfSet = int(numLocalizations / 2)
permutedSequence = np.random.permutation(
np.arange(numLocalizations))
self.embeddingsHalf1 = embeddingData[
permutedSequence[0:sizeHalfSet], :]
self.embeddingsHalf2 = embeddingData[
permutedSequence[sizeHalfSet:], :]
self.embedding = embeddingData
self.make_half_maps()
#****************************
#***** use two images *******
#****************************
elif image1 is not None:
self.halfMap1 = image1
self.halfMap2 = image2
self.halfMap1 = self.halfMap1 + np.random.randn(
self.halfMap1.shape[0], self.halfMap1.shape[1]) * 0.01
self.halfMap2 = self.halfMap2 + np.random.randn(
self.halfMap2.shape[0], self.halfMap1.shape[1]) * 0.01
#maskData = FSCutil.makeCircularMask(self.halfMap1, (np.min(self.halfMap1.shape) / 2.0) - 4.0); # circular mask
maskData = np.ones(self.halfMap1.shape)
self.fullMap = self.halfMap1 + self.halfMap2
self.frequencyMap = FSCutil.calculate_frequency_map(self.halfMap1)
#estimate the local resolutions
self.localResolutions = localResolutions2D.localResolutions2D(
self.halfMap1, self.halfMap2, boxSize, stepSize, 0.5, self.apix, 1,
maskData, maskData, lowRes)
#do local filtering
self.filteredMap, _, _, _ = mapUtil.localFiltration(
self.fullMap, self.localResolutions, self.apix, False, None, None,
None)
self.filteredMap[self.filteredMap < 0.0] = 0.0
def runLocalFSC(self):
#show message box before starting
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Start the job with OK!")
msg.setInformativeText("GUI will be locked until the job is finished. See terminal printouts for progress ...");
msg.setWindowTitle("Start job");
msg.setStandardButtons( QMessageBox.Cancel| QMessageBox.Ok);
result = msg.exec_();
if result == QMessageBox.Cancel:
return;
start = time.time();
print('***************************************************');
print('******* Significance analysis of FSC curves *******');
print('***************************************************');
#read the half maps
try:
half_map1 = mrcfile.open(self.fileLine_halfMap1.text(), mode='r');
half_map2 = mrcfile.open(self.fileLine_halfMap2.text(), mode='r');
except:
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Cannot read file ...");
msg.setWindowTitle("Error");
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel);
retval = msg.exec_();
return;
halfMap1Data = np.copy(half_map1.data);
halfMap2Data = np.copy(half_map2.data);
sizeMap = halfMap1Data.shape;
# set output filename and working directory
path = self.fileLine_output.text();
if path == '':
path = os.path.dirname(self.fileLine_halfMap1.text());
os.chdir(path);
splitFilename = os.path.splitext(os.path.basename(self.fileLine_halfMap1.text()));
outputFilename_LocRes = splitFilename[0] + "_localResolutions.mrc";
# make the mask
try:
mask = mrcfile.open(self.fileLine_mask.text(), mode='r+');
except:
mask = None;
maskData = FSCutil.makeCircularMask(halfMap1Data, (np.min(halfMap1Data.shape) / 2.0) - 4.0); # circular mask
if mask is not None:
print("Using user provided mask ...");
maskPermutationData = np.copy(mask.data);
else:
maskPermutationData = maskData;
#**************************************
#********* get pixel size *************
#**************************************
apixMap = float(half_map1.voxel_size.x);
try:
apix = float(self.apix.text());
except:
apix = None;
if apix is not None:
print('Pixel size set to {:.3f} Angstroem. (Pixel size encoded in map: {:.3f})'.format(apix, apixMap));
else:
print(
'Pixel size was read as {:.3f} Angstroem. If this is incorrect, please specify with -p pixelSize'.format(
apixMap));
apix = apixMap;
#******************************************
#************* get step Size **************
#******************************************
try:
stepSize = int(self.stepSize.text());
except:
print("Invalid input for stepSize. Needs to be a integer >= 0 ...")
#******************************************
#************* get step Size **************
#******************************************
try:
stepSize = int(self.stepSize.text());
except:
print("Invalid input for stepSize. Needs to be a integer >= 0 ...")
#********************************************
#************* get window size **************
#********************************************
try:
windowSize = int(self.w.text());
except:
print("Invalid input for windowSize. Needs to be a integer >= 0 ...");
# ********************************************
# ************* get window size **************
# ********************************************
try:
lowRes = int(self.lowRes.text());
except:
lowRes = None;
# *******************************************
# ********* calc local Resolutions **********
# *******************************************
FSCcutoff = 0.5;
localResMap = localResolutions.localResolutions(halfMap1Data, halfMap2Data, windowSize, stepSize, FSCcutoff, apix,
1,
maskData, maskPermutationData);
# set lowest resolution if wished
if lowRes is not None:
lowRes = lowRes;
localResMap[localResMap > lowRes] = lowRes;
# write the local resolution map
localResMapMRC = mrcfile.new(outputFilename_LocRes, overwrite=True);
localResMap = np.float32(localResMap);
localResMapMRC.set_data(localResMap);
localResMapMRC.voxel_size = apix;
localResMapMRC.close();
output = "Saved local resolutions map to: " + outputFilename_LocRes;
print(output);
end = time.time();
totalRuntime = end - start;
print("****** Summary ******");
print("Runtime: %.2f" % totalRuntime);
self.showMessageBox();
def runFSC(self):
#show message box before starting
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Start the job with OK!")
msg.setInformativeText("GUI will be locked until the job is finished. See terminal printouts for progress ...");
msg.setWindowTitle("Start job");
msg.setStandardButtons( QMessageBox.Cancel| QMessageBox.Ok);
result = msg.exec_();
if result == QMessageBox.Cancel:
return;
start = time.time();
print('***************************************************');
print('******* Significance analysis of FSC curves *******');
print('***************************************************');
#read the half maps
try:
half_map1 = mrcfile.open(self.fileLine_halfMap1.text(), mode='r');
half_map2 = mrcfile.open(self.fileLine_halfMap2.text(), mode='r');
except:
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Cannot read file ...");
msg.setWindowTitle("Error");
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel);
retval = msg.exec_();
return;
halfMap1Data = np.copy(half_map1.data);
halfMap2Data = np.copy(half_map2.data);
sizeMap = halfMap1Data.shape;
# set working directory and output filename
path = self.fileLine_output.text();
if path == '':
path = os.path.dirname(self.fileLine_halfMap1.text());
os.chdir(path);
splitFilename = os.path.splitext(os.path.basename(self.fileLine_halfMap1.text()));
outputFilename_PostProcessed = splitFilename[0] + "_filtered.mrc";
# make the mask
maskData = FSCutil.makeCircularMask(halfMap1Data, (np.min(halfMap1Data.shape) / 2.0) - 4.0); # circular mask
maskBFactor = FSCutil.makeCircularMask(halfMap1Data, (
np.min(halfMap1Data.shape) / 4.0) - 4.0); # smaller circular mask for B-factor estimation
#**************************************
#********* get pixel size *************
#**************************************
apixMap = float(half_map1.voxel_size.x);
try:
apix = float(self.apix.text());
except:
apix = None;
if apix is not None:
print('Pixel size set to {:.3f} Angstroem. (Pixel size encoded in map: {:.3f})'.format(apix, apixMap));
else:
print(
'Pixel size was read as {:.3f} Angstroem. If this is incorrect, please specify with -p pixelSize'.format(
apixMap));
apix = apixMap;
#******************************************
#*********** get num Asym Units ***********
#******************************************
try:
numAsymUnits = int(self.numAsUnit.text());
except:
numAsymUnits = None;
if numAsymUnits is not None:
print('Using user provided number of asymmetric units, given as {:d}'.format(numAsymUnits));
else:
symmetry = self.symmetry.text();
numAsymUnits = FSCutil.getNumAsymUnits(symmetry);
print('Using provided ' + symmetry + ' symmetry. Number of asymmetric units: {:d}'.format(numAsymUnits));
#**********************************************
#*************** get resolutions **************
#**********************************************
#read the mask
#mask = mrcfile.open('/Users/mbeckers/Documents/LabBook/2019/June2019/mapModel_FSC/betaGal_refinement/mask.mrc', mode='r');
#maskData = mask.data;
#run the FSC
res, FSC, percentCutoffs, pValues, qValsFDR, resolution, _ = FSCutil.FSC(halfMap1Data, halfMap2Data,
maskData, apix, 0.143,
numAsymUnits, False, True, None,
False);
# write the FSC
FSCutil.writeFSC(res, FSC, qValsFDR, pValues, resolution);
processedMap = FDRutil.sharpenMap(0.5 * (halfMap1Data + halfMap2Data), 0, apix, resolution);
# write the post-processed map
postProcMRC = mrcfile.new(outputFilename_PostProcessed, overwrite=True);
postProc = np.float32(processedMap);
postProcMRC.set_data(postProc);
postProcMRC.voxel_size = apix;
postProcMRC.close();
output = "Saved filtered map to: " + outputFilename_PostProcessed;
print(output);
end = time.time();
totalRuntime = end - start;
print("****** Summary ******");
print("Runtime: %.2f" % totalRuntime);
self.showMessageBox(resolution);
def localResolutions(halfMap1, halfMap2, boxSize, stepSize, cutoff, apix,
numAsymUnits, mask, maskPermutation):
# ********************************************
# ****** calculate local resolutions by ******
# ********** local FSC-thresholding **********
# ********************************************
print("Starting calculations of local resolutions ...")
sizeMap = halfMap1.shape
locRes = np.zeros((len(range(boxSize, boxSize + sizeMap[0], stepSize)),
len(range(boxSize, boxSize + sizeMap[1], stepSize)),
len(range(boxSize, boxSize + sizeMap[2], stepSize))))
# pad the volumes
paddedHalfMap1 = np.zeros(
(sizeMap[0] + 2 * boxSize, sizeMap[1] + 2 * boxSize,
sizeMap[2] + 2 * boxSize))
paddedHalfMap2 = np.zeros(
(sizeMap[0] + 2 * boxSize, sizeMap[1] + 2 * boxSize,
sizeMap[2] + 2 * boxSize))
paddedMask = np.zeros((sizeMap[0] + 2 * boxSize, sizeMap[1] + 2 * boxSize,
sizeMap[2] + 2 * boxSize))
paddedMaskPermutation = np.zeros(
(sizeMap[0] + 2 * boxSize, sizeMap[1] + 2 * boxSize,
sizeMap[2] + 2 * boxSize))
paddedHalfMap1[boxSize:boxSize + sizeMap[0], boxSize:boxSize + sizeMap[1],
boxSize:boxSize + sizeMap[2]] = halfMap1
paddedHalfMap2[boxSize:boxSize + sizeMap[0], boxSize:boxSize + sizeMap[1],
boxSize:boxSize + sizeMap[2]] = halfMap2
paddedMask[boxSize:boxSize + sizeMap[0], boxSize:boxSize + sizeMap[1],
boxSize:boxSize + sizeMap[2]] = mask
paddedMaskPermutation[boxSize:boxSize + sizeMap[0],
boxSize:boxSize + sizeMap[1],
boxSize:boxSize + sizeMap[2]] = maskPermutation
halfBoxSize = int(boxSize / 2.0)
# make Hann window
hannWindow = FDRutil.makeHannWindow(np.zeros((boxSize, boxSize, boxSize)))
numCalculations = len(range(
boxSize, boxSize + sizeMap[0], stepSize)) * len(
range(boxSize, boxSize + sizeMap[1], stepSize)) * len(
range(boxSize, boxSize + sizeMap[0], stepSize))
print("Total number of calculations: " + repr(numCalculations))
# ****************************************************
# ********* get initial permuted CorCoeffs ***********
# ****************************************************
print("Do initial permuations ...")
for i in range(10):
xInd = np.random.randint(boxSize, sizeMap[0] + boxSize)
yInd = np.random.randint(boxSize, sizeMap[1] + boxSize)
zInd = np.random.randint(boxSize, sizeMap[2] + boxSize)
#xInd = np.random.randint(sizeMap[0]/2 - sizeMap[0]/8 + boxSize, sizeMap[0]/2 + sizeMap[0]/8 + boxSize);
#yInd = np.random.randint(sizeMap[1]/2 - sizeMap[1]/8 + boxSize, sizeMap[1]/2 + sizeMap[1]/8 + boxSize);
#zInd = np.random.randint(sizeMap[2]/2 - sizeMap[2]/8 + boxSize, sizeMap[2]/2 + sizeMap[2]/8 + boxSize);
#generate new locations until one is found in the mask
while ((paddedMaskPermutation[xInd, yInd, zInd] < 0.5)):
xInd = np.random.randint(boxSize, sizeMap[0] + boxSize)
yInd = np.random.randint(boxSize, sizeMap[1] + boxSize)
zInd = np.random.randint(boxSize, sizeMap[2] + boxSize)
#xInd = np.random.randint(sizeMap[0] / 2 - sizeMap[0] / 8 + boxSize,
# sizeMap[0] / 2 + sizeMap[0] / 8 + boxSize);
#yInd = np.random.randint(sizeMap[1] / 2 - sizeMap[1] / 8 + boxSize,
# sizeMap[1] / 2 + sizeMap[1] / 8 + boxSize);
#zInd = np.random.randint(sizeMap[2] / 2 - sizeMap[2] / 8 + boxSize,
# sizeMap[2] / 2 + sizeMap[2] / 8 + boxSize);
#get windowed parts
windowHalfmap1 = paddedHalfMap1[xInd - halfBoxSize:xInd - halfBoxSize +
boxSize, yInd - halfBoxSize:yInd -
halfBoxSize + boxSize,
zInd - halfBoxSize:zInd - halfBoxSize +
boxSize]
windowHalfmap2 = paddedHalfMap2[xInd - halfBoxSize:xInd - halfBoxSize +
boxSize, yInd - halfBoxSize:yInd -
halfBoxSize + boxSize,
zInd - halfBoxSize:zInd - halfBoxSize +
boxSize]
# apply hann window
windowHalfmap1 = windowHalfmap1 * hannWindow
windowHalfmap2 = windowHalfmap2 * hannWindow
res, _, _, _, _, _, tmpPermutedCorCoeffs = FSCutil.FSC(
windowHalfmap1, windowHalfmap2, None, apix, cutoff, numAsymUnits,
True, False, None, False)
if i == 0:
# initialize the array of correlation coefficients
permutedCorCoeffs = tmpPermutedCorCoeffs
else:
# append the correlation coefficients
for resInd in range(len(tmpPermutedCorCoeffs)):
permutedCorCoeffs[resInd] = np.append(
permutedCorCoeffs[resInd], tmpPermutedCorCoeffs[resInd])
# ****************************************************
# ********* calculate the local resolutions **********
# ****************************************************
print("Do local FSC calculations ...")
# generate partial function to loop over the whole map
partialLoopOverMap = functools.partial(loopOverMap,
paddedMask=paddedMask,
paddedHalfMap1=paddedHalfMap1,
paddedHalfMap2=paddedHalfMap2,
boxSize=boxSize,
sizeMap=sizeMap,
stepSize=stepSize,
halfBoxSize=halfBoxSize,
hannWindow=hannWindow,
apix=apix,
cutoff=cutoff,
numAsymUnits=numAsymUnits,
permutedCorCoeffs=permutedCorCoeffs)
#parallelized local resolutions
numCores = min(multiprocessing.cpu_count(), 4)
print(
"Using {:d} cores. This might take a few minutes ...".format(numCores))
iIterable = range(boxSize, boxSize + sizeMap[0], stepSize)
#initialize parallel processes
lenInt = int(math.ceil(len(iIterable) / float(numCores)))
queue = multiprocessing.Queue()
#start process for each core and run in parallel
for i in range(numCores):
#split the iterable
startInd = (i * lenInt)
endInd = (i + 1) * lenInt
if i == (numCores - 1):
seq = range(iIterable[startInd],
iIterable[len(iIterable) - 1] + stepSize, stepSize)
else:
seq = range(iIterable[startInd], iIterable[endInd], stepSize)
#start the respective process
proc = multiprocessing.Process(target=partialLoopOverMap,
args=(
seq,
queue,
))
proc.start()
#addition of indiviual local resolution maps to produce the final one
for i in range(numCores):
locRes = locRes + queue.get()
# *************************************
# ********** do interpolation *********
# *************************************
#locRes[locRes==0] = 2.2;
print("Interpolating local Resolutions ...")
x = np.linspace(1, 10, locRes.shape[0])
y = np.linspace(1, 10, locRes.shape[1])
z = np.linspace(1, 10, locRes.shape[2])
myInterpolatingFunction = RegularGridInterpolator((x, y, z),
locRes,
method='linear')
xNew = np.linspace(1, 10, sizeMap[0])
yNew = np.linspace(1, 10, sizeMap[1])
zNew = np.linspace(1, 10, sizeMap[2])
xInd, yInd, zInd = np.meshgrid(xNew,
yNew,
zNew,
indexing='ij',
sparse=True)
localRes = myInterpolatingFunction((xInd, yInd, zInd))
localRes[mask <= 0.01] = 0.0
return localRes
def runFSC(self):
#show message box before starting
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Start the job with OK!")
msg.setInformativeText("GUI will be locked until the job is finished. See terminal printouts for progress ...");
msg.setWindowTitle("Start job");
msg.setStandardButtons( QMessageBox.Cancel| QMessageBox.Ok);
result = msg.exec_();
if result == QMessageBox.Cancel:
return;
start = time.time();
print('***************************************************');
print('********** Sharpening of cryo-EM maps ***********');
print('***************************************************');
#read the half maps
try:
half_map1 = mrcfile.open(self.fileLine_halfMap1.text(), mode='r');
half_map2 = mrcfile.open(self.fileLine_halfMap2.text(), mode='r');
except:
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Cannot read file ...");
msg.setWindowTitle("Error");
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel);
retval = msg.exec_();
return;
halfMap1Data = np.copy(half_map1.data);
halfMap2Data = np.copy(half_map2.data);
sizeMap = halfMap1Data.shape;
# set working directory and output filename
path = self.fileLine_output.text();
if path == '':
path = os.path.dirname(self.fileLine_halfMap1.text());
os.chdir(path);
splitFilename = os.path.splitext(os.path.basename(self.fileLine_halfMap1.text()));
outputFilename_PostProcessed = "postProcessed.mrc";
outputFilename_PostProcessed_half1 = "postProcessed_half1.mrc";
outputFilename_PostProcessed_half2 = "postProcessed_half2.mrc";
# make the mask
maskData = FSCutil.makeCircularMask(halfMap1Data, (np.min(halfMap1Data.shape) / 2.0) - 4.0); # circular mask
maskBFactor = FSCutil.makeCircularMask(halfMap1Data, (
np.min(halfMap1Data.shape) / 4.0) - 4.0); # smaller circular mask for B-factor estimation
#**************************************
#********* get pixel size *************
#**************************************
apixMap = float(half_map1.voxel_size.x);
try:
apix = float(self.apix.text());
except:
apix = None;
if apix is not None:
print('Pixel size set to {:.3f} Angstroem. (Pixel size encoded in map: {:.3f})'.format(apix, apixMap));
else:
print(
'Pixel size was read as {:.3f} Angstroem. If this is incorrect, please specify with -p pixelSize'.format(
apixMap));
apix = apixMap;
#**********************************************
#***************** get bfactor ****************
#**********************************************
try:
bFactorInput = float(self.bFactor.text());
except:
bFactorInput = None;
#**********************************************
#***************** get bfactor ****************
#**********************************************
try:
resolution = float(self.resolution.text());
except:
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("No resolution specified ...");
msg.setWindowTitle("Error");
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel);
retval = msg.exec_();
return;
if (resolution > 8.0) and (bFactorInput is None):
msg = QMessageBox();
msg.setIcon(QMessageBox.Information);
msg.setText("Automated B-factor estimation is unstable for low-resolution maps. Please specify a B-factor!");
msg.setWindowTitle("Error");
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel);
retval = msg.exec_();
return;
if bFactorInput is not None:
bFactor = bFactorInput;
bFactor_half1 = bFactorInput;
bFactor_half2 = bFactorInput;
print('Using a user-specified B-factor of {:.2f} for map sharpening'.format(-bFactor));
else:
# estimate b-factor and sharpen the map
bFactor = FSCutil.estimateBfactor(0.5 * (halfMap1Data + halfMap2Data), resolution, apix, maskBFactor);
print('Using a B-factor of {:.2f} for map sharpening.'.format(-bFactor));
#bFactor_half1 = FSCutil.estimateBfactor(halfMap1Data, resolution, apix, maskBFactor);
#bFactor_half2 = FSCutil.estimateBfactor(halfMap2Data, resolution, apix, maskBFactor);
#print("B-factor of halfmap 1: {:.2f}".format(bFactor_half1));
#print("B-factor of halfmap 2: {:.2f}".format(bFactor_half2));
processedMap = FDRutil.sharpenMap(0.5 * (halfMap1Data + halfMap2Data), -bFactor, apix, resolution);
#processed_halfMap1 = FDRutil.sharpenMap(halfMap1Data, -bFactor_half1, apix, resolution);
#processed_halfMap2 = FDRutil.sharpenMap(halfMap2Data, -bFactor_half2, apix, resolution);
# write the post-processed map
postProcMRC = mrcfile.new(outputFilename_PostProcessed, overwrite=True);
postProc = np.float32(processedMap);
postProcMRC.set_data(postProc);
postProcMRC.voxel_size = apix;
postProcMRC.close();
"""
# write the post-processed halfmaps
postProcMRC = mrcfile.new(outputFilename_PostProcessed_half1, overwrite=True);
postProc = np.float32(processed_halfMap1);
postProcMRC.set_data(postProc);
postProcMRC.voxel_size = apix;
postProcMRC.close();
postProcMRC = mrcfile.new(outputFilename_PostProcessed_half2, overwrite=True);
postProc = np.float32(processed_halfMap2);
postProcMRC.set_data(postProc);
postProcMRC.voxel_size = apix;
postProcMRC.close();
"""
output = "Saved sharpened and filtered map to: " + outputFilename_PostProcessed;
print(output);
end = time.time();
totalRuntime = end - start;
print("****** Summary ******");
print("Runtime: %.2f" % totalRuntime);
self.showMessageBox(resolution, bFactor);
def main():
start = time.time()
print('***************************************************')
print('******* Significance analysis of FSC curves *******')
print('***************************************************')
# get command line input
args = cmdl_parser.parse_args()
#read the half maps
halfMap1 = mrcfile.open(args.halfmap1, mode='r')
halfMap2 = mrcfile.open(args.halfmap2, mode='r')
halfMap1Data = np.copy(halfMap1.data)
halfMap2Data = np.copy(halfMap2.data)
#get size of map
sizeMap = halfMap2Data.shape
#set pixel size
apix = float(halfMap1.voxel_size.x)
if args.apix is not None:
print(
'Pixel size set to {:.3f} Angstroem. (Pixel size encoded in map: {:.3f})'
.format(args.apix, apix))
apix = args.apix
else:
print(
'Pixel size was read as {:.3f} Angstroem. If this is incorrect, please specify with -p pixelSize'
.format(apix))
args.apix = apix
# set output filename
splitFilename = os.path.splitext(os.path.basename(args.halfmap1))
print(splitFilename[0])
outputFilename_LocRes = splitFilename[0] + "_localResolutions.mrc"
outputFilename_PostProcessed = "postProcessed.mrc"
outputFilename_PostProcessed_half1 = "postProcessed_half1.mrc"
outputFilename_PostProcessed_half2 = "postProcessed_half2.mrc"
outputFilename_averagedHalfmaps = splitFilename[0] + "_avg.mrc"
#handle window size for local FSC
if args.window_size is not None:
wn = args.window_size
wn = int(wn)
else:
wn = 20
#default is 20 pixels
#handle step size for local FSC
if args.stepSize is None:
stepSize = float(sizeMap[0] * sizeMap[1] * sizeMap[2]) / 300000.0
stepSize = max(int(math.ceil(stepSize**(1.0 / 3.0))), 1)
else:
stepSize = int(args.stepSize)
if not args.localResolutions:
if args.numAsymUnits is not None:
numAsymUnits = args.numAsymUnits
print(
'Using user provided number of asymmetric units, given as {:d}'
.format(numAsymUnits))
else:
if args.symmetry is not None:
numAsymUnits = FSCutil.getNumAsymUnits(args.symmetry)
print('Using provided ' + args.symmetry +
' symmetry. Number of asymmetric units: {:d}'.format(
numAsymUnits))
else:
numAsymUnits = 1
print('Using C1 symmetry. Number of asymmetric units: {:d}'.
format(numAsymUnits))
else:
#if local resolutions are calculated, no symmetry correction needed
print(
"Using a step size of {:d} voxel. If you prefer another one, please specify with -step."
.format(stepSize))
print(
'Calculating local resolutions. No symmetry correction necessary.')
numAsymUnits = 1.0
#make the mask
print("Using a circular mask ...")
maskData = FSCutil.makeCircularMask(
halfMap1Data, (np.min(halfMap1Data.shape) / 2.0) - 4.0)
#circular mask
maskBFactor = FSCutil.makeCircularMask(
halfMap1Data, (np.min(halfMap1Data.shape) / 4.0) - 4.0)
#smaller circular mask for B-factor estimation
#*******************************************
#********** no local Resolutions ***********
#*******************************************
if not args.localResolutions:
res, FSC, percentCutoffs, pValues, qValsFDR, resolution, _ = FSCutil.FSC(
halfMap1Data, halfMap2Data, maskData, apix, 0.143, numAsymUnits,
False, True, None, False)
# write the FSC
FSCutil.writeFSC(res, FSC, qValsFDR, pValues, resolution)
if resolution < 8.0:
#estimate b-factor and sharpen the map
bFactor = FSCutil.estimateBfactor(
0.5 * (halfMap1Data + halfMap2Data), resolution, apix,
maskBFactor)
#bFactor_half1 = FSCutil.estimateBfactor(halfMap1Data, resolution, apix, maskBFactor);
#bFactor_half2 = FSCutil.estimateBfactor(halfMap2Data, resolution, apix, maskBFactor);
if args.bFactor is not None:
bFactor = args.bFactor
print(
'Using a user-specified B-factor of {:.2f} for map sharpening'
.format(-bFactor))
else:
print('Using a B-factor of {:.2f} for map sharpening.'.format(
-bFactor))
processedMap = FDRutil.sharpenMap(
0.5 * (halfMap1Data + halfMap2Data), -bFactor, apix,
resolution)
#processed_halfMap1 = FDRutil.sharpenMap(halfMap1Data, -bFactor_half1, apix, resolution);
#processed_halfMap2 = FDRutil.sharpenMap(halfMap2Data, -bFactor_half2, apix, resolution);
#write the post-processed maps
postProcMRC = mrcfile.new(outputFilename_PostProcessed,
overwrite=True)
postProc = np.float32(processedMap)
postProcMRC.set_data(postProc)
postProcMRC.voxel_size = apix
postProcMRC.close()
"""
#write the post-processed halfmaps
postProcMRC = mrcfile.new(outputFilename_PostProcessed_half1, overwrite=True);
postProc= np.float32(processed_halfMap1);
postProcMRC.set_data(postProc);
postProcMRC.voxel_size = apix;
postProcMRC.close();
postProcMRC = mrcfile.new(outputFilename_PostProcessed_half2, overwrite=True);
postProc= np.float32(processed_halfMap2);
postProcMRC.set_data(postProc);
postProcMRC.voxel_size = apix;
postProcMRC.close();
"""
output = "Saved sharpened and filtered map to: " + outputFilename_PostProcessed
print(output)
#*******************************************
#********* calc local Resolutions **********
#*******************************************
else:
FSCcutoff = 0.5
#set mask for locations of permutations
if args.mask is not None:
maskPermuation = mrcfile.open(args.mask, mode='r')
maskPermutationData = np.copy(maskPermuation.data)
else:
maskPermutationData = maskData
localResMap = localResolutions.localResolutions(
halfMap1Data, halfMap2Data, wn, stepSize, FSCcutoff, apix,
numAsymUnits, maskData, maskPermutationData)
# set lowest resolution if wished
if args.lowRes is not None:
lowRes = args.lowRes
localResMap[localResMap > lowRes] = lowRes
#write the local resolution map
localResMapMRC = mrcfile.new(outputFilename_LocRes, overwrite=True)
localResMap = np.float32(localResMap)
localResMapMRC.set_data(localResMap)
localResMapMRC.voxel_size = apix
localResMapMRC.close()
output = "Saved local resolutions map to: " + outputFilename_LocRes
print(output)
end = time.time()
totalRuntime = end - start
print("****** Summary ******")
print("Runtime: %.2f" % totalRuntime)