def testMMTF(self): '''Styled MMTF export/import''' S = 0b10 # 1 << 1 spheres D = 0b1000000000 # 1 << 9 dots B = 2 # blue R = 4 # red cmd.fragment('gly') cmd.color(B) cmd.color(R, 'elem C') cmd.show_as('spheres') cmd.show_as('dots', 'elem C') with testing.mktemp('.mmtf') as filename: cmd.save(filename) cmd.delete('*') cmd.load(filename) color_list = [] reps_list = [] cmd.iterate('*', 'color_list.append(color)', space=locals()) cmd.iterate('*', 'reps_list.append(reps)', space=locals()) self.assertEqual(color_list, [B, R, R, B, B, B, B]) self.assertEqual(reps_list, [S, D, D, S, S, S, S])
def testSaveRef(self, format): # for rms_cur (not all formats save all identifiers) m = -1 cmd.set('retain_order') cmd.fragment('ala', 'm1') cmd.copy('m2', 'm1') cmd.copy('m3', 'm1') cmd.rotate('y', 90, 'm2') cmd.align('m3', 'm2') # with ref=m3 with testing.mktemp('.' + format) as filename: cmd.save(filename, 'm2', ref='m3') cmd.load(filename, 'm4') self.assertAlmostEqual(cmd.rms_cur('m4', 'm1', matchmaker=m), 0.00, delta=1e-2) self.assertAlmostEqual(cmd.rms_cur('m4', 'm2', matchmaker=m), 1.87, delta=1e-2) # without ref with testing.mktemp('.' + format) as filename: cmd.save(filename, 'm2') cmd.load(filename, 'm5') self.assertAlmostEqual(cmd.rms_cur('m5', 'm2', matchmaker=m), 0.00, delta=1e-2) self.assertAlmostEqual(cmd.rms_cur('m5', 'm1', matchmaker=m), 1.87, delta=1e-2)
def testMultifilesave(self): import glob for name in ['ala', 'gly', 'his', 'arg']: cmd.fragment(name) # multistate for i in range(2, 11): cmd.create('ala', 'ala', 1, i) for fmt in ['{}-{:02}.cif', '{}-{state}.cif']: with testing.mkdtemp() as dirname: cmd.multifilesave(os.path.join(dirname, fmt), 'ala', 0) filenames = [os.path.basename(p) for p in glob.glob(os.path.join(dirname, '*.cif'))] self.assertEqual(len(filenames), 10) self.assertTrue('ala-03.cif' in filenames) with testing.mkdtemp() as dirname: cmd.multifilesave(os.path.join(dirname, '{}.pdb'), 'a* g*') filenames_full = sorted(glob.glob(os.path.join(dirname, '*.pdb'))) filenames = [os.path.basename(p) for p in filenames_full] self.assertEqual(filenames, ['ala.pdb', 'arg.pdb', 'gly.pdb']) cmd.delete('*') cmd.load(filenames_full[0]) self.assertEqual(cmd.count_atoms(), 10) cmd.delete('*') cmd.load(filenames_full[1]) self.assertEqual(cmd.count_atoms(), 24)
def testglTF(self): '''glTF export''' cmd.fragment('gly') with testing.mktemp('.gltf') as filename: self.assertEqual(cmd.save(filename), 0) cmd.delete('*')
def test(self): cmd.viewport(100, 100) # make map cmd.fragment('gly', 'm1') cmd.set('gaussian_b_floor', 30) cmd.set('mesh_width', 5) cmd.map_new('map') cmd.delete('m1') # make mesh cmd.isomesh('mesh', 'map') # check mesh presence by color meshcolor = 'red' cmd.color(meshcolor, 'mesh') self.ambientOnly() self.assertImageHasColor(meshcolor) # continue without map cmd.delete('map') with testing.mktemp('.pse') as filename: cmd.save(filename) cmd.delete('*') self.assertImageHasNotColor(meshcolor) cmd.load(filename) self.assertImageHasColor(meshcolor)
def test(self): cmd.fragment('ala') cmd.ray(100, 100) img = self.get_imagearray() # cmd.png without optional arguments # bug was: ray tracing twice, second time would not be 100x100 self.assertEqual(img.shape[:2], (100, 100))
def test_colors(self): cmd.fragment('gly') pymol.util.colors("jmol") stored.colors = set() cmd.iterate('elem C', 'stored.colors.add(color)') colors = [get_color_tuple(c, 3) for c in stored.colors] self.assertEqual(colors, [(0.567, 0.567, 0.567)])
def test(self): cmd.viewport(100,100) cmd.set('gaussian_b_floor', 20) cmd.set('ambient', 1) cmd.set('specular', 0) cmd.set('mesh_color', 'blue') cmd.set('dot_color', 'green') cmd.fragment('gly') cmd.map_new('map1') cmd.disable('*') cmd.isomesh('o1', 'map1') cmd.color('red', 'o1') cmd.show('cell') self._check_colors('red', 'blue') cmd.delete('o1') cmd.isodot('o1', 'map1') cmd.color('red', 'o1') self._check_colors('green') cmd.delete('o1') cmd.gradient('o1', 'map1') cmd.color('yellow', 'o1') self._check_colors('yellow') cmd.delete('o1')
def testIdAtom(self): cmd.fragment('gly', 'm1') self.assertEqual(cmd.id_atom('ID 3'), 3) self.assertEqual(cmd.id_atom('ID 3', 1), ('m1', 3)) cmd.feedback("disable", "cmd", "errors") self.assertRaises(CmdException, cmd.id_atom, 'ID 3+4') self.assertRaises(CmdException, cmd.id_atom, 'ID 100')
def testGetType(self): cmd.fragment('gly', 'm1') self.assertEqual(cmd.get_type('m1'), 'object:molecule') cmd.ramp_new('ramp1', 'none') self.assertEqual(cmd.get_type('ramp1'), 'object:ramp') cmd.select('s1', 'elem C') self.assertEqual(cmd.get_type('s1'), 'selection')
def testPairFit(self): cmd.fragment('trp') cmd.fragment('his') # 1 atom sele = ('trp and guide', 'his and guide') pos = list(map(cmd.get_atom_coords, sele)) vec = cpv.sub(*pos) mat_ref = [ 1.0, 0.0, 0.0, -vec[0], 0.0, 1.0, 0.0, -vec[1], 0.0, 0.0, 1.0, -vec[2], 0.0, 0.0, 0.0, 1.0] rms = cmd.pair_fit(*sele) self.assertEqual(rms, 0.0) mat = cmd.get_object_matrix('trp') self.assertArrayEqual(mat, mat_ref, 1e-4) # 2 atoms sele += ('trp & name CB', 'his & name CB') rms = cmd.pair_fit(*sele) self.assertAlmostEqual(rms, 0.0082, delta=1e-4) # 4 atoms sele += ('trp & name CG', 'his & name CG', 'trp & name CD1', 'his & name CD2') rms = cmd.pair_fit(*sele) self.assertAlmostEqual(rms, 0.0713, delta=1e-4)
def testNumeric(self): cmd.fragment('ala') cmd.alter_state(1, 'all', 'p.x, p.y, p.index = x, y, index') cmd.select('sele_p_x', 'p.x < 0') cmd.select('sele_p_y', 'p.y > 0') cmd.select('sele_p_i', 'p.index = 3') cmd.select('sele_x', 'x < 0.0') cmd.select('sele_y', 'y > 0.0') cmd.select('sele_i', 'index 3') counts = [ cmd.count_atoms('sele_p_x'), cmd.count_atoms('sele_x'), cmd.count_atoms('sele_x & sele_p_x'), ] self.assertEqual(counts[0], 8) self.assertEqual(counts[0], counts[1]) self.assertEqual(counts[0], counts[2]) counts = [ cmd.count_atoms('sele_p_y'), cmd.count_atoms('sele_y'), cmd.count_atoms('sele_y & sele_p_y'), ] self.assertEqual(counts[0], 6) self.assertEqual(counts[0], counts[1]) self.assertEqual(counts[0], counts[2]) counts = [ cmd.count_atoms('sele_i'), cmd.count_atoms('sele_p_i'), cmd.count_atoms('sele_i & sele_p_i'), ] self.assertEqual(counts[0], 1) self.assertEqual(counts[0], counts[1]) self.assertEqual(counts[0], counts[2])
def testByRing(self): cmd.fragment('trp') self.assertEqual(cmd.count_atoms('byring name CB'), 0) self.assertEqual(cmd.count_atoms('byring name CG'), 5) self.assertEqual(cmd.count_atoms('byring name CD2'), 9) self.assertEqual(cmd.count_atoms('byring name CE3'), 6) self.assertEqual(cmd.count_atoms('byring all'), 9)
def test_msms_surface(): eps = 1e-3 cmd.reinitialize() cmd.fragment('ala', 'm1') # default psico.msms.msms_surface(name='surf1') extent = cmd.get_extent('surf1') assert extent[0] == approx([-2.705, -3.208, -2.413], rel=eps) assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps) # global solvent_radius cmd.set('solvent_radius', 3.5) psico.msms.msms_surface(name='surf2') extent = cmd.get_extent('surf2') assert extent[0] == approx([-2.705, -3.169, -2.436], rel=eps) assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps) # object-level solvent_radius cmd.set('solvent_radius', 2.8, 'm1') psico.msms.msms_surface(name='surf3') extent = cmd.get_extent('surf3') assert extent[0] == approx([-2.705, -3.161, -2.427], rel=eps) assert extent[1] == approx([3.530, 2.907, 2.676], rel=eps) # modified atom radii cmd.alter('m1', 'vdw = 3.0') psico.msms.msms_surface(name='surf4') extent = cmd.get_extent('surf4') assert extent[0] == approx([-4.605, -5.162, -4.418], rel=eps) assert extent[1] == approx([5.030, 4.861, 4.681], rel=eps)
def testCifMissing(self): N = 7 cmd.fragment('gly', 'm1') cmd.alter('all', '(chain, segi, resv, alt) = ("?", ".", 5, "")') s = cmd.get_str('cif') self.assertTrue("'?'" in s or '"?"' in s) # chain self.assertTrue("'.'" in s or '"."' in s) # segi self.assertTrue(' ? ' in s) # e.g. pdbx_PDB_ins_code self.assertTrue(' . ' in s) # e.g. label_alt_id cmd.delete('*') cmd.set('cif_keepinmemory') cmd.load(s, 'm2', format='cifstr') self.assertEqual(['?'], cmd.get_chains()) self.assertEqual(cmd.count_atoms('segi .'), N) self.assertEqual(cmd.count_atoms('alt ""'), N) # no alt self.assertEqual(cmd.count_atoms('resi 5'), N) # no ins_code from pymol.querying import cif_get_array self.assertEqual(cif_get_array("m2", "_atom_site.type_symbol"), list('NCCOHHH')) self.assertEqual(cif_get_array("m2", "_atom_site.id", "i"), list(range(1, N + 1))) self.assertEqual(cif_get_array("m2", "_atom_site.auth_asym_id"), ['?'] * N) self.assertEqual(cif_get_array("m2", "_atom_site.label_asym_id"), ['.'] * N) self.assertEqual(cif_get_array("m2", "_atom_site.pdbx_pdb_ins_code"), [None] * N) self.assertEqual(cif_get_array("m2", "_atom_site.label_alt_id"), [None] * N)
def testLoadCoords(self): import numpy cmd.fragment('gly', 'm1') coords = cmd.get_coords('m1') coords += 5.0 cmd.load_coords(coords, 'm1') self.assertTrue(numpy.allclose(coords, cmd.get_coords('m1')))
def testPairFit(self): cmd.fragment('trp') cmd.fragment('his') # 1 atom sele = ('trp and guide', 'his and guide') pos = list(map(cmd.get_atom_coords, sele)) vec = cpv.sub(*pos) mat_ref = [ 1.0, 0.0, 0.0, -vec[0], 0.0, 1.0, 0.0, -vec[1], 0.0, 0.0, 1.0, -vec[2], 0.0, 0.0, 0.0, 1.0 ] rms = cmd.pair_fit(*sele) self.assertEqual(rms, 0.0) mat = cmd.get_object_matrix('trp') self.assertArrayEqual(mat, mat_ref, 1e-4) # 2 atoms sele += ('trp & name CB', 'his & name CB') rms = cmd.pair_fit(*sele) self.assertAlmostEqual(rms, 0.0082, delta=1e-4) # 4 atoms sele += ('trp & name CG', 'his & name CG', 'trp & name CD1', 'his & name CD2') rms = cmd.pair_fit(*sele) self.assertAlmostEqual(rms, 0.0713, delta=1e-4)
def test_h_add_state(self): nheavy = 4 nhydro = 5 nfull = nheavy + nhydro cmd.fragment('gly', 'm1') cmd.remove('hydro') self.assertEqual(nheavy, cmd.count_atoms()) cmd.h_add() self.assertEqual(nfull, cmd.count_atoms()) # multi-state cmd.remove('hydro') cmd.create('m1', 'm1', 1, 2) cmd.create('m1', 'm1', 1, 3) cmd.h_add(state=2) self.assertEqual(nfull, cmd.count_atoms()) self.assertEqual(nheavy, cmd.count_atoms('state 1')) self.assertEqual(nfull, cmd.count_atoms('state 2')) self.assertEqual(nheavy, cmd.count_atoms('state 3')) # discrete multi-state cmd.remove('hydro') cmd.create('m2', 'm1', 1, 1, discrete=1) cmd.create('m2', 'm2', 1, 2, discrete=1) cmd.create('m2', 'm2', 1, 3, discrete=1) self.assertEqual(nheavy * 3, cmd.count_atoms('m2')) cmd.h_add('m2 & state 2') # TODO , state=2) self.assertEqual(nfull + nheavy * 2, cmd.count_atoms('m2')) self.assertEqual(nheavy, cmd.count_atoms('m2 & state 1')) self.assertEqual(nfull, cmd.count_atoms('m2 & state 2')) self.assertEqual(nheavy, cmd.count_atoms('m2 & state 3')) cmd.h_add('m2') self.assertEqual(nfull * 3, cmd.count_atoms('m2'))
def testIgnoreCase(self): # check defaults self.assertEqual(cmd.get_setting_int('ignore_case'), 1) self.assertEqual(cmd.get_setting_int('ignore_case_chain'), 0) # data natoms = 10 cmd.fragment('ala', 'm1') cmd.copy('m2', 'm1') cmd.alter('m1', 'chain, segi = "C", "S"') cmd.alter('m2', 'chain, segi = "c", "s"') cmd.alter('m2', 'resn, name = resn.lower(), name.lower()') self.assertEqual(cmd.count_atoms('chain C'), natoms) self.assertEqual(cmd.count_atoms('segi S'), natoms) self.assertEqual(cmd.count_atoms('chain c'), natoms) self.assertEqual(cmd.count_atoms('segi s'), natoms) self.assertEqual(cmd.count_atoms('resn ALA'), natoms * 2) self.assertEqual(cmd.count_atoms('resn ala'), natoms * 2) self.assertEqual(cmd.count_atoms('name CA'), 2) self.assertEqual(cmd.count_atoms('name ca'), 2) cmd.set('ignore_case_chain') self.assertEqual(cmd.count_atoms('chain C'), natoms * 2) self.assertEqual(cmd.count_atoms('segi S'), natoms * 2) self.assertEqual(cmd.count_atoms('chain c'), natoms * 2) self.assertEqual(cmd.count_atoms('segi s'), natoms * 2) cmd.set('ignore_case', 0) self.assertEqual(cmd.count_atoms('resn ALA'), natoms) self.assertEqual(cmd.count_atoms('resn ala'), natoms) self.assertEqual(cmd.count_atoms('name CA'), 1) self.assertEqual(cmd.count_atoms('name ca'), 1)
def testGetObjectMatrix(self): identity = (1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0) mat_x90 = (1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0) cmd.fragment('ala', 'm1') cmd.fragment('gly', 'm2') # default/identity mat = cmd.get_object_matrix('m1', incl_ttt=1) self.assertTrue(isinstance(mat, tuple)) self.assertArrayEqual(mat, identity, delta=1e-6) mat = cmd.get_object_matrix('m1', incl_ttt=0) self.assertArrayEqual(mat, identity, delta=1e-6) # TTT cmd.rotate('x', 90, object='m1', camera=0, object_mode=0) mat = cmd.get_object_matrix('m1', incl_ttt=1) self.assertArrayEqual(mat, mat_x90, delta=1e-6) mat = cmd.get_object_matrix('m1', incl_ttt=0) self.assertArrayEqual(mat, identity, delta=1e-6) # state matrix cmd.rotate('x', 90, object='m2', camera=0, object_mode=1) mat = cmd.get_object_matrix('m2', incl_ttt=1) self.assertArrayEqual(mat, mat_x90, delta=1e-6) mat = cmd.get_object_matrix('m2', incl_ttt=0) self.assertArrayEqual(mat, mat_x90, delta=1e-6)
def testSaveSelection(self, format, pymol_version): if pymol_version > testing.PYMOL_VERSION[1]: self.skipTest("version %f" % (pymol_version)) cmd.fragment('trp', 'm1') cmd.fragment('glu', 'm2') n_O = cmd.count_atoms('elem O') n_N = cmd.count_atoms('elem N') with testing.mktemp('.' + format) as filename: cmd.set('raise_exceptions', 0) # 1.7.6 save xyz doesn't set r=DEFAULT_SUCCESS cmd.save(filename, 'elem O+N') cmd.set('raise_exceptions', 1) if format == 'mae' and not pymol.invocation.options.incentive_product: format = 'cms' cmd.delete('*') cmd.load(filename, 'm2', discrete=1, format=format) # avoid merging of atoms self.assertEqual(n_O, cmd.count_atoms('elem O')) self.assertEqual(n_N, cmd.count_atoms('elem N')) self.assertEqual(n_O + n_N, cmd.count_atoms())
def testIdentify(self): cmd.fragment('gly', 'm1') cmd.select('s1', 'ID 3+4') r = cmd.identify('s1') self.assertItemsEqual(r, [3, 4]) r = cmd.identify('s1', 1) self.assertItemsEqual(r, [('m1', 3), ('m1', 4)])
def testIterateState(self): cmd.fragment('ala') cmd.create('ala', 'ala', 1, 2) self.assertEqual(2, cmd.count_states()) v_count = cmd.count_atoms('all') expr = 'v_xyz.append(((model,index), (x,y,z)))' # current state v_xyz = [] cmd.iterate_state(-1, 'all', expr, space=locals()) self.assertEqual(len(v_xyz), v_count) # all states v_xyz = [] cmd.iterate_state(0, 'all', expr, space=locals()) self.assertEqual(len(v_xyz), v_count * 2) # atomic=0 stored.v_xyz = [] cmd.iterate_state(1, 'all', 'stored.v_xyz.append((x,y,z))', atomic=0) self.assertEqual(len(stored.v_xyz), v_count) space = {'self': self, 'NameError': NameError, 'v_list': []} cmd.iterate_state(1, 'all', 'v_list.append(self.assertRaises(NameError, lambda: (model, index)))', space=space) self.assertEqual(len(space['v_list']), v_count)
def testStereo(self): cmd.fragment('ala') cmd.remove('hydro') # default: S configuration labels = [] cmd.iterate('name CA', 'labels.append(stereo)', space=locals()) self.assertEqual(labels, ['S']) # load R configuration (moves CB) ala_conf_R = { 'N': (-0.67690, -1.23030, -0.49050), 'CA': (-0.00090, 0.06370, -0.49050), 'C': (1.49910, -0.11030, -0.49050), 'O': (2.03010, -1.22730, -0.50150), # 'CB' : (-0.50890, 0.85570, 0.72650), # S configuration 'CB': (-0.33784, 0.82664, -1.78310), # R configuration } cmd.alter_state(1, 'ala', '(x,y,z) = ala_conf_R.get(name)', space=locals()) labels = [] cmd.iterate('name CA', 'labels.append(stereo)', space=locals()) self.assertEqual(labels, ['R'])
def testIsolevel(self): cmd.viewport(100, 100) cmd.fragment('gly', 'm1') cmd.set('gaussian_b_floor', 30) cmd.set('mesh_width', 5) cmd.map_new('map') cmd.delete('m1') # make mesh cmd.isodot('dot', 'map') cmd.isodot('dot', 'map', source_state=1, state=-2) ## check mesh presence by color meshcolor = 'red' cmd.color(meshcolor, 'dot') self.ambientOnly() self.assertImageHasColor(meshcolor) cmd.frame(2) self.assertEqual(cmd.get_state(), 2) self.assertImageHasColor(meshcolor) for contourlvl in range(7): cmd.isolevel('dot', contourlvl) self.assertImageHasColor(meshcolor) cmd.isolevel('dot', 10) self.assertImageHasNotColor(meshcolor)
def testFloatType(self, val1, val2): cmd.fragment('ala') cmd.set_property('float_property_1', val1, 'ala') cmd.set_property('float_property_2', val2, 'ala') self.assertAlmostEqual(cmd.get_property('float_property_1', 'ala'), val1) self.assertAlmostEqual(cmd.get_property('float_property_2', 'ala'), val2) # test setting boolean type by string cmd.set_property('float_property_1', str(val1), 'ala', proptype=PROPERTY_FLOAT) cmd.set_property('float_property_2', str(val1), 'ala', proptype=PROPERTY_FLOAT) cmd.set_property('float_property_3', str(val1), 'ala', proptype=PROPERTY_FLOAT) cmd.set_property('float_property_4', str(val2), 'ala', proptype=PROPERTY_FLOAT) self.assertAlmostEqual(cmd.get_property('float_property_1', 'ala'), val1) self.assertAlmostEqual(cmd.get_property('float_property_2', 'ala'), val1) # overwritting self.assertAlmostEqual(cmd.get_property('float_property_3', 'ala'), val1) self.assertAlmostEqual(cmd.get_property('float_property_4', 'ala'), val2)
def testTrilines(self, trilines): cmd.viewport(100, 100) cmd.set('use_shaders', True) self.ambientOnly() cmd.set('dynamic_width', 0) cmd.set('line_width', 5) cmd.set('line_smooth', 0) cmd.fragment('ethylene') cmd.show_as('lines') cmd.color('white') cmd.orient() cmd.set('trilines', trilines) # check percentage of covered pixels img = self.get_imagearray() npixels = img.shape[0] * img.shape[1] covered = numpy.count_nonzero(img[..., :3]) ratio = covered / float(npixels) msg = "covered=%d npixels=%d ratio=%f" % (covered, npixels, ratio) self.assertTrue(0.14 < ratio < 0.165, msg)
def testAA(self): ''' Make a black/white image and check if gray pixels are found with antialias_shader=1/2 ''' cmd.viewport(100, 100) cmd.set('use_shaders', True) self.ambientOnly() cmd.fragment('gly') cmd.show_as('spheres') cmd.color('white') cmd.zoom() # b/w image, we expect only two color values img = self.get_imagearray() self.assertNumColorsEqual(img, 2) for aa in (1, 2): cmd.set('antialias_shader', aa) # smoothed edges, we expect more than two color values img = self.get_imagearray() self.assertTrue(len(numpy.unique(img[..., :3])) > 2)
def testStickBall(self, use_shader): ''' Test some stick_ball* settings ''' cmd.viewport(100, 100) cmd.set('use_shaders', use_shader) self.ambientOnly() cmd.set('stick_ball') cmd.set('stick_ball_ratio', 2.0) cmd.set('stick_ball_color', 'blue') cmd.set('stick_color', 'red') cmd.fragment('gly') cmd.orient() cmd.color('green') cmd.show_as('sticks') img = self.get_imagearray() self.assertImageHasColor('blue', img) self.assertImageHasColor('red', img) self.assertImageHasNotColor('green', img)
def testShow(self): cmd.fragment('ala') self.assertEqual(cmd.count_atoms('rep sticks'), 0) cmd.show('sticks') self.assertEqual(cmd.count_atoms('rep sticks'), 10) cmd.hide('lines', 'not elem C') self.assertEqual(cmd.count_atoms('rep lines'), 3)
def test_set_dihedral(self): cmd.fragment('ala') angle = 45.0 atoms = ('ID 7', 'ID 2', 'ID 1', 'ID 9') cmd.set_dihedral(*atoms, angle=angle) v = cmd.get_dihedral(*atoms) self.assertAlmostEqual(v, angle, 4)
def test_color_deep(self): cmd.viewport(100, 70) self.ambientOnly() cmd.fragment('trp', 'm1') cmd.orient('m1') cmd.show_as('sticks') cmd.show('spheres', 'name C') cmd.set('stick_color', 'blue', 'm1') cmd.set('stick_color', 'red', 'name CH2+CZ3+CE3+CD2') cmd.set('sphere_color', 'yellow', 'name C') cmd.color('green') img = self.get_imagearray() self.assertImageHasColor('blue', img) self.assertImageHasColor('red', img) self.assertImageHasColor('yellow', img) self.assertImageHasNotColor('green', img) cmd.color_deep('green') img = self.get_imagearray() self.assertImageHasNotColor('blue', img) self.assertImageHasNotColor('red', img) self.assertImageHasNotColor('yellow', img) self.assertImageHasColor('green', img)
def testIsosurface(self): cmd.viewport(100, 100) cmd.fragment('gly', 'm1') cmd.set('gaussian_b_floor', 30) cmd.set('mesh_width', 5) cmd.map_new('map') cmd.delete('m1') # make mesh cmd.isosurface('surface', 'map') cmd.isosurface('surface', 'map', source_state=1, state=-2) ## check mesh presence by color meshcolor = 'red' cmd.color(meshcolor, 'surface') self.ambientOnly() self.assertImageHasColor(meshcolor) cmd.frame(2) self.assertEqual(cmd.get_state(), 2) self.assertImageHasColor(meshcolor) with testing.mktemp('.pse') as filename: cmd.save(filename) cmd.delete('*') self.assertImageHasNotColor(meshcolor) cmd.load(filename) self.assertImageHasColor(meshcolor) cmd.frame(2) self.assertEqual(cmd.get_state(), 2) self.assertImageHasColor(meshcolor)
def testIntegerType(self, val1, val2): cmd.fragment('ala') cmd.set_property('int_property_1', val1, 'ala') cmd.set_property('int_property_2', val2, 'ala') self.assertEqual(cmd.get_property('int_property_1', 'ala'), val1) self.assertEqual(cmd.get_property('int_property_2', 'ala'), val2) # test setting boolean type by string cmd.set_property('int_property_1', str(val1), 'ala', proptype=PROPERTY_INT) cmd.set_property('int_property_2', str(val1), 'ala', proptype=PROPERTY_INT) cmd.set_property('int_property_3', str(val1), 'ala', proptype=PROPERTY_INT) cmd.set_property('int_property_4', str(val2), 'ala', proptype=PROPERTY_INT) self.assertEqual(cmd.get_property('int_property_1', 'ala'), val1) self.assertEqual(cmd.get_property('int_property_2', 'ala'), val1) # overwritting self.assertEqual(cmd.get_property('int_property_3', 'ala'), val1) self.assertEqual(cmd.get_property('int_property_4', 'ala'), val2)
def testTrilines(self, trilines): cmd.viewport(100, 100) cmd.set('use_shaders', True) self.ambientOnly() cmd.set('dynamic_width', 0) cmd.set('line_width', 5) cmd.set('line_smooth', 0) cmd.fragment('ethylene') cmd.show_as('lines') cmd.color('white') cmd.orient() cmd.set('trilines', trilines) # check percentage of covered pixels img = self.get_imagearray() npixels = img.shape[0] * img.shape[1] covered = numpy.count_nonzero(img[...,:3]) ratio = covered / float(npixels) msg = "covered=%d npixels=%d ratio=%f" % (covered, npixels, ratio) self.assertTrue(0.14 < ratio < 0.165, msg)
def testBooleanType(self): cmd.fragment('ala') cmd.set_property('bool_property_1', True, 'ala') cmd.set_property('bool_property_2', False, 'ala') self.assertEqual(cmd.get_property('bool_property_1', 'ala'), True) self.assertEqual(cmd.get_property('bool_property_2', 'ala'), False) # test setting boolean type by string cmd.set_property('bool_property_1', "True", 'ala', proptype=PROPERTY_BOOLEAN) cmd.set_property('bool_property_2', "True", 'ala', proptype=PROPERTY_BOOLEAN) cmd.set_property('bool_property_3', "True", 'ala', proptype=PROPERTY_BOOLEAN) cmd.set_property('bool_property_4', "False", 'ala', proptype=PROPERTY_BOOLEAN) self.assertEqual(cmd.get_property('bool_property_1', 'ala'), True) self.assertEqual(cmd.get_property('bool_property_2', 'ala'), True) # overwritting self.assertEqual(cmd.get_property('bool_property_3', 'ala'), True) self.assertEqual(cmd.get_property('bool_property_4', 'ala'), False)
def testAA(self): ''' Make a black/white image and check if gray pixels are found with antialias_shader=1/2 ''' cmd.viewport(100, 100) cmd.set('use_shaders', True) self.ambientOnly() cmd.fragment('gly') cmd.show_as('spheres') cmd.color('white') cmd.zoom() # b/w image, we expect only two color values img = self.get_imagearray() self.assertTrue(len(numpy.unique(img[...,:3])) == 2) for aa in (1, 2): cmd.set('antialias_shader', aa) # smoothed edges, we expect more than two color values img = self.get_imagearray() self.assertTrue(len(numpy.unique(img[...,:3])) > 2)
def test(self): cmd.fragment('ala') cmd.ray(100, 100) img = self.get_imagearray() # cmd.png without optional arguments # bug was: ray tracing twice, second time would not be 100x100 self.assertEqual(img.shape[:2], (100,100))
def testCOLLADA(self): cmd.fragment('gly') for rep in ['spheres', 'sticks', 'surface']: cmd.show_as(rep) with testing.mktemp('.dae') as filename: cmd.save(filename) contents = file_get_contents(filename) self.assertTrue('<COLLADA' in contents)
def _test_cba(self, fun, expected_color): cmd.fragment('gly') cmd.color('white') fun('*') stored.colors = set() cmd.iterate('elem C', 'stored.colors.add(color)') colors = [get_color_tuple(c, 3) for c in stored.colors] self.assertEqual(colors, [expected_color])
def testPop(self): cmd.fragment("ala") cmd.select("src", "ala") # iterate across the 10 atoms in ala cnt = 0 while cmd.pop("tmp","src"): cnt+=1 self.assertEquals(cnt,10)
def testGetSession(self): cmd.fragment('ala') x = cmd.count_atoms() s = cmd.get_session() cmd.reinitialize() cmd.set_session(s) self.assertEqual(['ala'], cmd.get_names()) self.assertEqual(x, cmd.count_atoms())
def test_invert(self): cmd.fragment('ala') xyzfix = get_coord_list('ID 1-7') xyzmov = get_coord_list('ID 0+8+9') cmd.edit('ID 1', 'ID 2', 'ID 3') cmd.invert() self.assertEqual(xyzfix, get_coord_list('ID 1-7')) self.assertNotEqual(xyzmov, get_coord_list('ID 0+8+9'))
def testMappend(self): self.prep_movie() cmd.fragment("ala") cmd.mappend(5,"delete *") cmd.mappend(5,"frame 1") cmd.frame(5) self.assertEquals(len(cmd.get_names()),0) self.assertEquals(cmd.get_frame(),1)
def testVRML(self): cmd.fragment('gly') for rep in ['spheres', 'sticks', 'surface']: cmd.show_as(rep) with testing.mktemp('.wrl') as filename: cmd.save(filename) contents = file_get_contents(filename) self.assertTrue(contents.startswith('#VRML V2'))
def testScene(self): cmd.fragment('ala', 'm1') cmd.fragment('gly', 'm2') cmd.create('m2', 'm2', 1, 2) cmd.create('m2', 'm2', 1, 3) cmd.create('m2', 'm2', 1, 4) # store cmd.show_as('sticks', 'm1') cmd.show_as('spheres', 'm2') cmd.color('blue', 'm1') cmd.color('yellow', 'm2') view_001 = cmd.get_view() cmd.scene('new', 'store', 'hello world') # store cmd.frame(3) cmd.show_as('lines') cmd.color('red') cmd.turn('x', 45) view_002 = cmd.get_view() cmd.scene('new', 'store') # we actually don't know the auto naming counter # self.assertEqual(cmd.get_scene_list(), ['001', '002']) names = cmd.get_scene_list() # recall cmd.scene(names[0], 'recall', animate=0) self.assertArrayEqual(view_001, cmd.get_view(), delta=1e-3) self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('color blue')) self.assertEqual(cmd.count_atoms('m1'), cmd.count_atoms('rep sticks')) self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('color yellow')) self.assertEqual(cmd.count_atoms('m2'), cmd.count_atoms('rep spheres')) self.assertNotEqual(cmd.get_wizard(), None) self.assertEqual(cmd.get_state(), 1) # recall cmd.scene(names[1], 'recall', animate=0) self.assertArrayEqual(view_002, cmd.get_view(), delta=1e-3) self.assertEqual(0, cmd.count_atoms('color blue')) self.assertEqual(0, cmd.count_atoms('rep sticks')) self.assertEqual(cmd.count_atoms(), cmd.count_atoms('color red')) self.assertEqual(cmd.count_atoms(), cmd.count_atoms('rep lines')) self.assertEqual(cmd.get_wizard(), None) self.assertEqual(cmd.get_state(), 3) # with movie (not playing) it must not recall the state cmd.mset('1-4') cmd.frame(1) cmd.scene(names[1], 'recall', animate=0) self.assertEqual(cmd.get_state(), 1) # rename and delete cmd.scene('F2', 'store') cmd.scene(names[0], 'rename', new_key='F1') cmd.scene(names[1], 'delete') self.assertEqual(cmd.get_scene_list(), ['F1', 'F2'])
def test_torsion(self): cmd.fragment('ala') delta = 10 atoms = ('ID 7', 'ID 2', 'ID 1', 'ID 9') d1 = cmd.get_dihedral(*atoms) cmd.edit(*atoms[1:3]) cmd.torsion(delta) d2 = cmd.get_dihedral(*atoms) self.assertAlmostEqual(d1 + delta, d2, 4)
def build(object_name, sequence, first_residue = "1"): if len(sequence): code = sequence[0] cmd.fragment(aa_dict[code],object_name) cmd.alter(object_name,'resi="%s"'%first_residue) cmd.edit(object_name+" and name C") for code in sequence[1:]: editor.attach_amino_acid("pk1",aa_dict[code]) cmd.edit()