Exemplo n.º 1
0
 def __init__(self):
     self._active = False
     self._value = _Button._MultiStateVariable._create("")
     self._color = _Button._MultiStateVariable._create(Color.White())
     self._sharpness = 0.5
     self._size = 1.0
     self._ratio = 0.5
     self._position = Vector3()
     self._rotation = Vector3()
Exemplo n.º 2
0
 def make_menu(self):
     self.menu = nanome.ui.Menu()
     self.menu_position = Vector3()
     self.menu_rotation = Quaternion()
     self.menu_scale = Vector3()
     self.last = time.time()
     self.outstanding = True
     self.update_menu(self.menu)
     self.request_menu_transform(0, lambda _1, _2, _3: None)
     self.set_menu_transform(0, self.menu_position, self.menu_rotation,
                             self.menu_scale)
     self.request_menu_transform(0, self.check_menu_stats)
Exemplo n.º 3
0
def get_complex_center(complex):
    """Calculate the center of a complex."""
    inf = float('inf')
    min_pos = Vector3(inf, inf, inf)
    max_pos = Vector3(-inf, -inf, -inf)

    for atom in complex.atoms:
        min_pos.x = min(min_pos.x, atom.position.x)
        min_pos.y = min(min_pos.y, atom.position.y)
        min_pos.z = min(min_pos.z, atom.position.z)
        max_pos.x = max(max_pos.x, atom.position.x)
        max_pos.y = max(max_pos.y, atom.position.y)
        max_pos.z = max(max_pos.z, atom.position.z)

    return (min_pos + max_pos) * 0.5
Exemplo n.º 4
0
def structure_molecule(model):
    # type: (Content.Model) -> Molecule
    molecule = _Molecule._create()
    molecule._name = model.name

    chain = _Chain._create()
    chain._name = "S"
    molecule._add_chain(chain)
    residue = _Residue._create()
    residue._name = "SDF"
    residue._type = residue._name
    residue.serial = 1
    chain._add_residue(residue)
    atoms_by_serial = {}

    for catom in model.atoms:
        atom = _Atom._create()
        atom._symbol = catom.symbol
        atom._serial = catom.serial
        atom._position = Vector3(catom.x, catom.y, catom.z)
        atom._name = catom.symbol
        atom._is_het = True
        atom._formal_charge = catom.charge
        residue._add_atom(atom)
        atoms_by_serial[atom._serial] = atom
    for cbond in model.bonds:
        if cbond.serial_atom1 in atoms_by_serial and cbond.serial_atom2 in atoms_by_serial:
            bond = _Bond._create()
            bond._atom1 = atoms_by_serial[cbond.serial_atom1]
            bond._atom2 = atoms_by_serial[cbond.serial_atom2]
            bond._kind = enums.Kind.safe_cast(cbond.bond_order)
            residue._add_bond(bond)
    molecule._associated = model._associated
    return molecule
Exemplo n.º 5
0
def test_matrices():
    a = Matrix(3, 4)
    b = Matrix(4, 3)
    v = Matrix(4, 1)
    v[0][0] = 12.5
    v[1][0] = 9.36
    v[2][0] = 24.1
    v[3][0] = 1.0
    result_mul = Matrix(3, 3)
    result_mul[0] = [42, 48, 54]
    result_mul[1] = [114, 136, 158]
    result_mul[2] = [186, 224, 262]
    result_mul_v = Matrix(3, 1)
    result_mul_v[0][0] = 60.56
    result_mul_v[1][0] = 248.4
    result_mul_v[2][0] = 436.24

    for i in range(12):
        a[int(i / 4)][int(i % 4)] = i
        b[int(i / 3)][int(i % 3)] = i

    assert_equal(a * b, result_mul)
    assert_equal(a * v, result_mul_v)

    res_atom_global_pos = Vector3(-20.33947, 0.1491127, -9.878754)
    complex = struct.Complex()
    atom = struct.Atom()
    atom.position.set(7.2, 2.6, -21.56)
    complex.position.set(-3.197371, -2.314157, 5.071643)
    complex.rotation.set(0.09196287, 0.4834483, 0.3486853, 0.797646)
    m = complex.get_complex_to_workspace_matrix()
    m_inv = complex.get_workspace_to_complex_matrix()
    atom_global_pos = m * atom.position
    assert_equal(atom_global_pos, res_atom_global_pos)
    assert_equal(m_inv * atom_global_pos, atom.position)
Exemplo n.º 6
0
 def import_file(self, file_text, file_name, ext, button):
     lines = file_text.split('\n')
     suffix = ext if ext != 'cif' else 'mmcif'
     complex = getattr(nanome.api.structure.Complex.io,
                       'from_' + suffix)(lines=lines)
     complex.name = file_name
     complex.position = Vector3()
     self._plugin.add_bonds([complex], self._plugin.add_to_workspace)
Exemplo n.º 7
0
    def __init__(self):
        self._A = 0.0
        self._B = 0.0
        self._C = 0.0

        self._Alpha = 0.0
        self._Beta = 0.0
        self._Gamma = 0.0

        self._Origin = Vector3()
Exemplo n.º 8
0
def create_complex():
    val = struct.Complex()
    val.index = 1000
    val._molecules = [struct.Molecule(), create_molecule(), struct.Molecule(), create_molecule()]
    val.boxed = True
    val.visible = False
    val.computing = False
    val.set_current_frame(0)
    val.name = "COMPLEX_NAME"
    val._remarks = dict([("key1", "val1"), ("key2","val2"),("key3", "val3"), ("key4","val4")])
    val.position = Vector3(1,2,3)
    val.rotation = Quaternion(1,2,3,4)
    return val
Exemplo n.º 9
0
def StructureAtom(c_atom, helper):
    atom = _Atom._create()
    atom._serial = c_atom.atom_serial
    atom._occupancy = c_atom.occupancy
    atom._bfactor = c_atom.bfactor
    atom._position = Vector3(c_atom.x, c_atom.y, c_atom.z)
    atom._symbol = c_atom.symbol
    atom._name = c_atom.atom_name
    atom._is_het = c_atom.is_het
    if (atom._symbol == ""):
        atom._symbol = atom._name[0]
    if (c_atom.fract and helper != None):
        helper.Orthogonalize(c_atom.x, c_atom.y, c_atom.z, atom._position)
    return atom
Exemplo n.º 10
0
def create_atom():
    val = struct.Atom()
    val.index = 1000
    val.selected = True
    val.atom_mode = 1  # BALLSTICK
    val.labeled = True
    val.atom_rendering = True
    val.atom_color = Color.White()
    val.surface_rendering = True
    val.surface_color = Color.White()
    val.surface_opacity = 1
    val.symbol = "Carbon"
    val.serial = 0
    val.name = "default"
    val.position = Vector3()
    return val
Exemplo n.º 11
0
    def __init__(self, tokens):
        self.__is_het = tokens[0] != "ATOM"
        self.__atom_number = int(tokens[1])
        self.__atom_name = tokens[2]
        self.__res_name = tokens[3]
        if len(tokens) > 10:
            self.__chain_id = tokens[4]
        else:
            self.__chain_id = None

        # Strip non numeric characters from the residue number
        res_number = re.sub("[^0-9]", "", tokens[-6])
        self.__res_number = int(res_number)
        self.__position = Vector3(tokens[-5], tokens[-4], tokens[-3])
        self.__charge = float(tokens[-2])
        self.__radius = float(tokens[-1])
Exemplo n.º 12
0
def structure_molecule(atoms, compnds):
    # All structured infos
    all_residues = {}  #<string, Residue>
    all_chains = {}  #<string, Chain>
    all_atoms = {}  #<string, Atom>
    # Read all atoms
    for ratom in atoms:
        atom = _Atom._create()
        atom._symbol = ratom.element_symbol
        atom._serial = ratom.atom_serial_number
        atom._name = ratom.atom_name
        #atom.alts = ratom.atom_alternate_location
        atom._occupancy = ratom.occupancy
        atom._bfactor = ratom.bfactor
        #atom.charge = ratom.atom_charge
        atom._position = Vector3(ratom.atom_x, ratom.atom_y, ratom.atom_z)
        atom._is_het = ratom.is_het_atom
        atom_id = ratom.chain_identifier + ":" + str(
            ratom.residue_serial_number) + ":" + ratom.atom_name + ":" + str(
                ratom.atom_serial_number)
        if not atom_id in all_atoms:
            residue_id = ratom.chain_identifier + ":" + str(
                ratom.residue_serial_number) + ":" + ratom.segment_identifier
            if not residue_id in all_residues:
                residue = _Residue._create()
                residue._name = ratom.residue_name
                residue._type = residue._name
                residue._serial = ratom.residue_serial_number
                # residue.insertion_code = ratom.residue_insertion_code
                all_residues[residue_id] = residue
                chain_id = ratom.chain_identifier
                if ratom.is_het_atom:
                    chain_id = "H" + chain_id
                if not chain_id in all_chains:
                    chain = _Chain._create()
                    chain._name = chain_id
                    all_chains[chain_id] = chain
                all_chains[chain_id]._add_residue(residue)
            all_residues[residue_id]._add_atom(atom)
            all_atoms[atom_id] = atom
    # Final molecule
    molecule = _Molecule._create()
    # Assemble molecule contents
    for chain in all_chains:
        molecule._add_chain(all_chains[chain])
    # Done
    return molecule
Exemplo n.º 13
0
 def build_simple_complex(self, name, color):
     new_complex = Complex()
     new_complex.name = name
     new_molecule = Molecule()
     new_chain = Chain()
     new_residue = Residue()
     new_atom1 = Atom()
     new_atom2 = Atom()
     new_bond = Bond()
     new_complex.add_molecule(new_molecule)
     new_molecule.add_chain(new_chain)
     new_chain.add_residue(new_residue)
     new_residue.add_atom(new_atom1)
     new_residue.add_atom(new_atom2)
     new_residue.add_bond(new_bond)
     new_bond.atom1 = new_atom1
     new_bond.atom2 = new_atom2
     new_atom2.position = Vector3(0, 0, 1)
     new_atom1.atom_color = color
     new_atom2.atom_color = color
     return new_complex
Exemplo n.º 14
0
 def __init__(self):
     super(_Complex, self).__init__()
     #Molecular
     self._name = "complex"
     self._index_tag = 0
     self._split_tag = ""
     self._remarks = {}
     #Rendering
     self._boxed = False
     self._locked = False
     self._visible = True
     self._computing = False
     self._current_frame = 0
     self._selected = False  #selected on live
     self._surface_dirty = False
     self._surface_refresh_rate = -1.0  # Not used yet, future auto surface refresh
     self._box_label = ""
     #Transform
     self._position = Vector3(0, 0, 0)
     self._rotation = Quaternion(0, 0, 0, 0)
     self._molecules = []
     self._parent = None
Exemplo n.º 15
0
 def __init__(self):
     super(_Atom, self).__init__()
     #Molecular
     self._symbol = "C"
     self._serial = 1
     self._name = "default"
     self._is_het = False
     self._atom_type = "C"
     #No API
     self._occupancy = 0.0
     self._bfactor = 0.0
     self._acceptor = False
     self._donor = False
     self._formal_charge = 0
     #Rendering
     #API
     self._selected = False
     self._atom_mode = _Atom.AtomRenderingMode.BallStick
     self._labeled = False
     self._label_text = ""
     self._atom_rendering = True
     self._atom_color = Color.Clear()
     self._atom_scale = 0.5
     self._surface_rendering = False
     self._surface_color = Color.Clear()
     self._surface_opacity = 1.0
     #No API
     self._hydrogened = True
     self._watered = True
     self._het_atomed = True
     self._het_surfaced = True
     #conformer
     self._positions = [Vector3()]
     self._in_conformer = [True]
     #internal
     self._unique_identifier = _Atom._atom_count
     self._bonds = []
     self._parent = None
     _Atom._atom_count += 1
Exemplo n.º 16
0
def parse_lines(lines):
    descrip = lines[0].split()
    if(descrip[3] != 'gridpositions'):
        raise Exception("unsupported OpenDX format {}".format(descrip[3]))

    dim = [int(x) for x in descrip[-3:]]

    origin = [float(n) for n in lines[1].split()[1:]]
    delta = [float(line.split()[i])
             for line, i in zip(lines[2:5], range(1, 4))]

    cell = _UnitCell()
    cell._A = (dim[0] - 1) * delta[0]
    cell._B = (dim[1] - 1) * delta[1]
    cell._C = (dim[2] - 1) * delta[2]
    cell._Alpha = 90.0
    cell._Beta = 90.0
    cell._Gamma = 90.0
    cell._Origin = Vector3(origin[0], origin[1], origin[2])

    volume = _VolumeData()
    volume._width = dim[0]
    volume._height = dim[1]
    volume._depth = dim[2]
    volume._mean = 0.0
    volume._rmsd = 1.0
    volume._type = VolumeType.electrostatic
    volume._name = "map.dx"
    volume._cell = cell

    datalines = lines[7:-5]
    data = [float(x) for line in datalines for x in line.split()]

    volume._data = [data[z + (y + x * dim[1]) * dim[2]] for z in range(dim[2])
                    for y in range(dim[1]) for x in range(dim[0])]
    return volume
Exemplo n.º 17
0
def create_workspace():
    workspace = struct.Workspace()
    workspace.complexes = [struct.Complex(), create_complex(), struct.Complex(), create_complex()]
    workspace.position = Vector3(1,2,3)
    workspace.rotation = Quaternion(1,2,3,4)
    return workspace
Exemplo n.º 18
0
def test_error_conditions():
    sample_kinds = [nanome.util.enums.Kind.CovalentSingle, nanome.util.enums.Kind.CovalentDouble, nanome.util.enums.Kind.CovalentTriple]
    sample_positions = [Vector3(0,0,0), Vector3(1,1,1), Vector3(2,2,2)]
    sample_exists = [True, False, True]
    molecule = create_frames(1)[0]
    atom = next(molecule.atoms)
    bond = next(molecule.bonds)
    failed = False
    try:
        atom.positions = sample_positions
    except ValueError:
        failed = True
    assert(failed)

    failed = False
    try:
        atom.in_conformer = sample_exists
    except ValueError:
        failed = True
    assert(failed)

    failed = False
    try:
        bond.in_conformer = sample_exists
    except ValueError:
        failed = True
    assert(failed)

    failed = False
    try:
        bond.kinds = sample_kinds
    except ValueError:
        failed = True
    assert(failed)

    failed = False
    try:
        molecule.associateds = [{}, {}, {}]
    except ValueError:
        failed = True
    assert(failed)

    failed = False
    try:
        molecule.names = ["", "", ""]
    except ValueError:
        failed = True
    assert(failed)

    new_atom = struct.Atom()
    new_atom.in_conformer = sample_exists
    failed = False
    try:
        next(molecule.residues).add_atom(new_atom)
    except ValueError:
        failed = True
    assert(failed)

    new_atom = struct.Atom()
    new_atom.positions = sample_positions
    failed = False
    try:
        next(molecule.residues).add_atom(new_atom)
    except ValueError:
        failed = True
    assert(failed)

    new_atom = struct.Atom()
    new_atom.in_conformer = sample_exists
    failed = False
    try:
        next(molecule.residues).add_atom(new_atom)
    except ValueError:
        failed = True
    assert(failed)

    new_bond = struct.Bond()
    new_bond.kinds = sample_kinds
    failed = False
    try:
        next(molecule.residues).add_bond(new_bond)
    except ValueError:
        failed = True
    assert(failed)

    new_bond = struct.Bond()
    new_bond.in_conformer = sample_exists
    failed = False
    try:
        next(molecule.residues).add_bond(new_bond)
    except ValueError:
        failed = True
    assert(failed)
Exemplo n.º 19
0
 def __init__(self):
     self._position = Vector3()
     self._rotation = Quaternion()
     self._scale = Vector3(0.02,0.02,0.02)
     self._complexes = []
Exemplo n.º 20
0
def parse_json(content_json):
    # type: () -> Button
    #region text
    button = _Button._create()
    button._selected = content_json.read("selected", button._selected)
    button._unusable = content_json.read("unusable", button._unusable)
    button._text._active = content_json.read("text_active",
                                             button._text._active)
    button._text._value._idle = content_json.read("text_value_idle",
                                                  button._text._value._idle)
    button._text._value._selected = content_json.read(
        "text_value_selected", button._text._value._selected)
    button._text._value._highlighted = content_json.read(
        "text_value_highlighted", button._text._value._highlighted)
    button._text._value._selected_highlighted = content_json.read(
        "text_value_selected_highlighted",
        button._text._value._selected_highlighted)
    button._text._value._unusable = content_json.read(
        "text_value_unusable", button._text._value._unusable)
    button._text._auto_size = content_json.read("text_auto_size",
                                                button._text._auto_size)
    button._text._min_size = content_json.read("text_min_size",
                                               button._text._min_size)
    button._text._max_size = content_json.read("text_max_size",
                                               button._text._max_size)
    button._text._size = content_json.read("text_size", button._text._size)
    button._text._underlined = content_json.read("text_underlined",
                                                 button._text._underlined)
    button._text._bold._set_all(content_json.read("text_bolded",
                                                  False))  #deprecated
    button._text._bold._idle = content_json.read("text_bold_idle",
                                                 button._text._bold._idle)
    button._text._bold._selected = content_json.read(
        "text_bold_selected", button._text._bold._selected)
    button._text._bold._highlighted = content_json.read(
        "text_bold_highlighted", button._text._bold._highlighted)
    button._text._bold._selected_highlighted = content_json.read(
        "text_bold_selected_highlighted",
        button._text._bold._selected_highlighted)
    button._text._bold._unusable = content_json.read(
        "text_bold_unusable", button._text._bold._unusable)
    button._text._color._idle = content_json.read("text_color_idle",
                                                  button._text._color._idle)
    button._text._color._selected = content_json.read(
        "text_color_selected", button._text._color._selected)
    button._text._color._highlighted = content_json.read(
        "text_color_highlighted", button._text._color._highlighted)
    button._text._color._selected_highlighted = content_json.read(
        "text_color_selected_highlighted",
        button._text._color._selected_highlighted)
    button._text._color._unusable = content_json.read(
        "text_color_unusable", button._text._color._unusable)
    button._text._padding_top = content_json.read("text_padding_top",
                                                  button._text._padding_top)
    button._text._padding_bottom = content_json.read(
        "text_padding_bottom", button._text._padding_bottom)
    button._text._padding_left = content_json.read("text_padding_left",
                                                   button._text._padding_left)
    button._text._padding_right = content_json.read(
        "text_padding_right", button._text._padding_right)
    button._text._line_spacing = content_json.read("text_line_spacing",
                                                   button._text._line_spacing)
    button._text._vertical_align = VertAlignOptions(
        content_json.read("text_vertical_align", button._text._vertical_align))
    button._text._horizontal_align = HorizAlignOptions(
        content_json.read("text_horizontal_align",
                          button._text._horizontal_align))
    #endregion
    #region icon
    button._icon._active = content_json.read("icon_active",
                                             button._icon._active)
    button._icon._value._idle = content_json.read("icon_value_idle",
                                                  button._icon._value._idle)
    button._icon._value._selected = content_json.read(
        "icon_value_selected", button._icon._value._selected)
    button._icon._value._highlighted = content_json.read(
        "icon_value_highlighted", button._icon._value._highlighted)
    button._icon._value._selected_highlighted = content_json.read(
        "icon_value_selected_highlighted",
        button._icon._value._selected_highlighted)
    button._icon._value._unusable = content_json.read(
        "icon_value_unusable", button._icon._value._unusable)
    button._icon._color._idle = content_json.read("icon_color_idle",
                                                  button._icon._color._idle)
    button._icon._color._selected = content_json.read(
        "icon_color_selected", button._icon._color._selected)
    button._icon._color._highlighted = content_json.read(
        "icon_color_highlighted", button._icon._color._highlighted)
    button._icon._color._selected_highlighted = content_json.read(
        "icon_color_selected_highlighted",
        button._icon._color._selected_highlighted)
    button._icon._color._unusable = content_json.read(
        "icon_color_unusable", button._icon._color._unusable)
    button._icon._sharpness = content_json.read("icon_sharpness",
                                                button._icon._sharpness)
    button._icon._size = content_json.read("icon_size", button._icon._size)
    button._icon._ratio = content_json.read("icon_ratio", button._icon._ratio)
    button._icon._position = Vector3(
        content_json.read("icon_position_x", button._icon._position.x),
        content_json.read("icon_position_y", button._icon._position.y),
        content_json.read("icon_position_z", button._icon._position.z))
    button._icon._rotation = Vector3(
        content_json.read("icon_rotation_x", button._icon._rotation.x),
        content_json.read("icon_rotation_y", button._icon._rotation.y),
        content_json.read("icon_rotation_z", button._icon._rotation.z))
    #endregion
    #region mesh
    button._mesh._active = content_json.read("mesh_active",
                                             button._mesh._active)
    button._mesh._enabled._idle = content_json.read(
        "mesh_enabled_idle", button._mesh._enabled._idle)
    button._mesh._enabled._selected = content_json.read(
        "mesh_enabled_selected", button._mesh._enabled._selected)
    button._mesh._enabled._highlighted = content_json.read(
        "mesh_enabled_highlighted", button._mesh._enabled._highlighted)
    button._mesh._enabled._selected_highlighted = content_json.read(
        "mesh_enabled_selected_highlighted",
        button._mesh._enabled._selected_highlighted)
    button._mesh._enabled._unusable = content_json.read(
        "mesh_enabled_unusable", button._mesh._enabled._unusable)
    button._mesh._color._idle = content_json.read("mesh_color_idle",
                                                  button._mesh._color._idle)
    button._mesh._color._selected = content_json.read(
        "mesh_color_selected", button._mesh._color._selected)
    button._mesh._color._highlighted = content_json.read(
        "mesh_color_highlighted", button._mesh._color._highlighted)
    button._mesh._color._selected_highlighted = content_json.read(
        "mesh_color_selected_highlighted",
        button._mesh._color._selected_highlighted)
    button._mesh._color._unusable = content_json.read(
        "mesh_color_unusable", button._mesh._color._unusable)
    #endregion
    #region outline
    button._outline._active = content_json.read("outline_active",
                                                button._outline._active)
    button._outline._size._idle = content_json.read(
        "outline_size_idle", button._outline._size._idle)
    button._outline._size._selected = content_json.read(
        "outline_size_selected", button._outline._size._selected)
    button._outline._size._highlighted = content_json.read(
        "outline_size_highlighted", button._outline._size._highlighted)
    button._outline._size._selected_highlighted = content_json.read(
        "outline_size_selected_highlighted",
        button._outline._size._selected_highlighted)
    button._outline._size._unusable = content_json.read(
        "outline_size_unusable", button._outline._size._unusable)
    button._outline._color._idle = content_json.read(
        "outline_color_idle", button._outline._color._idle)
    button._outline._color._selected = content_json.read(
        "outline_color_selected", button._outline._color._selected)
    button._outline._color._highlighted = content_json.read(
        "outline_color_highlighted", button._outline._color._highlighted)
    button._outline._color._selected_highlighted = content_json.read(
        "outline_color_selected_highlighted",
        button._outline._color._selected_highlighted)
    button._outline._color._unusable = content_json.read(
        "outline_color_unusable", button._outline._color._unusable)
    #endregion
    #region tooltip
    button._tooltip._title = content_json.read("tooltip_title",
                                               button._tooltip._title)
    button._tooltip._content = content_json.read("tooltip_content",
                                                 button._tooltip._content)
    button._tooltip._bounds = content_json.read("tooltip_bounds",
                                                button._tooltip._bounds)
    button._tooltip._positioning_target = content_json.read(
        "tooltip_positioning_target", button._tooltip._positioning_target)
    button._tooltip._positioning_origin = content_json.read(
        "tooltip_positioning_origin", button._tooltip._positioning_origin)
    #endregion
    return button
Exemplo n.º 21
0
def convert_to_conformers(complex, force_conformer = None): #Data.Complex -> Data.Complex
    frame_count = len(complex._molecules)
    # Maybe conformers are disabled
    if frame_count <= 1 or s_ConformersDisabled:
        return complex._deep_copy()
    # Collect count of first molecule
    molecule_index = 0
    chain_total_count = 0
    residue_total_count = 0
    atom_total_count = 0
    bond_total_count = 0
    # Create molecular container
    new_complex = complex._shallow_copy() #Data.Complex
    new_complex._current_frame = 0
    new_molecule = complex._molecules[0]._shallow_copy() # Data.Molecule
    # Group structures by their hash
    new_chains = {}
    new_residues = {}
    new_atoms = {}
    new_bonds = {}
    # Computation stores
    sb = StringBuilder()
    names_dictionary = {}
    atoms_dictionary = {}
    # Get ready
    new_complex._add_molecule(new_molecule)
    new_molecule._conformer_count = len(complex._molecules)

    # Loop over all frames
    for molecule in complex._molecules:
        # Meta informations
        new_molecule._names[molecule_index] = molecule._name
        new_molecule._associateds[molecule_index] = molecule._associated
        # Loop over all chains
        for chain in molecule._chains:
            # Lookup or create chain with hash
            hash_chain = _get_chain_hash(sb, chain)
            new_chain = None
            if hash_chain in new_chains:
                new_chain = new_chains[hash_chain]
            else:
                new_chain = chain._shallow_copy()
                new_molecule._add_chain(new_chain)
                new_chains[hash_chain] = new_chain
            # Loop over all residues
            for residue in chain._residues:
                # Lookup or create chain with hash
                hash_residue = _get_residue_hash(sb, residue)
                new_residue = None
                if hash_residue in new_residues:
                    new_residue = new_residues[hash_residue]
                else:
                    new_residue = residue._shallow_copy()
                    new_chain._add_residue(new_residue)
                    new_residues[hash_residue] = new_residue
                # Cleanup
                names_dictionary.clear()

                for atom in residue._atoms:
                    name_hash = _get_hash_code(atom.name)
                    off = 0
                    if name_hash in names_dictionary:
                        off = names_dictionary[name_hash]
                    off +=1
                    names_dictionary[name_hash] = off
                    # Lookup or create atom with hash
                    hash_atom = _get_atom_hash(sb, atom, off)
                    new_atom = None
                    if hash_atom in new_atoms:
                        new_atom = new_atoms[hash_atom]
                    else:
                        new_atom = atom._shallow_copy()
                        new_atom._in_conformer = [False]*new_molecule._conformer_count
                        new_atom._positions = [Vector3()]*new_molecule._conformer_count
                        new_residue._add_atom(new_atom)
                        if off > 1:
                            new_atom.name = new_atom.name + str(off)
                        new_atoms[hash_atom] = new_atom
                        new_atom.serial = len(new_atoms)
                    # Update current conformer
                    new_atom._in_conformer[molecule_index] = True
                    new_atom._positions[molecule_index] = atom.position.get_copy()
                    # Save
                    atoms_dictionary[atom._unique_identifier] = (hash_atom, new_atom)
                    atom_total_count+=1
                residue_total_count+=1
            chain_total_count+=1

        for bond in molecule.bonds:
            atom_info_1 = atoms_dictionary[bond._atom1._unique_identifier]
            atom_info_2 = atoms_dictionary[bond._atom2._unique_identifier]

            # Lookup the parent residue
            residue = bond._parent
            hash_residue = _get_residue_hash(sb, residue)
            new_residue = new_residues[hash_residue]

            hash_bond = _get_bond_hash(sb, bond, atom_info_1[0], atom_info_2[0])
            new_bond = None
            if hash_bond in new_bonds:
                new_bond = new_bonds[hash_bond]
            else:
                new_bond = bond._shallow_copy()
                new_bond._in_conformer = [False]*new_molecule._conformer_count
                new_bond._kinds = [enums.Kind.CovalentSingle]*new_molecule._conformer_count
                new_residue._add_bond(new_bond)
                new_bonds[hash_bond] = new_bond
            # Update current conformer
            new_bond._in_conformer[molecule_index] = True
            new_bond._kinds[molecule_index] = bond.kind
            # Count bonds
            bond_total_count+=1

        for atom in molecule.atoms:
            for bond in atom.bonds:
                atom_info_1 = atoms_dictionary[bond._atom1._unique_identifier]
                atom_info_2 = atoms_dictionary[bond._atom2._unique_identifier]

                # Lookup the parent residue
                residue = bond._parent
                hash_residue = _get_residue_hash(sb, residue)
                new_residue = new_residues[hash_residue]

                hash_bond = _get_bond_hash(sb, bond, atom_info_1[0], atom_info_2[0])
                new_bond = new_bonds[hash_bond]
                if atom == bond._atom1:
                    new_bond._atom1 = atom_info_1[1]
                else:
                    new_bond._atom2 = atom_info_2[1]

        # Molecule idx
        molecule_index+=1
    if force_conformer == None:
        force_conformer = s_ConformersAlways
    # Important decision to make, is everything suited for a trajectories?
    if not force_conformer:
        # Gather important information of the conversion
        is_very_big_chains = chain_total_count > 1
        is_very_big_residues = residue_total_count > 10
        is_very_big_atoms = atom_total_count > 10000
        is_very_big_bonds = bond_total_count > 20000
        if len(new_chains) == 0:
            chain_similarity_ratio = 1
        else:
            chain_similarity_ratio = float(chain_total_count) / float(frame_count) / float(len(new_chains))
        if len(new_residues) == 0:
            residue_similarity_ratio = 1
        else:
            residue_similarity_ratio = float(residue_total_count) / float(frame_count) / float(len(new_residues))
        if len(new_atoms) == 0:
            atom_similarity_ratio = 1
        else:
            atom_similarity_ratio = float(atom_total_count) / float(frame_count) / float(len(new_atoms))
        if len(new_bonds) == 0:
            bond_similarity_ratio = 1
        else:
            bond_similarity_ratio = float(bond_total_count) / float(frame_count) / float(len(new_bonds))
        is_chain_similar_enough = chain_similarity_ratio > 0.85
        is_residue_similar_enough = residue_similarity_ratio > 0.85
        is_atom_similar_enough = atom_similarity_ratio > 0.85
        is_bond_similar_enough = bond_similarity_ratio > 0.85
        # Cancel conversion if not suited
        if is_very_big_chains and not is_chain_similar_enough:
            return complex._deep_copy()
        if is_very_big_residues and not is_residue_similar_enough:
            return complex._deep_copy()
        if is_very_big_atoms and not is_atom_similar_enough:
            return complex._deep_copy()
        if is_very_big_bonds and not is_bond_similar_enough:
            return complex._deep_copy()
    # Otherwise let's start grabbing the data
    return new_complex
Exemplo n.º 22
0
 def deserialize(self, version, context):
     x = context.read_float()
     y = context.read_float()
     z = context.read_float()
     return Vector3(x, y, z)
Exemplo n.º 23
0
def rand_pos():
    return Vector3(rand_float(-5, 5), rand_float(0, 2), rand_float(-5, 5))
Exemplo n.º 24
0
def rand_scale():
    scale = rand_float(.5, 1)
    return Vector3(scale, scale, scale)
Exemplo n.º 25
0
 def __init__(self):
     self._title = ""
     self._content = ""
     self._bounds = Vector3(1.73, .6, .05)
     self._positioning_target = _Button.ToolTipPositioning.right
     self._positioning_origin = _Button.ToolTipPositioning.top_left
Exemplo n.º 26
0
def test_conformer_API():
    #test molecule
    test = create_frames(1)[0]
    #conformer_count
    molecule = test._deep_copy()
    atom = next(molecule.atoms)
    bond = next(molecule.bonds)
    molecule.set_current_conformer(1)
    assert(molecule.current_conformer == 1)
    assert(atom.current_conformer == 1)
    assert(bond.current_conformer == 1)
    assert(molecule.conformer_count == 1)
    assert(atom.conformer_count == 1)
    assert(bond.conformer_count == 1)
    molecule.set_conformer_count(2)
    assert(molecule.current_conformer == 1)
    assert(atom.current_conformer == 1)
    assert(bond.current_conformer == 1)
    assert(molecule.conformer_count == 2)
    assert(atom.conformer_count == 2)
    assert(bond.conformer_count == 2)
    molecule.set_conformer_count(1)
    assert(molecule.current_conformer == 0)
    assert(atom.current_conformer == 0)
    assert(bond.current_conformer == 0)
    assert(molecule.conformer_count == 1)
    assert(atom.conformer_count == 1)
    assert(bond.conformer_count == 1)

    #list_resizing
    molecule = test._deep_copy()
    atom = next(molecule.atoms)
    bond = next(molecule.bonds)
    molecule.set_conformer_count(2)
    assert(len(molecule.names) == 2)
    assert(len(molecule.associateds) == 2)
    assert(molecule.names[1] == molecule.names[0])
    assert(molecule.associateds[1] == molecule.associateds[0])
    assert(len(atom.positions) == 2)
    assert(len(atom.in_conformer) == 2)
    assert(atom.positions[1].equals(atom.positions[0]))
    assert(atom.in_conformer[1] == atom.in_conformer[0])
    assert(len(bond.kinds) == 2)
    assert(len(bond.in_conformer) == 2)
    assert(bond.kinds[1] == bond.kinds[0])
    assert(bond.in_conformer[1] == bond.in_conformer[0])

    #convenience functions
    reference = test._deep_copy()
    atom = next(reference.atoms)
    bond = next(reference.bonds)
    reference.set_conformer_count(3)
    atom.positions = [Vector3(0,0,0), Vector3(1,1,1), Vector3(2,2,2)]
    bond.kinds = [nanome.util.enums.Kind.CovalentSingle, nanome.util.enums.Kind.CovalentDouble, nanome.util.enums.Kind.CovalentTriple]

    molecule = reference._deep_copy()
    atom = next(molecule.atoms)
    molecule.create_conformer(1)
    assert(molecule.conformer_count == 4)
    assert(len(molecule.names) == 4)
    assert(len(atom.positions) == 4)
    assert(atom.positions[0].equals(atom.positions[1]))
    assert(atom.positions[0] != atom.positions[1])
    molecule.create_conformer(4)
    molecule.create_conformer(0)

    molecule = reference._deep_copy()
    bond = next(molecule.bonds)
    molecule.copy_conformer(2, 0)
    assert(molecule.conformer_count == 4)
    assert(len(molecule.names) == 4)
    assert(len(bond.kinds) == 4)
    assert(bond.kinds[0] == bond.kinds[3])
    molecule.copy_conformer(3)
    molecule.copy_conformer(0)

    molecule = reference._deep_copy()
    bond = next(molecule.bonds)
    atom = next(molecule.atoms)
    position = atom.positions[2]
    molecule.move_conformer(2, 0)
    assert(molecule.conformer_count == 3)
    assert(len(molecule.names) == 3)
    assert(len(atom.positions) == 3)
    assert(atom.position[2] != position)
    assert(position == atom.positions[0])
    molecule.move_conformer(2,2)
    molecule.move_conformer(0,0)
    molecule.move_conformer(0,3)

    molecule = reference._deep_copy()
    bond = next(molecule.bonds)
    atom = next(molecule.atoms)
    molecule.set_current_conformer(2)
    position = atom.positions[2]
    deleted = atom.positions[0]
    molecule.delete_conformer(0)
    assert(molecule.current_conformer == 1)
    assert(molecule.conformer_count == 2)
    assert(len(molecule.names) == 2)
    assert(len(atom.positions) == 2)
    assert(atom.positions[1] == position)
    assert(atom.positions[0] != deleted)
    molecule.delete_conformer(1)
    molecule.delete_conformer(0)