Exemplo n.º 1
0
    def check_mmtf_vs_cif(self, mmtf_filename, cif_filename):
        """Compare parsed structures for MMTF and CIF files."""
        with warnings.catch_warnings():
            warnings.simplefilter("ignore", PDBConstructionWarning)
            mmtf_struct = MMTFParser.get_structure(mmtf_filename)
        mmcif_parser = MMCIFParser()
        mmcif_struct = mmcif_parser.get_structure("4CUP", cif_filename)
        self.mmcif_atoms = list(mmcif_struct.get_atoms())
        self.mmtf_atoms = list(mmtf_struct.get_atoms())
        self.check_atoms()
        mmcif_chains = list(mmcif_struct.get_chains())
        mmtf_chains = list(mmtf_struct.get_chains())
        self.assertEqual(len(mmcif_chains), len(mmtf_chains))
        for i, e in enumerate(mmcif_chains):
            self.mmcif_res = list(mmcif_chains[i].get_residues())
            self.mmtf_res = list(mmtf_chains[i].get_residues())
            self.check_residues()

        self.mmcif_res = list(mmcif_struct.get_residues())
        self.mmtf_res = list(mmtf_struct.get_residues())
        self.check_residues()
        self.assertEqual(
            sum(1 for _ in mmcif_struct.get_models()),
            sum(1 for _ in mmtf_struct.get_models()),
        )
Exemplo n.º 2
0
 def test_multi_model_write(self):
     """Test multiple models are written out correctly to MMTF."""
     parser = PDBParser()
     struc = parser.get_structure("1SSU_mod", "PDB/1SSU_mod.pdb")
     io = MMTFIO()
     io.set_structure(struc)
     filenumber, filename = tempfile.mkstemp()
     os.close(filenumber)
     try:
         io.save(filename)
         struc_back = MMTFParser.get_structure(filename)
         dict_back = mmtf.parse(filename)
         self.assertEqual(dict_back.num_models, 2)
         self.assertEqual(dict_back.num_chains, 4)
         self.assertEqual(dict_back.num_groups, 4)
         self.assertEqual(dict_back.num_atoms, 4)
         self.assertEqual(list(dict_back.x_coord_list),
                          [-1.058, -0.025, 7.024, 6.259])
         self.assertEqual(dict_back.chain_id_list, ["A", "B", "A", "B"])
         self.assertEqual(dict_back.chain_name_list, ["A", "B", "A", "B"])
         self.assertEqual(dict_back.chains_per_model, [2, 2])
         self.assertEqual(len(dict_back.group_list), 1)
         self.assertEqual(len(dict_back.group_id_list), 4)
         self.assertEqual(len(dict_back.group_type_list), 4)
         self.assertEqual(dict_back.groups_per_chain, [1, 1, 1, 1])
         self.assertEqual(len(dict_back.entity_list), 4)
     finally:
         os.remove(filename)
def loop_parsing(file_type, proteins, rep=10):
    cwd = os.getcwd()
    if file_type == 'mmtf': parser = MMTFParser()
    elif file_type == 'fast_cif': parser = FastMMCIFParser()
    elif file_type == 'cif': parser = MMCIFParser()
    else: parser = PDBParser()
    for p in proteins:
        if file_type == "fast_cif": file_type = "cif"
        directory = "%s/%s/%s.%s" % (cwd, file_type, p, file_type)
        try:
            if file_type == 'mmtf':
                protein = parser.get_structure(directory)
            else:
                protein = parser.get_structure(random.randint(0, 100),
                                               directory)
        except Exception:
            print("Having trouble parsing %s" % (p))
            break
    return
Exemplo n.º 4
0
    def test_compare_to_mmcif(self):
        """Compre the MMTF and mmCIF parsed structrues"""
        def test_atoms(parse_mmtf):
            """Test that all atoms in self.mmtf_atoms and self.mmcif_atoms are equivalent"""
            parse_mmtf.assertEqual(len(parse_mmtf.mmcif_atoms), len(parse_mmtf.mmtf_atoms))
            for i, e in enumerate(parse_mmtf.mmcif_atoms):
                mmtf_atom = parse_mmtf.mmtf_atoms[i]
                mmcif_atom = parse_mmtf.mmcif_atoms[i]
                parse_mmtf.assertEqual(mmtf_atom.name, mmcif_atom.name)  # eg. CA, spaces are removed from atom name
                parse_mmtf.assertEqual(mmtf_atom.fullname, mmcif_atom.fullname)  # e.g. " CA ", spaces included
                parse_mmtf.assertAlmostEqual(mmtf_atom.coord[0], mmcif_atom.coord[0], places=3)
                parse_mmtf.assertAlmostEqual(mmtf_atom.coord[1], mmcif_atom.coord[1], places=3)
                parse_mmtf.assertAlmostEqual(mmtf_atom.coord[2], mmcif_atom.coord[2], places=3)
                parse_mmtf.assertEqual(mmtf_atom.bfactor, mmcif_atom.bfactor)
                parse_mmtf.assertEqual(mmtf_atom.occupancy, mmcif_atom.occupancy)
                parse_mmtf.assertEqual(mmtf_atom.altloc, mmcif_atom.altloc)
                parse_mmtf.assertEqual(mmtf_atom.full_id,
                                       mmcif_atom.full_id)  # (structure id, model id, chain id, residue id, atom id)
                parse_mmtf.assertEqual(mmtf_atom.id, mmcif_atom.name)  # id of atom is the atom name (e.g. "CA")
                # self.assertEqual(mmtf_atom.serial_number,mmcif_atom.serial_number) # mmCIF serial number is none
        def test_residues(parse_mmtf):
            """Test that all residues in self.mmcif_res and self.mmtf_res are equivalent"""
            parse_mmtf.assertEqual(len(parse_mmtf.mmcif_res), len(parse_mmtf.mmtf_res))
            for i, e in enumerate(parse_mmtf.mmcif_res):
                mmcif_r = parse_mmtf.mmcif_res[i]
                mmtf_r = parse_mmtf.mmtf_res[i]
                parse_mmtf.assertEqual(mmtf_r.level, mmcif_r.level)
                parse_mmtf.assertEqual(mmtf_r.disordered, mmcif_r.disordered)
                parse_mmtf.assertEqual(mmtf_r.resname, mmcif_r.resname)
                parse_mmtf.assertEqual(mmtf_r.segid, mmcif_r.segid)
                parse_mmtf.mmcif_atoms = [x for x in mmcif_r.get_atom()]
                parse_mmtf.mmtf_atoms = [x for x in mmtf_r.get_atom()]
                test_atoms(parse_mmtf=parse_mmtf)

        with warnings.catch_warnings():
            warnings.simplefilter('ignore', PDBConstructionWarning)
            mmtf_struct = MMTFParser.get_structure("PDB/4CUP.mmtf")
        mmcif_parser = MMCIFParser()
        mmcif_struct = mmcif_parser.get_structure("example", "PDB/4CUP.cif")
        self.mmcif_atoms = [x for x in mmcif_struct.get_atoms()]
        self.mmtf_atoms = [x for x in mmtf_struct.get_atoms()]
        test_atoms(self)
        mmcif_chains = [x for x in mmcif_struct.get_chains()]
        mmtf_chains = [x for x in mmtf_struct.get_chains()]
        self.assertEqual(len(mmcif_chains), len(mmtf_chains))
        for i, e in enumerate(mmcif_chains):
            self.mmcif_res = [x for x in mmcif_chains[i].get_residues()]
            self.mmtf_res = [x for x in mmtf_chains[i].get_residues()]
            test_residues(self)

        self.mmcif_res = [x for x in mmcif_struct.get_residues()]
        self.mmtf_res = [x for x in mmtf_struct.get_residues()]
        test_residues(self)
        self.assertEqual(len([x for x in mmcif_struct.get_models()]), len([x for x in mmtf_struct.get_models()]))
Exemplo n.º 5
0
    def test_selection_write(self):
        """Test the use of a Select subclass when writing MMTF files."""
        struc = MMTFParser.get_structure("PDB/4CUP.mmtf")
        io = MMTFIO()
        io.set_structure(struc)
        filenumber, filename = tempfile.mkstemp()
        os.close(filenumber)

        class CAonly(Select):
            """Accepts only CA residues."""
            def accept_atom(self, atom):
                if atom.name == "CA" and atom.element == "C":
                    return 1

        try:
            io.save(filename, CAonly())
            struc_back = MMTFParser.get_structure(filename)
            dict_back = mmtf.parse(filename)
            self.assertEqual(dict_back.num_atoms, 116)
            self.assertEqual(len(dict_back.x_coord_list), 116)
            self.assertEqual(set(dict_back.alt_loc_list), {"\x00", "A", "B"})
        finally:
            os.remove(filename)
Exemplo n.º 6
0
 def test_write(self):
     """Test a simple structure object is written out correctly to MMTF."""
     parser = MMCIFParser()
     struc = parser.get_structure("1A8O", "PDB/1A8O.cif")
     io = MMTFIO()
     io.set_structure(struc)
     filenumber, filename = tempfile.mkstemp()
     os.close(filenumber)
     try:
         io.save(filename)
         struc_back = MMTFParser.get_structure(filename)
         dict_back = mmtf.parse(filename)
         self.assertEqual(dict_back.structure_id, "1A8O")
         self.assertEqual(dict_back.num_models, 1)
         self.assertEqual(dict_back.num_chains, 2)
         self.assertEqual(dict_back.num_groups, 158)
         self.assertEqual(dict_back.num_atoms, 644)
         self.assertEqual(len(dict_back.x_coord_list), 644)
         self.assertEqual(len(dict_back.y_coord_list), 644)
         self.assertEqual(len(dict_back.z_coord_list), 644)
         self.assertEqual(len(dict_back.b_factor_list), 644)
         self.assertEqual(len(dict_back.occupancy_list), 644)
         self.assertEqual(dict_back.x_coord_list[5], 20.022)
         self.assertEqual(set(dict_back.ins_code_list), {"\x00"})
         self.assertEqual(set(dict_back.alt_loc_list), {"\x00"})
         self.assertEqual(list(dict_back.atom_id_list), list(range(1, 645)))
         self.assertEqual(list(dict_back.sequence_index_list),
                          list(range(70)) + [-1] * 88)
         self.assertEqual(dict_back.chain_id_list, ["A", "B"])
         self.assertEqual(dict_back.chain_name_list, ["A", "A"])
         self.assertEqual(dict_back.chains_per_model, [2])
         self.assertEqual(len(dict_back.group_list), 21)
         self.assertEqual(len(dict_back.group_id_list), 158)
         self.assertEqual(len(dict_back.group_type_list), 158)
         self.assertEqual(dict_back.groups_per_chain, [70, 88])
         self.assertEqual(len(dict_back.entity_list), 2)
         self.assertEqual(dict_back.entity_list[0]["type"], "polymer")
         self.assertEqual(dict_back.entity_list[0]["chainIndexList"], [0])
         self.assertEqual(
             dict_back.entity_list[0]["sequence"],
             "MDIRQGPKEPFRDYVDRFYKTLRAEQASQEVKNWMTETLLVQNANPDCKTILKALGPGATLEEMMTACQG",
         )
         self.assertEqual(dict_back.entity_list[1]["type"], "water")
         self.assertEqual(dict_back.entity_list[1]["chainIndexList"], [1])
         self.assertEqual(dict_back.entity_list[1]["sequence"], "")
     finally:
         os.remove(filename)
Exemplo n.º 7
0
def read_inputs(in_file, file_format, curr_model, chains):
    # Infer file format from extension
    file_format = file_format or os.path.basename(in_file).rsplit(".", 1)[-1]

    # Handle stdin
    if in_file == "-":
        contents = sys.stdin.read()
        struct_file = StringIO(contents)
        try:
            # Redirect stdin from pipe back to terminal
            sys.stdin = open("/dev/tty", "r")
        except:
            print(
                "Piping structures not supported on this system (no /dev/tty)")
            return None, None
    else:
        struct_file = in_file

    # Use Biopython parser by default
    get_coords = get_coords_biopython

    if file_format.lower() == "pdb":
        from Bio.PDB import PDBParser
        p = PDBParser()
        struc = p.get_structure("", struct_file)
    elif file_format.lower() in ("mmcif", "cif"):
        from Bio.PDB.MMCIFParser import MMCIFParser
        p = MMCIFParser()
        struc = p.get_structure("", struct_file)
    elif file_format.lower() == "mmtf":
        from Bio.PDB.mmtf import MMTFParser
        struc = MMTFParser.get_structure(struct_file)
    elif file_format.lower() in ("mae", "maegz"):
        from schrodinger import structure
        struc = list(structure.StructureReader(struct_file))
        get_coords = get_coords_schrodinger
    else:
        print("Unrecognised file format")
        return None, None

    coords, info = get_coords(struc, chains)

    if coords is None or curr_model > len(coords):
        print("Nothing to show")
        return None, None

    return np.array(coords), info
Exemplo n.º 8
0
    def check_mmtf_vs_cif(self, mmtf_filename, cif_filename):
        """Compare parsed structures for MMTF and CIF files."""
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', PDBConstructionWarning)
            mmtf_struct = MMTFParser.get_structure(mmtf_filename)
        mmcif_parser = MMCIFParser()
        mmcif_struct = mmcif_parser.get_structure("example", cif_filename)
        self.mmcif_atoms = [x for x in mmcif_struct.get_atoms()]
        self.mmtf_atoms = [x for x in mmtf_struct.get_atoms()]
        self.check_atoms()
        mmcif_chains = [x for x in mmcif_struct.get_chains()]
        mmtf_chains = [x for x in mmtf_struct.get_chains()]
        self.assertEqual(len(mmcif_chains), len(mmtf_chains))
        for i, e in enumerate(mmcif_chains):
            self.mmcif_res = [x for x in mmcif_chains[i].get_residues()]
            self.mmtf_res = [x for x in mmtf_chains[i].get_residues()]
            self.check_residues()

        self.mmcif_res = [x for x in mmcif_struct.get_residues()]
        self.mmtf_res = [x for x in mmtf_struct.get_residues()]
        self.check_residues()
        self.assertEqual(len([x for x in mmcif_struct.get_models()]), len([x for x in mmtf_struct.get_models()]))
Exemplo n.º 9
0
 def test_1A80(self):
     """Parse 1A8O.mmtf"""
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', PDBConstructionWarning)
         structure = MMTFParser.get_structure("PDB/1A8O.mmtf")
Exemplo n.º 10
0
 def test_4ZHL(self):
     """Parse 4ZHL.mmtf"""
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', PDBConstructionWarning)
         structure = MMTFParser.get_structure("PDB/4ZHL.mmtf")
Exemplo n.º 11
0
from Bio.PDB.mmtf import MMTFParser
# read structure from file
structure = MMTFParser.get_structure("PDB/4CUP.mmtf")
# read structure from PDB
structure = MMTFParser.get_structure_from_url("4CUP")
Exemplo n.º 12
0
    def test_compare_to_mmcif(self):
        """Compre the MMTF and mmCIF parsed structrues"""
        def test_atoms(parse_mmtf):
            """Test that all atoms in self.mmtf_atoms and self.mmcif_atoms are equivalent"""
            parse_mmtf.assertEqual(len(parse_mmtf.mmcif_atoms),
                                   len(parse_mmtf.mmtf_atoms))
            for i, e in enumerate(parse_mmtf.mmcif_atoms):
                mmtf_atom = parse_mmtf.mmtf_atoms[i]
                mmcif_atom = parse_mmtf.mmcif_atoms[i]
                parse_mmtf.assertEqual(
                    mmtf_atom.name, mmcif_atom.name
                )  # eg. CA, spaces are removed from atom name
                parse_mmtf.assertEqual(
                    mmtf_atom.fullname,
                    mmcif_atom.fullname)  # e.g. " CA ", spaces included
                parse_mmtf.assertAlmostEqual(mmtf_atom.coord[0],
                                             mmcif_atom.coord[0],
                                             places=3)
                parse_mmtf.assertAlmostEqual(mmtf_atom.coord[1],
                                             mmcif_atom.coord[1],
                                             places=3)
                parse_mmtf.assertAlmostEqual(mmtf_atom.coord[2],
                                             mmcif_atom.coord[2],
                                             places=3)
                parse_mmtf.assertEqual(mmtf_atom.bfactor, mmcif_atom.bfactor)
                parse_mmtf.assertEqual(mmtf_atom.occupancy,
                                       mmcif_atom.occupancy)
                parse_mmtf.assertEqual(mmtf_atom.altloc, mmcif_atom.altloc)
                parse_mmtf.assertEqual(
                    mmtf_atom.full_id, mmcif_atom.full_id
                )  # (structure id, model id, chain id, residue id, atom id)
                parse_mmtf.assertEqual(
                    mmtf_atom.id,
                    mmcif_atom.name)  # id of atom is the atom name (e.g. "CA")
                # self.assertEqual(mmtf_atom.serial_number,mmcif_atom.serial_number) # mmCIF serial number is none
        def test_residues(parse_mmtf):
            """Test that all residues in self.mmcif_res and self.mmtf_res are equivalent"""
            parse_mmtf.assertEqual(len(parse_mmtf.mmcif_res),
                                   len(parse_mmtf.mmtf_res))
            for i, e in enumerate(parse_mmtf.mmcif_res):
                mmcif_r = parse_mmtf.mmcif_res[i]
                mmtf_r = parse_mmtf.mmtf_res[i]
                parse_mmtf.assertEqual(mmtf_r.level, mmcif_r.level)
                parse_mmtf.assertEqual(mmtf_r.disordered, mmcif_r.disordered)
                parse_mmtf.assertEqual(mmtf_r.resname, mmcif_r.resname)
                parse_mmtf.assertEqual(mmtf_r.segid, mmcif_r.segid)
                parse_mmtf.mmcif_atoms = [x for x in mmcif_r.get_atom()]
                parse_mmtf.mmtf_atoms = [x for x in mmtf_r.get_atom()]
                test_atoms(parse_mmtf=parse_mmtf)

        with warnings.catch_warnings():
            warnings.simplefilter('ignore', PDBConstructionWarning)
            mmtf_struct = MMTFParser.get_structure("PDB/4CUP.mmtf")
        mmcif_parser = MMCIFParser()
        mmcif_struct = mmcif_parser.get_structure("example", "PDB/4CUP.cif")
        self.mmcif_atoms = [x for x in mmcif_struct.get_atoms()]
        self.mmtf_atoms = [x for x in mmtf_struct.get_atoms()]
        test_atoms(self)
        mmcif_chains = [x for x in mmcif_struct.get_chains()]
        mmtf_chains = [x for x in mmtf_struct.get_chains()]
        self.assertEqual(len(mmcif_chains), len(mmtf_chains))
        for i, e in enumerate(mmcif_chains):
            self.mmcif_res = [x for x in mmcif_chains[i].get_residues()]
            self.mmtf_res = [x for x in mmtf_chains[i].get_residues()]
            test_residues(self)

        self.mmcif_res = [x for x in mmcif_struct.get_residues()]
        self.mmtf_res = [x for x in mmtf_struct.get_residues()]
        test_residues(self)
        self.assertEqual(len([x for x in mmcif_struct.get_models()]),
                         len([x for x in mmtf_struct.get_models()]))
Exemplo n.º 13
0
def test_parser():
    """Simply test that """
    with warnings.catch_warnings():
        warnings.simplefilter('ignore', PDBConstructionWarning)
        structure = MMTFParser.get_structure("PDB/4CUP.mmtf")
Exemplo n.º 14
0
 def test_cif(self):
     """Parse MMTF file."""
     with warnings.catch_warnings():
         warnings.simplefilter('ignore', PDBConstructionWarning)
         structure = MMTFParser.get_structure("PDB/1EJG.mmtf")
         print(structure)
Exemplo n.º 15
0
def view_protein(in_file,
                 file_format=None,
                 curr_model=1,
                 chains=[],
                 box_size=100.0):
    if box_size < 10.0 or box_size > 400.0:
        print("Box size must be between 10 and 400")
        return

    zoom_speed = 1.1
    trans_speed = 1.0
    rot_speed = 0.1
    spin_speed = 0.01
    action_count = 500
    auto_spin = False
    cycle_models = False

    # Infer file format from extension
    if file_format is None:
        file_format = os.path.basename(in_file).rsplit(".", 1)[-1]

    # Handle stdin
    if in_file == "-":
        contents = sys.stdin.read()
        struct_file = StringIO(contents)
        try:
            # Redirect stdin from pipe back to terminal
            sys.stdin = open("/dev/tty", "r")
        except:
            print(
                "Piping structures not supported on this system (no /dev/tty)")
            return
    else:
        struct_file = in_file

    if file_format.lower() == "pdb":
        from Bio.PDB import PDBParser
        p = PDBParser()
        struc = p.get_structure("", struct_file)
    elif file_format.lower() in ("mmcif", "cif"):
        from Bio.PDB.MMCIFParser import MMCIFParser
        p = MMCIFParser()
        struc = p.get_structure("", struct_file)
    elif file_format.lower() == "mmtf":
        from Bio.PDB.mmtf import MMTFParser
        struc = MMTFParser.get_structure(struct_file)
    else:
        print("Unrecognised file format")
        return

    # Get backbone coordinates
    coords = []
    connections = []
    atom_counter, res_counter = 0, 0
    chain_ids = []
    for mi, model in enumerate(struc):
        model_coords = []
        for chain in model:
            chain_id = chain.get_id()
            if len(chains) > 0 and chain_id not in chains:
                continue
            if mi == 0:
                chain_ids.append(chain_id)
            for res in chain:
                if mi == 0:
                    res_counter += 1
                res_n = res.get_id()[1]
                for atom in res:
                    if mi == 0:
                        atom_counter += 1
                    if atom.get_name() in (
                            "N",
                            "CA",
                            "C",  # Protein
                            "P",
                            "O5'",
                            "C5'",
                            "C4'",
                            "C3'",
                            "O3'",  # Nucleic acid
                    ):
                        if mi == 0 and len(model_coords) > 0:
                            # Determine if the atom is connected to the previous atom
                            connections.append(chain_id == last_chain_id
                                               and (res_n == (last_res_n + 1)
                                                    or res_n == last_res_n))
                        model_coords.append(atom.get_coord())
                        last_chain_id, last_res_n = chain_id, res_n
        model_coords = np.array(model_coords)
        if mi == 0:
            if model_coords.shape[0] == 0:
                print("Nothing to show")
                return
            coords_mean = model_coords.mean(0)
        model_coords -= coords_mean  # Center on origin of first model
        coords.append(model_coords)
    coords = np.array(coords)
    if curr_model > len(struc):
        print("Can't find that model")
        return
    info_str = "{} with {} models, {} chains ({}), {} residues, {} atoms".format(
        os.path.basename(in_file), len(struc), len(chain_ids),
        "".join(chain_ids), res_counter, atom_counter)

    # Make square bounding box of a set size and determine zoom
    x_min, x_max = float(coords[curr_model - 1, :,
                                0].min()), float(coords[curr_model - 1, :,
                                                        0].max())
    y_min, y_max = float(coords[curr_model - 1, :,
                                1].min()), float(coords[curr_model - 1, :,
                                                        1].max())
    x_diff, y_diff = x_max - x_min, y_max - y_min
    box_bound = float(np.max([x_diff, y_diff])) + 2.0
    zoom = box_size / box_bound
    x_min = zoom * (x_min - (box_bound - x_diff) / 2.0)
    x_max = zoom * (x_max + (box_bound - x_diff) / 2.0)
    y_min = zoom * (y_min - (box_bound - y_diff) / 2.0)
    y_max = zoom * (y_max + (box_bound - y_diff) / 2.0)

    # See https://stackoverflow.com/questions/13207678/whats-the-simplest-way-of-detecting-keyboard-input-in-python-from-the-terminal/13207724
    fd = sys.stdin.fileno()

    oldterm = termios.tcgetattr(fd)
    newattr = termios.tcgetattr(fd)
    newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
    termios.tcsetattr(fd, termios.TCSANOW, newattr)

    oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
    fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)

    canvas = Canvas()
    trans_x, trans_y = 0.0, 0.0
    rot_x, rot_y = 0.0, 0.0

    try:
        while True:
            os.system("clear")
            points = []

            for x_start, y_start, x_end, y_end in (
                (x_min, y_min, x_max, y_min),
                (x_max, y_min, x_max, y_max),
                (x_max, y_max, x_min, y_max),
                (x_min, y_max, x_min, y_min),
            ):
                for x, y in line(x_start, y_start, x_end, y_end):
                    points.append([x, y])

            rot_mat_x = np.array([
                [1.0, 0.0, 0.0],
                [0.0, np.cos(rot_x), -np.sin(rot_x)],
                [0.0, np.sin(rot_x), np.cos(rot_x)],
            ],
                                 dtype=np.float32)
            rot_mat_y = np.array([
                [np.cos(rot_y), 0.0, np.sin(rot_y)],
                [0.0, 1.0, 0.0],
                [-np.sin(rot_y), 0.0, np.cos(rot_y)],
            ],
                                 dtype=np.float32)
            trans_coords = coords[curr_model - 1] + np.array(
                [trans_x, trans_y, 0.0], dtype=np.float32)
            zoom_rot_coords = zoom * np.matmul(
                rot_mat_y, np.matmul(rot_mat_x, trans_coords.T)).T

            for i in range(coords.shape[1] - 1):
                if connections[i]:
                    x_start, x_end = float(zoom_rot_coords[i, 0]), float(
                        zoom_rot_coords[i + 1, 0])
                    y_start, y_end = float(zoom_rot_coords[i, 1]), float(
                        zoom_rot_coords[i + 1, 1])
                    if x_min < x_start < x_max and x_min < x_end < x_max and y_min < y_start < y_max and y_min < y_end < y_max:
                        for x, y in line(x_start, y_start, x_end, y_end):
                            points.append([x, y])

            print(info_str)
            print(
                "W/A/S/D rotates, T/F/G/H moves, I/O zooms, U spins, P cycles models, Q quits"
            )
            canvas.clear()
            for x, y in points:
                canvas.set(x, y)
            print(canvas.frame())

            counter = 0
            while True:
                if auto_spin or cycle_models:
                    counter += 1
                    if counter == action_count:
                        if auto_spin:
                            rot_y += spin_speed
                        if cycle_models:
                            curr_model += 1
                            if curr_model > len(struc):
                                curr_model = 1
                        break
                try:
                    k = sys.stdin.read(1)
                    if k:
                        if k.upper() == "O":
                            zoom /= zoom_speed
                        elif k.upper() == "I":
                            zoom *= zoom_speed
                        elif k.upper() == "F":
                            trans_x -= trans_speed
                        elif k.upper() == "H":
                            trans_x += trans_speed
                        elif k.upper() == "G":
                            trans_y -= trans_speed
                        elif k.upper() == "T":
                            trans_y += trans_speed
                        elif k.upper() == "S":
                            rot_x -= rot_speed
                        elif k.upper() == "W":
                            rot_x += rot_speed
                        elif k.upper() == "A":
                            rot_y -= rot_speed
                        elif k.upper() == "D":
                            rot_y += rot_speed
                        elif k.upper() == "U":
                            auto_spin = not auto_spin
                        elif k.upper() == "P" and len(struc) > 1:
                            cycle_models = not cycle_models
                        elif k.upper() == "Q":
                            return
                        break
                except IOError:
                    pass
    finally:
        termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
        fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)
Exemplo n.º 16
0
 def test_1A80(self):
     """Parse 1A8O.mmtf."""
     with warnings.catch_warnings():
         warnings.simplefilter("ignore", PDBConstructionWarning)
         structure = MMTFParser.get_structure("PDB/1A8O.mmtf")
Exemplo n.º 17
0
def test_parser():
    """Simply test that """
    with warnings.catch_warnings():
        warnings.simplefilter('ignore', PDBConstructionWarning)
        structure = MMTFParser.get_structure("PDB/4CUP.mmtf")
Exemplo n.º 18
0
# Benchmark the parsing of a MMTF file given as an argument

import sys
import time
from Bio.PDB.mmtf import MMTFParser

mmtf_filepath = sys.argv[1]

start = time.time()
MMTFParser.get_structure(mmtf_filepath)
end = time.time()

print(end - start)