コード例 #1
0
def get_3D_transform():
    #with mrcfile.open("cropout_bin4.mrc") as mrc: # small example
    with mrcfile.open("cropout.mrc") as mrc:

        # coerce to double
        realpart = flex.double(mrc.data.astype(np.float64))
        # in-place resize to a good multiple of 2
        realpart.resize(flex.grid(imax, imax, imax))
        complpart = flex.double(flex.grid(imax, imax, imax))
        #from IPython import embed; embed()
        C3D = flex.complex_double(realpart, complpart)

        from matplotlib import pyplot as plt
        from scitbx import fftpack
        #plt.imshow(S2D)
        #plt.show()
        #from IPython import embed; embed()
        print "C3Dfocus", C3D.focus()
        print C3D
        FFT = fftpack.complex_to_complex_3d(
            (C3D.focus()[0], C3D.focus()[1], C3D.focus()[2]))
        c = FFT.forward(C3D)
        print c.focus()
        print c
        return c
コード例 #2
0
 def raw(filename):
     mrc = mrcfile.open(filename, permissive=True)
     data = mrc.data
     arr = np.zeros(shape=data.shape, dtype=data.dtype)
     arr[:] = data[:]
     data = 0
     return arr
コード例 #3
0
ファイル: processing_functions.py プロジェクト: bbarad/Live2D
def make_photos(basename, working_directory):
    """
    Convert MRC file with stack of classes to series of scaled PNGs for web viewing.

    Args:
        basename (str): name of desired folder within class_images - usually the same name as the mrc file.
        working_directory (str): the base directory where :py:mod:`live_2d` is working.
    Returns:
        str: Directory path with new PNGs written out.
    """
    live2dlog = logging.getLogger("live_2d")
    if not os.path.isdir(os.path.join(working_directory, "class_images")):
        os.mkdir(os.path.join(working_directory, "class_images"))
    if not os.path.isdir(
            os.path.join(working_directory, "class_images", basename)):
        os.mkdir(os.path.join(working_directory, "class_images", basename))
    photo_dir = os.path.join(working_directory, "class_images", basename)
    with mrcfile.open(
            os.path.join(working_directory, "{}.mrc".format(basename)),
            "r") as stack:
        for index, item in enumerate(stack.data):
            imageio.imwrite(
                os.path.join(photo_dir, "{}.png".format(index + 1)), item)
    live2dlog.info(
        f"Exported class averages to web-friendly images stored in {photo_dir}"
    )
    return photo_dir
コード例 #4
0
def get_train_set(img_per_class):
	files = []
	Y = []
	for i in classes:
		for j in range(img_per_class):
			filename = '../data/SNR003/' + str(i) + '/tomotarget' + str(j) + '.mrc'
			files.append(filename)
			Y.append(classes.index(i))

	# print(files)
	c = list(zip(files, Y))
	random.shuffle(c)
	files, Y = zip(*c)

	count = 0
	while True:
		if count == img_per_class*10:
			count = 0

		f = mrcfile.open(files[count])
		x = f.data
		x = pad(x)
		# x = norm_3d(x)
		x = np.expand_dims(x, axis = 0)
		x = np.expand_dims(x, axis = 4)
		y = Y[count]
		y_arr = np.zeros(10)
		y_arr[y] = 1
		y_arr = np.expand_dims(y_arr, axis = 0)
		# print(x.shape)
		count += 1
		# print(x)

		yield x, y_arr
コード例 #5
0
def read_mrc(fname, cut_sino):
    import mrcfile
    # read mrc file for FEI extended header
    # angles.mat file contains the angle information
    proj_geom = {}

    with mrcfile.open(fname, 'r', permissive=True) as mrc:
        proj = mrc.data[:]

        if cut_sino:
            proj = proj[:, cut_sino:-cut_sino, cut_sino:-cut_sino]

        proj_geom['type'] = 'parallel3d'
        proj_geom['DetectorColCount'] = proj.shape[2]
        proj_geom['DetectorRowCount'] = proj.shape[1]
        proj_geom['DetectorSpacingX'] = 2. / proj.shape[2]
        proj_geom['DetectorSpacingY'] = 2. / proj.shape[1]
        proj_geom['DistanceOriginSource'] = 4.0

    import struct
    proj_geom['ProjectionAngles'] = np.zeros(proj.shape[0])

    with open(fname, "rb") as f:
        for i in range(proj.shape[0]):
            f.seek(1024 + (i) * 128, 0)
            byte_float = f.read(4)
            proj_geom['ProjectionAngles'][i] = struct.unpack(
                'f', byte_float)[0] * np.pi / 180

    return proj, proj_geom
コード例 #6
0
def intialize():  # initialize program
    global mrc, img_matrix, shape, nx, ny, nz, df, unit, global_regionid, cube_id, threshold
    fname = input("choose mrc file:")
    mrc = mrcfile.open(fname, mode='r+')
    img_matrix = np.copy(mrc.data)
    img_matrix = gaussian_filter(img_matrix,
                                 sigma=1,
                                 mode="constant",
                                 cval=0.0,
                                 truncate=4.0)
    img_matrix = gaussian_filter(img_matrix,
                                 sigma=1,
                                 mode="constant",
                                 cval=0.0,
                                 truncate=4.0)
    threshold = img_matrix.mean()
    nx = mrc.header.nx
    ny = mrc.header.ny
    nz = mrc.header.nz
    shape = (nx, ny, nz)
    # img_matrix = gaussian_filter(img_matrix, sigma=1, mode="constant", cval=0.0, truncate=4.0)
    unit = int(math.sqrt(nx))
    df = pd.DataFrame({"Name": [fname]})
    df['region number in divide'] = "8/8"
    global_regionid = -1
コード例 #7
0
def read_mrc(image_path):
    with mrcfile.open(image_path, permissive=True) as mrc:
        mrc_image_data = np.copy(mrc.data)
    mrc_image_data = np.squeeze(mrc_image_data)
    mrc_image_data = np.flipud(mrc_image_data)

    return mrc_image_data
コード例 #8
0
def mrc_to_tiff(mrc: str, scaling_factor: float, outdir: str = None):
    outdir = Path(outdir)

    print("Loading mrc file...")
    with mrcfile.open(mrc) as fmrc:
        print("Starting conversion to .tiff\n")

        futures = []
        pbar = tqdm.tqdm(total=len(fmrc.data))

        with concurrent.futures.ThreadPoolExecutor(
                max_workers=WORKERS) as executor:
            for i, image in enumerate(fmrc.data):
                out = outdir / f"mrc_{i:05d}.tiff"
                futures.append(
                    executor.submit(
                        convert,
                        image=image,
                        scaling_factor=scaling_factor,
                        out=out,
                        callback=pbar.update,
                    ))

        pbar.close()
        print()

    for future in futures:
        ret = future.result()
コード例 #9
0
def save_image_k3(mrc_name, height=494):
    try:
        micrograph = mrcfile.open(mrc_name, permissive=True).data
        if len(micrograph.shape) == 3:
            micrograph = micrograph.reshape(
                (micrograph.shape[1], micrograph.shape[2]))
        else:
            micrograph = micrograph
        new_img = scale_image(micrograph, height)
        short_edge = min(
            np.array(new_img).shape[0],
            np.array(new_img).shape[1])
        new_img_left = crop_left(np.array(new_img), short_edge, short_edge)
        new_img_right = crop_right(np.array(new_img), short_edge, short_edge)
        new_img.save(
            os.path.join('MicAssess', 'jpgs', 'data',
                         (os.path.basename(mrc_name)[:-4] + '.jpg')))
        new_img_left.save(
            os.path.join('MicAssess', 'k3_left', 'data',
                         (os.path.basename(mrc_name)[:-4] + '.jpg')))
        new_img_right.save(
            os.path.join('MicAssess', 'k3_right', 'data',
                         (os.path.basename(mrc_name)[:-4] + '.jpg')))
    except ValueError:
        print('Warning - Having trouble converting this file:', mrc_name)
        pass
コード例 #10
0
ファイル: mrcutils.py プロジェクト: slaclab/cryoEM-notebooks
def mrc2data(mrc_filename):
    """ mrc2data
    """
    mrc = mrcfile.open(mrc_filename, mode='r+')
    data = mrc.data
    mrc.close()
    return data
コード例 #11
0
    def _read(self):
        with mrcfile.open(self.filepath) as mrc:
            im = mrc.data.astype('double')

        # For multiple mrc files, mrcfile returns an ndarray with (shape n_images, height, width)
        # swap axes 0 and 2 so we get the more natural (height, width, n_images)
        if im.ndim == 3:
            im = np.swapaxes(im, 0, 2)

        self.original_im = im

        # Discard outer pixels
        im = im[
            self.margin_top: -self.margin_bottom if self.margin_bottom is not None else None,
            self.margin_left: -self.margin_right if self.margin_right is not None else None
        ]

        if self.square:
            side_length = min(im.shape[0], im.shape[1])
            im = im[:side_length, :side_length]

        if self.shrink_factor is not None:
            size = tuple((np.array(im.shape) / config.apple.mrc_shrink_factor).astype(int))
            im = np.array(Image.fromarray(im).resize(size, Image.BICUBIC))

        if self.gauss_filter_size is not None:
            im = signal.correlate(
                im,
                Micrograph.gaussian_filter(self.gauss_filter_size, self.gauss_filter_sigma),
                'same'
            )

        self.im = im.astype('double')
        self.shape = im.shape
コード例 #12
0
def execute(paths):
    threshold = get_threshold(paths)

    experimental_map = mrcfile.open(paths['cleaned_map'], mode='r')
    experimental_data = deepcopy(experimental_map.data)

    # Remove low valued data and translate the higher values down to zero.
    experimental_data[experimental_data < 0] = 0
    # experimental_data = percentile_filter(experimental_data, numpy.shape(experimental_data), 5)

    # Change all values < threshold to 0
    experimental_data[experimental_data < threshold] = 0
    # translate data to have min = 0
    experimental_data[experimental_data > 0] -= threshold

    # normalize data with percentile value
    percentile = numpy.percentile(
        experimental_data[numpy.nonzero(experimental_data)], 60)
    experimental_data /= percentile

    # Get rid of the very high-intensity voxels by setting them to 95-percentile
    percentile_98 = numpy.percentile(
        experimental_data[numpy.nonzero(experimental_data)], 98)
    experimental_data[experimental_data > percentile_98] = percentile_98

    # Print the normalized file to disk.
    with mrcfile.new(paths['normalized_map'], overwrite=True) as mrc:
        mrc.set_data(experimental_data)
        mrc.header.origin = experimental_map.header.origin
        mrc.close()
コード例 #13
0
def run(mrcin, prefix=None):
    f = mrcfile.open(mrcin)
    if prefix is None: prefix = os.path.splitext(os.path.basename(mrcin))[0]
    data = f.data
    if data.ndim == 2: data = data.reshape(-1, *data.shape)
    
    print "MRC file loaded"
    print " shape = %s" % (data.shape,)
    print " dtype = %s" % data.dtype
    print
    
    for i in xrange(data.shape[0]):
        size2, size1 = data[i].shape # XXX really?
        cbfout = "%s_%.3d.cbf"%(prefix, i+1)
        print "Writing %s" % cbfout
        cbf.save_numpy_data_as_cbf(data[i].flatten(), size1, size2,
                                   "%s:%d"%(mrcin, i+1),
                                   cbfout, pilatus_header="""
# Detector: %(detname)s
# Pixel_size %(pixelsize)e m x %(pixelsize)e m
# Wavelength %(wavelength)f A
# Detector_distance %(distance)f m
# Beam_xy (%(beamx)f, %(beamy)f) pixels
# Start_angle %(start_angle)%.4f deg.
# Angle_increment %(angle_inc).4f deg.
""" % dict(detname="????",
           pixelsize=75.e-6,
           wavelength=1,
           distance=300.e-3,
           beamx=size1/2., beamy=size2/2.,
           start_angle=0, angle_inc=0))
コード例 #14
0
def basicDVreader(image_path, n_channels=3, z_first=True):
    ''' very simple function to read .dv files as formatted by deltavision
    microscopes.

    image_path is the complete file path of the image
    for deconvolved images, rolloff specifies the width of the border in pixels
        to be cropped before further processing
    n_channels (defualt 3) is the number of fluorescence and bright field
        channels
    z_first (default True); boolean, is the the order of the .dv tiff stack z-
        first or channel-first (often, z_first = True for R3D_D3D, 
        z_first = False for R3D)
    '''
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        with mrcfile.open(image_path, permissive=True) as dv:
            dvData = dv.data[:]
            dvShape = dvData.shape
            nZslices = int(dvShape[0] / n_channels)
            dvImage = np.zeros([n_channels, nZslices, dvShape[1], dvShape[2]],
                               dtype='uint16')
            if z_first:
                for channel in range(n_channels):
                    dvImage[channel, :, :, :] = dvData[channel *
                                                       nZslices:channel *
                                                       nZslices +
                                                       nZslices, :, :]
            else:
                for channel in range(n_channels):
                    dvImage[channel, :, :, :] = dvData[
                        channel::n_channels, :, :]
    return dvImage
コード例 #15
0
def write_mrc_from_atoms(
    path: Path,
    atoms: mda.AtomGroup,
    path_out: Path,
    context: float = 4.0,
    cut_box=True,
    keep_data=False,
):
    """mask a mrc map using an group of atoms"""
    if not atoms:
        logger.warning("Cannot crop empty atom selection. No file written")
        return

    with mrcfile.open(path) as mrc:
        voxel, grid, origin, full_data = _get_mrc_properties(mrc)

    data_mask = _create_voxel_mask(atoms,
                                   grid,
                                   origin,
                                   voxel,
                                   context,
                                   symmetric=keep_data)
    data = full_data * data_mask
    if cut_box:
        data, origin, voxel = _mrc_cutbox(data,
                                          full_data,
                                          origin,
                                          voxel,
                                          keep_full=keep_data)

    with mrcfile.new(path_out, overwrite=True) as mrc_out:
        mrc_out.set_data(data.transpose())
        mrc_out.voxel_size = tuple(voxel.tolist())
        mrc_out.header["origin"] = tuple(origin)
コード例 #16
0
 def read_pix_mrc(filename):
     mrc = mrcfile.open(filename)
     data = mrc.data
     arr = np.zeros(shape=data.shape, dtype=np.float32)
     arr[:] = data[:]
     data = 0
     return arr, mrc.voxel_size
コード例 #17
0
    def NoiseGenerator(self, idx):
        self.args.ProjectionSize = int(self.args.ProjectionSize)

        if self.args.UseEstimatedNoise == False:
            image = torch.zeros(self.args.ProjectionSize,
                                self.args.ProjectionSize).normal_()

            image = image.unsqueeze(0)

        else:
            if self.args.dataset == 'Betagal' or self.args.dataset == 'Betagal-Synthetic':

                with mrcfile.open(self.BackgroundPath + str(idx).zfill(6) +
                                  ".mrc") as m:
                    image = np.array(m.data, dtype=np.float32)
                if self.args.GaussianFilterProjection:
                    image = scipy.ndimage.gaussian_filter(
                        image, self.args.GaussianSigma)

                image = Tensor(image).unsqueeze(0).cuda()

        downsampling = image.shape[-1] // self.args.RawProjectionSize
        if downsampling > 1:
            image = torch.nn.functional.avg_pool2d(image,
                                                   kernel_size=downsampling,
                                                   stride=downsampling,
                                                   padding=0)

        image = (image - image.mean((1, 2), keepdim=True)) / image.std(
            (1, 2), keepdim=True)

        return image
コード例 #18
0
def save_mrcs(**args):
    print('Converting mrcs to jpg....')
    os.chdir(os.path.abspath(os.path.dirname(args['input']))) # navigate to the par dir of input file
    try:
        shutil.rmtree(args['output'])
    except OSError:
        pass
    os.mkdir(args['output'])
    os.mkdir(os.path.join(args['output'], 'data'))

    avg_mrc = mrcfile.open(os.path.basename(args['input'])).data
    if len(avg_mrc.shape) == 3:
        num_part = avg_mrc.shape[0]
    elif len(avg_mrc.shape) == 2:
        num_part = 1


    for i in range(num_part):
        new_img = avg_mrc[i,:,:]
        if np.sum(new_img) > 1e-7 or np.sum(new_img) < -1e-7:
            new_img = cutbyradius(new_img)
            new_img = ((new_img-new_img.min())/((new_img.max()-new_img.min())+1e-7)*255).astype('uint8')
            new_img = Image.fromarray(new_img)
            new_img = new_img.convert("L")
            new_img.save(os.path.join(args['output'], 'data', (args['name'] + '_' + str(i+1) + '.jpg')))
コード例 #19
0
    def _read(self):
        with mrcfile.open(self.filepath) as mrc:
            im = mrc.data.astype('double')

        # For multiple mrc files, mrcfile returns an ndarray with (shape n_images, height, width)
        # swap axes 0 and 2 so we get the more natural (height, width, n_images)
        if im.ndim == 3:
            im = np.swapaxes(im, 0, 2)

        self.original_im = im

        # Discard outer pixels
        im = im[self.margin_top:-self.margin_bottom if self.
                margin_bottom is not None else None,
                self.margin_left:-self.margin_right if self.
                margin_right is not None else None]

        if self.square:
            side_length = min(im.shape)
            im = im[:side_length, :side_length]

        if self.shrink_factor is not None:
            im = misc.imresize(im,
                               1 / self.shrink_factor,
                               mode='F',
                               interp='cubic')

        if self.gauss_filter_size is not None:
            im = signal.correlate(
                im,
                Micrograph.gaussian_filter(self.gauss_filter_size,
                                           self.gauss_filter_sigma), 'same')

        self.im = im.astype('double')
        self.shape = im.shape
コード例 #20
0
 def read_mrc(self, mrcfilename=None):
     if mrcfilename is not None:
         self.mrcfilename = mrcfilename
     with mrcfile.open(self.mrcfilename) as emd:
         nx, ny, nz = emd.header['nx'], emd.header['ny'], emd.header['nz']
         x0, y0, z0 = emd.header['origin']['x'], emd.header['origin']['y'],\
             emd.header['origin']['z']
         dx, dy, dz = emd.voxel_size['x'], emd.voxel_size[
             'y'], emd.voxel_size['z']
         xyz = numpy.meshgrid(numpy.arange(x0, x0 + nx * dx, dx),
                              numpy.arange(y0, y0 + ny * dy, dy),
                              numpy.arange(z0, z0 + nz * dz, dz),
                              indexing='ij')
         xyz = numpy.asarray(xyz)
         xyz = xyz.reshape(3, nx * ny * nz)
         xyz = xyz.T
         self.grid = emd.data.flatten(order='F').reshape(nx, ny, nz)
         print('Reading density:')
         print(self.grid.shape)
         self.grid_coords = xyz.reshape(nx, ny, nz, 3)
         self.grid_indices = numpy.indices(self.grid.shape)
         # First to last
         self.grid_indices = numpy.squeeze(self.grid_indices[...,
                                                             None].swapaxes(
                                                                 0, -1))
         assert dy == dx and dz == dx
         self.step = dx
         self.origin = numpy.asarray([x0, y0, z0])
コード例 #21
0
    def read_mrc(self):
        """Gets and preprocesses micrograph.

        Reads the micrograph, applies binning and a low-pass filter.

        Returns:
            Micrograph image.
        """

        with mrcfile.open(self.filename, mode='r+', permissive=True) as mrc:
            im = mrc.data.astype('float')

        # Discard outer pixels
        im = im[config.apple.mrc.margin_top:-config.apple.mrc.margin_bottom,
                config.apple.mrc.margin_left:-config.apple.mrc.margin_right]

        # Make square
        side_length = min(im.shape)
        im = im[:side_length, :side_length]

        im = misc.imresize(im,
                           1 / config.apple.mrc.shrink_factor,
                           mode='F',
                           interp='cubic')
        im = signal.correlate(
            im,
            PickerHelper.gaussian_filter(config.apple.mrc.gauss_filter_size,
                                         config.apple.mrc.gauss_filter_sigma),
            'same')

        return im.astype('double')
コード例 #22
0
ファイル: test_rec.py プロジェクト: jmp1985/guanaco
def test_rec():

    data_expected1 = mrcfile.open("test/rec_expected_gpu.mrc").data
    data_expected2 = mrcfile.open("test/rec_expected_cpu.mrc").data
    data1 = mrcfile.open("test/rec_gpu.mrc").data
    data2 = mrcfile.open("test/rec_cpu.mrc").data
    diff1 = numpy.max(numpy.abs(data_expected1 - data1))
    diff2 = numpy.max(numpy.abs(data_expected1 - data2))
    from matplotlib import pylab

    pylab.imshow((data1 - data2)[100, :, :])
    pylab.show()
    diff3 = numpy.max(numpy.abs(data1 - data2))
    assert diff3 == pytest.approx(0)
    assert diff1 == pytest.approx(0)
    assert diff2 == pytest.approx(0)
コード例 #23
0
ファイル: FilterUtil.py プロジェクト: irenedet/3d-unet
def read_mrc(file):
    """
    Read in a tomogram in MRC or REC format and return its data as a numpy array.
    """

    with mrcfile.open(file, permissive=True) as m:
        return m.data.astype(np.float32)
コード例 #24
0
def CoordsBackground_Betagal_Std(pathCoords, pathMicrograph, threshold=False, NumberParticles=10, sizeParticle=384, downSample=1):

    N=sizeParticle
    M=2*N    

    with mrcfile.open(pathMicrograph, permissive=True) as image:

       
        micrograph=torch.Tensor(image.data).cuda()
    
    template=torch.ones( sizeParticle,sizeParticle).float().cuda()/(sizeParticle**2)
    meanSquare= ConvolveTemplate(micrograph, template, downSample )**2
    Std=ConvolveTemplate(micrograph**2, template, downSample)
    heatmap=Std-meanSquare
    
    
    heatmap=heatmap.cpu().numpy()
    val=np.max(heatmap)
   
    heatmap[:M,:]=val
    heatmap[:,:M]=val

    heatmap[:,-M:]=val
    heatmap[-M:,:]=val
    

    coords=np.zeros((NumberParticles,2))
    for p in range(NumberParticles):

        ind=aminArray(heatmap)
        coords[p,0] = ind[1]
        coords[p,1] = ind[0]
        
        heatmap[ind[0]-sizeParticle//4 : ind[0]+sizeParticle//4 , ind[1]-sizeParticle//4 : ind[1]+sizeParticle//4]=val   
    return coords
コード例 #25
0
def calculate_sphericity(inmrc):
	# read MRC
	inputmrc = (mrcfile.open(inmrc)).data
	inputmrc_copy = copy.deepcopy(inputmrc)
	extended_inputmrc = np.zeros((inputmrc.shape[0]+10,inputmrc.shape[1]+10,inputmrc.shape[2]+10),dtype=np.float) ## Had to extend it before Gaussian filter, else you might edge effects
	extended_inputmrc[6:6+inputmrc.shape[0], 6:6+inputmrc.shape[1], 6:6+inputmrc.shape[2]] = inputmrc_copy
	
	# Gaussian filtering
	# Sigma=1 works well
	blurred = gaussian_filter(extended_inputmrc,sigma=1)

	# Find surfaces using marching cube algorithm
	verts, faces, normals, values = measure.marching_cubes_lewiner(blurred,level=0.5) ## Fixed thresholded due to Gaussian blurring
	
	# Find surface area
	surface_area = measure.mesh_surface_area(verts,faces)

	# Find volume
	blurred[blurred >= 0.5] = 1
	blurred[blurred < 0.5] = 0
	volume = np.sum(blurred)
	
	# Calculate sphericity
	sphericity = (((pi)**(1/3))*((6*volume)**(2/3)))/(surface_area)
	return sphericity
コード例 #26
0
def get_test_set(img_per_class):
	files = []
	Y = []
	for i in classes:
		for j in range(img_per_class):
			filename = '../data/SNR003/' + str(i) + '/tomotarget' + str(499-j) + '.mrc'
			files.append(filename)
			Y.append(classes.index(i))

	count = 0
	# print(files)
	while True:
		if count == img_per_class*10:
			count = 0

		f = mrcfile.open(files[count])
		x = np.asarray(f.data)
		# x = norm_3d(x)
		x = pad(x)
		x = np.expand_dims(x, axis = 0)
		x = np.expand_dims(x, axis = 4)
		y = Y[count]
		y_arr = np.zeros(10)
		y_arr[y] = 1
		y_arr = np.expand_dims(y_arr, axis = 0)

		count += 1

		yield x, y_arr
コード例 #27
0
 def read_mrc(filename):
     mrc = mrcfile.open(filename)
     data = mrc.data
     arr = np.zeros(shape=data.shape, dtype=np.uint8)
     arr[:] = data[:]
     data = 0
     return arr
コード例 #28
0
ファイル: __init__.py プロジェクト: alberttxu/simplectf
 def __init__(
     self,
     mrc,
     pixelsize,
     voltage,
     spherical_abberation,
     amplitude_contrast,
     low_cutoff_res=30,
     high_cutoff_res=5,
 ):
     self.pixelsize = pixelsize
     self.voltage = voltage
     self.spherical_abberation = spherical_abberation
     self.amplitude_contrast = amplitude_contrast
     self.electron_wavelength = wavelength_from_voltage(voltage)
     if type(mrc) == str:
         with mrcfile.open(mrc, permissive=True) as f:
             img = f.data
     elif type(mrc) == np.ndarray:
         img = mrc
     self.spectrum = np.log(
         np.abs(fft.rfft2(img, s=(max(img.shape), max(img.shape)))))
     # keep a copy of the full spectrum
     self.full_spectrum = self.spectrum
     # reduce the spectrum to a desired range and subtract background
     self.spectrum = self._preprocess_spectrum(self.spectrum,
                                               low_cutoff_res,
                                               high_cutoff_res)
コード例 #29
0
def process_experimental_map(map_file, filter_res, contour_level):
    """Filter and resample experimental maps to given resolution."""

    with mrcfile.open(map_file) as mrc:
        pixel_size = mrc.voxel_size['x']

    # Create temporary name
    fnHash = createHash()

    # Uncompress map
    if map_file[-3:] == '.gz':
        with mrcfile.open(map_file) as mrc:
            V_exp = mrc.data.copy()
            uncompressed_map = '%sExp.map'%fnHash
        with mrcfile.new(uncompressed_map) as mrc:
            mrc.set_data(V_exp)
    else:
        uncompressed_map = map_file

    # Assume all pixel sizes are equal and take x dimension
    with mrcfile.open(map_file) as mrc:
        pixel_size = mrc.voxel_size['x']
    # Resize to pixel size of 1A/pixel
    ok = runJob("xmipp_image_resize -i %s -o %sResized.map --factor %f" %
                (uncompressed_map, fnHash, pixel_size))
    # Filter to specified resolution
    if ok:
        ok = runJob("xmipp_transform_filter -i %sResized.map -o %sFiltered.map "\
                    "--fourier low_pass %f --sampling 1"
                    % (fnHash, fnHash, filter_res))
    # Get mask by thresholding to conout level provided
    if ok:
        ok = runJob("xmipp_transform_threshold -i %sResized.map -o %sMask.map "\
                    "--select below %f --substitute binarize -v 0" %
                    (fnHash, fnHash, contour_level))
    # Set filtered volume and mask
    if ok:
        with mrcfile.open(fnHash + 'Filtered.map') as mrc:
            Vf = mrc.data.copy()
        with mrcfile.open(fnHash + 'Mask.map') as mrc:
            Vmask = mrc_mask_to_binary(mrc.data.copy())
    else:
        Vf, Vmask = None, None
    # Remove all temporary files produced
    os.system("rm -f %s*" % fnHash)

    return Vf, Vmask
コード例 #30
0
ファイル: mrc.py プロジェクト: brisvag/peepingtom
 def loader(imageblock):
     if mmap is True:
         mrc = mrcfile.mmap(image_path)
     else:
         mrc = mrcfile.open(image_path)
     imageblock.data = mrc.data
     pixel_size = structured_to_unstructured(mrc.voxel_size)[::-1]
     imageblock.pixel_size = pixel_size