def test_even_projections(self): """ Evenly distributed em2d image projections from a PDB file""" smodel = IMP.Model() ssel = IMP.atom.ATOMPDBSelector() prot = IMP.atom.read_pdb(self.get_input_file_name("1z5s.pdb"), smodel, ssel) IMP.atom.add_radii(prot) particles = IMP.core.get_leaves(prot) n_projections = 3 rows = 80 cols = 80 resolution = 1 apix = 1.5 srw = em2d.SpiderImageReaderWriter() registration_values = em2d.get_evenly_distributed_registration_results( n_projections) options = em2d.ProjectingOptions(apix, resolution) projections = em2d.get_projections(particles, registration_values, rows, cols, options) # Read the stored projections stored_projection_names = em2d.create_filenames( n_projections, "1z5s-fast-projection", "spi") for n in range(0, n_projections): stored_projection_names[n] = self.get_input_file_name( stored_projection_names[n]) stored_projections = em2d.read_images(stored_projection_names, srw) # check for n in range(0, n_projections): for i in range(0, rows): for j in range(0, cols): self.assertAlmostEqual(projections[n](i, j), stored_projections[n](i, j), delta=0.001, msg="Projections generated and stored are different")
def test_even_projections(self): """ Evenly distributed em2d image projections from a PDB file""" smodel = IMP.Model() ssel = IMP.atom.ATOMPDBSelector() prot = IMP.atom.read_pdb(self.get_input_file_name("1z5s.pdb"), smodel, ssel) IMP.atom.add_radii(prot) particles = IMP.core.get_leaves(prot) n_projections = 3 rows = 80 cols = 80 resolution = 1 apix = 1.5 srw = em2d.SpiderImageReaderWriter() registration_values = em2d.get_evenly_distributed_registration_results(n_projections) options = em2d.ProjectingOptions(apix, resolution) projections = em2d.get_projections(particles, registration_values, rows, cols, options) # Read the stored projections stored_projection_names = em2d.create_filenames(n_projections, "1z5s-fast-projection", "spi") for n in xrange(0, n_projections): stored_projection_names[n] = self.get_input_file_name(stored_projection_names[n]) stored_projections = em2d.read_images(stored_projection_names, srw) # check for n in xrange(0, n_projections): for i in xrange(0, rows): for j in xrange(0, cols): self.assertAlmostEqual( projections[n](i, j), stored_projections[n](i, j), delta=0.001, msg="Projections generated and stored are different", )
def test_noisy_projections(self): """ Test the generation of noisy projections""" smodel = IMP.kernel.Model() ssel = IMP.atom.ATOMPDBSelector() fn_model = self.get_input_file_name("1e6v.pdb") prot = IMP.atom.read_pdb(fn_model, smodel, ssel) particles = IMP.core.get_leaves(prot) n_projections = 16 rows = 100 cols = 100 resolution = 1 apix = 1.5 noise_SNR = 0.5 # read the stored noisy images stored_names = [] srw = em2d.SpiderImageReaderWriter() for i in range(0, n_projections): fn_subject = "1e6v-subject-%d-set-%d-%s-apix" \ "-%s-SNR.spi" % (i, n_projections, str(apix), str(noise_SNR)) stored_names.append(self.get_input_file_name(fn_subject)) stored_images = em2d.read_images(stored_names, srw) # Read registration parameters and generate new images fn_regs = self.get_input_file_name('1e6v-subjects-0.5.params') Regs = em2d.read_registration_results(fn_regs) options = em2d.ProjectingOptions(apix, resolution) projections = em2d.get_projections(particles, Regs, rows, cols, options) # Add noise for i in range(0, n_projections): em2d.do_normalize(projections[i], True) em2d.add_noise(projections[i], 0.0, 1. / (noise_SNR**0.5), "gaussian", 3) # theoretical ccc for same images at a level of noise theoretical_ccc = noise_SNR / (noise_SNR + 1) for n in range(0, n_projections): ccc = em2d.get_cross_correlation_coefficient( projections[n], stored_images[n]) # allow 3% difference in cross-correlation self.assertAlmostEqual( theoretical_ccc, ccc, delta=0.03, msg="Noisy projections generated and stored are different")
def test_noisy_projections(self): """ Test the generation of noisy projections""" smodel = IMP.kernel.Model() ssel = IMP.atom.ATOMPDBSelector() fn_model = self.get_input_file_name("1e6v.pdb") prot = IMP.atom.read_pdb(fn_model, smodel, ssel) particles = IMP.core.get_leaves(prot) n_projections = 16 rows = 100 cols = 100 resolution = 1 apix = 1.5 noise_SNR = 0.5 # read the stored noisy images stored_names = [] srw = em2d.SpiderImageReaderWriter() for i in range(0, n_projections): fn_subject = "1e6v-subject-%d-set-%d-%s-apix" \ "-%s-SNR.spi" % (i, n_projections, str(apix), str(noise_SNR)) stored_names.append(self.get_input_file_name(fn_subject)) stored_images = em2d.read_images(stored_names, srw) # Read registration parameters and generate new images fn_regs = self.get_input_file_name('1e6v-subjects-0.5.params') Regs = em2d.read_registration_results(fn_regs) options = em2d.ProjectingOptions(apix, resolution) projections = em2d.get_projections(particles, Regs, rows, cols, options) # Add noise for i in range(0, n_projections): em2d.do_normalize(projections[i], True) em2d.add_noise(projections[i], 0.0, 1. / (noise_SNR ** 0.5), "gaussian", 3) # theoretical ccc for same images at a level of noise theoretical_ccc = noise_SNR / (noise_SNR + 1) for n in range(0, n_projections): ccc = em2d.get_cross_correlation_coefficient(projections[n], stored_images[n]) # allow 3% difference in cross-correlation self.assertAlmostEqual(theoretical_ccc, ccc, delta=0.03, msg="Noisy projections generated and stored are different")
def test_registration(self): """Test the registration of 3 subjects from 1gyt.pdb at 0.5 SNR""" # Get model from PDB file smodel = IMP.Model() ssel = IMP.atom.ATOMPDBSelector() fn_model = self.get_input_file_name("1gyt.pdb") prot = IMP.atom.read_pdb(fn_model, smodel, ssel) particles = IMP.core.get_leaves(prot) # Read subject images srw = em2d.SpiderImageReaderWriter() selection_file = self.get_input_file_name("1gyt-subjects-0.5-SNR.sel") images_to_read_names = em2d.read_selection_file(selection_file) for i in range(0, len(images_to_read_names)): images_to_read_names[i] = self.get_input_file_name( images_to_read_names[i]) subjects = em2d.read_images(images_to_read_names, srw) self.assertEqual(len(subjects), 3, "Problem reading subject images") # Generate 20 evenly distributed projections from the PDB file n_projections = 20 proj_params = em2d.get_evenly_distributed_registration_results( n_projections) rows = 128 cols = 128 pixel_size = 1.5 # for generating projections, use a very high resolution resolution = 8.5 options = em2d.ProjectingOptions(pixel_size, resolution) projections = em2d.get_projections(particles, proj_params, rows, cols, options) self.assertEqual(len(projections), n_projections, "Problem generating projections") # Prepare registration # IMP.set_log_level(IMP.VERBOSE) finder = em2d.ProjectionFinder() score_function = em2d.EM2DScore() params = em2d.Em2DRestraintParameters(pixel_size, resolution, n_projections) params.save_match_images = False params.coarse_registration_method = em2d.ALIGN2D_PREPROCESSING params.optimization_steps = 30 params.simplex_initial_length = 0.1 params.simplex_minimum_size = 0.01 finder.setup(score_function, params) finder.set_model_particles(particles) finder.set_subjects(subjects) finder.set_projections(projections) finder.set_fast_mode(2) finder.get_complete_registration() # Recover the registration results: registration_parameters = finder.get_registration_results() fn_registration_results = "my_1gyt_registration.params" em2d.write_registration_results(fn_registration_results, registration_parameters) # Read the correct registration results: correct_parameters = em2d.read_registration_results( self.get_input_file_name("1gyt-subjects-0.5-SNR.params")) print("determined: ") for r in registration_parameters: print(r.get_rotation(), r.get_shift()) print("correct: ") for r in correct_parameters: print(r.get_rotation(), r.get_shift()) for i in range(0, len(registration_parameters)): # Generate the registered projection imgx = em2d.Image() imgx.set_size(rows, cols) em2d.get_projection(imgx, particles, registration_parameters[i], options) ccc = em2d.get_cross_correlation_coefficient( subjects[i].get_data(), imgx.get_data()) print(i, "ccc", ccc) snr = 0.5 theoretical_ccc = (snr / (1. + snr))**.5 self.assertAlmostEqual( ccc, theoretical_ccc, delta=0.02, msg="Error in registration of subject %d: ccc %8.3f " "theoretical_ccc %8.3f " % (i, ccc, theoretical_ccc)) os.remove(fn_registration_results)
def test_registration(self): """Test the registration of 3 subjects from 1gyt.pdb at 0.5 SNR""" # Get model from PDB file smodel = IMP.Model() ssel = IMP.atom.ATOMPDBSelector() fn_model = self.get_input_file_name("1gyt.pdb") prot = IMP.atom.read_pdb(fn_model, smodel, ssel) particles = IMP.core.get_leaves(prot) # Read subject images srw = em2d.SpiderImageReaderWriter() selection_file = self.get_input_file_name("1gyt-subjects-0.5-SNR.sel") images_to_read_names = em2d.read_selection_file(selection_file) for i in range(0, len(images_to_read_names)): images_to_read_names[i] = self.get_input_file_name( images_to_read_names[i]) subjects = em2d.read_images(images_to_read_names, srw) self.assertEqual(len(subjects), 3, "Problem reading subject images") # Generate 20 evenly distributed projections from the PDB file n_projections = 20 proj_params = em2d.get_evenly_distributed_registration_results( n_projections) rows = 128 cols = 128 pixel_size = 1.5 # for generating projections, use a very high resolution resolution = 1 options = em2d.ProjectingOptions(pixel_size, resolution) projections = em2d.get_projections(particles, proj_params, rows, cols, options) self.assertEqual(len(projections), n_projections, "Problem generating projections") # Prepare registration # IMP.set_log_level(IMP.VERBOSE) finder = em2d.ProjectionFinder() score_function = em2d.EM2DScore() params = em2d.Em2DRestraintParameters(pixel_size, resolution, n_projections) params.save_match_images = False params.coarse_registration_method = em2d.ALIGN2D_PREPROCESSING params.optimization_steps = 30 params.simplex_initial_length = 0.1 params.simplex_minimum_size = 0.01 finder.setup(score_function, params) finder.set_model_particles(particles) finder.set_subjects(subjects) finder.set_projections(projections) finder.set_fast_mode(2) finder.get_complete_registration() # Recover the registration results: registration_parameters = finder.get_registration_results() fn_registration_results = "my_1gyt_registration.params" em2d.write_registration_results(fn_registration_results, registration_parameters) # Read the correct registration results: correct_parameters = em2d.read_registration_results( self.get_input_file_name("1gyt-subjects-0.5-SNR.params")) print("determined: ") for r in registration_parameters: print(r.get_rotation(), r.get_shift()) print("correct: ") for r in correct_parameters: print(r.get_rotation(), r.get_shift()) for i in range(0, len(registration_parameters)): # Generate the registered projection imgx = em2d.Image() imgx.set_size(rows, cols) em2d.get_projection(imgx, particles, registration_parameters[i], options) ccc = em2d.get_cross_correlation_coefficient( subjects[i].get_data(), imgx.get_data()) print(i, "ccc", ccc) snr = 0.5 theoretical_ccc = (snr / (1. + snr)) ** .5 self.assertAlmostEqual(ccc, theoretical_ccc, delta=0.02, msg="Error in registration of subject %d: ccc %8.3f " "theoretical_ccc %8.3f " % (i, ccc, theoretical_ccc)) os.remove(fn_registration_results)
def score_model(complete_fn_model, images_sel_file, pixel_size, n_projections=20, resolution=1, images_per_batch=250): """ Score a model Scores a model against the images in the selection file. Reads the images in batchs to avoid memory problems resolution and pixel_size are used for generating projections of the model The finder is an em2d.ProjectionFinder used for projection matching and optimizations """ print "SCORING MODEL:",complete_fn_model cwd = os.getcwd() images_dir, nil = os.path.split(images_sel_file) images_names = em2d.read_selection_file(images_sel_file) n_images = len(images_names) if(n_images == 0): raise ValueError(" Scoring with a empty set of images") # TYPICAL OPTIMIZER PARAMETERS params = em2d.Em2DRestraintParameters(pixel_size, resolution) params.coarse_registration_method = em2d.ALIGN2D_PREPROCESSING params.optimization_steps = 4 params.simplex_initial_length = 0.1 params.simplex_minimum_size=0.02 params.save_match_images = True score_function = em2d.EM2DScore() finder = em2d.ProjectionFinder() finder.setup(score_function, params) # Get the number of rows and cols from the 1st image srw = em2d.SpiderImageReaderWriter() test_imgs = em2d.read_images([os.path.join(images_dir, images_names[0])], srw) rows = test_imgs[0].get_header().get_number_of_columns() cols = test_imgs[0].get_header().get_number_of_rows() model = IMP.Model() ssel = atom.ATOMPDBSelector() prot = atom.read_pdb(complete_fn_model, model, ssel) particles = IMP.core.get_leaves(prot) # generate projections proj_params = em2d.get_evenly_distributed_registration_results(n_projections) opts = em2d.ProjectingOptions(pixel_size, resolution) projections = em2d.get_projections(particles, proj_params, rows, cols, opts) finder.set_model_particles(particles) finder.set_projections(projections) optimized_solutions= 2 finder.set_fast_mode(optimized_solutions) # read the images in blocks to avoid memory problems all_registration_results = [] init_set = 0 init_time = time.time() while(init_set < n_images): end_set = min( init_set + images_per_batch, n_images ) if(images_dir != ""): os.chdir(images_dir) subjects = em2d.read_images(images_names[init_set:end_set], srw) # register finder.set_subjects(subjects) os.chdir(cwd) finder.get_complete_registration() # Recover the registration results: registration_results = finder.get_registration_results() for reg in registration_results: all_registration_results.append(reg) init_set += images_per_batch os.chdir(cwd) em2d.write_registration_results("registration.params", all_registration_results) print "score_model: time complete registration",time.time()-init_time print "coarse registration time",finder.get_coarse_registration_time() print "fine registration time",finder.get_fine_registration_time() return all_registration_results