Example #1
0
    def test_line(self):
        self.pymol_file.commands += PyMOLCommands.line("myline", (1, 1, 1),
                                                       (2, 2, 2),
                                                       self.pomegranate,
                                                       width=4)

        self.pymol_file.commands += PyMOLCommands.line("myline2", (1, 1, 1),
                                                       (0, 0, 0),
                                                       self.pomegranate,
                                                       width=10)

        self.pymol_file.write("testdata/wrapper_pymol/test_line.py")
Example #2
0
    def test_group(self):
        self.pymol_file.commands += PyMOLCommands.line("myline1", (0, 0, 0),
                                                       (1, 1, 1),
                                                       self.pomegranate,
                                                       width=10)

        self.pymol_file.commands += PyMOLCommands.pseudoatom(
            "mypseudoatom1", (0, 0, 0), self.pomegranate)

        self.pymol_file.commands += PyMOLCommands.pseudoatom(
            "mypseudoatom2", (1, 1, 1), self.pomegranate)
        self.pymol_file.commands += PyMOLCommands.group(
            "mygroup", ["myline1", "mypseudoatom1", "mypseudoatom2"])

        self.pymol_file.write("testdata/wrapper_pymol/test_group.py")
Example #3
0
    def to_pymol_str(self, i=0, label=True, transparency=0.6):
        pymol_out = ""
        point_colour = rgb_to_decimal(self.colour)
        point_colour = utilities.Colour(point_colour[0], point_colour[1],
                                        point_colour[2], transparency)
        feat_ID = f"{self.identifier}_{i}"
        group = []

        coords = (self.point[0].centre[0], self.point[0].centre[1],
                  self.point[0].centre[2])

        radius = self.point[0].radius

        point_objname = f"{self.identifier}_point_{i}"
        pymol_out += PyMOLCommands.sphere(point_objname,
                                          point_colour,
                                          coords,
                                          radius=radius)
        pymol_out += PyMOLCommands.load_cgo(point_objname,
                                            f"{point_objname}_obj")
        group.append(f"{point_objname}_obj")

        if self.score != 0 and label:
            score_name = f"{point_objname}_score"
            pymol_out += PyMOLCommands.pseudoatom(
                objname=score_name,
                coords=coords,
                label=f'{round(self.score, 1)}')
            group.append(score_name)

            rank_name = f"{self.identifier}_rank_{i}"
            pymol_out += PyMOLCommands.pseudoatom(objname=rank_name,
                                                  coords=coords,
                                                  label=str(i + 1))
            group.append(rank_name)

        if self.projected:
            proj_coords = (self.projected[0].centre[0],
                           self.projected[0].centre[1],
                           self.projected[0].centre[2])

            projection_objname = f"{self.identifier}_projection_{i}"
            line_objname = f"{self.identifier}_line_{i}"

            group.extend([projection_objname, line_objname])
            if self.projected_value != 0 and label:
                proj_score_name = f"{point_objname}_proj_score"
                pymol_out += PyMOLCommands.pseudoatom(
                    objname=proj_score_name,
                    coords=proj_coords,
                    label=f'{round(self.projected_value, 1)}')
                group.append(proj_score_name)
            projected_colour = adjust_lightness(self.colour, percentage=30)
            projected_colour = utilities.Colour(projected_colour[0],
                                                projected_colour[1],
                                                projected_colour[2],
                                                transparency)
            projected_radius = self.projected[0].radius

            pymol_out += PyMOLCommands.sphere(projection_objname,
                                              projected_colour,
                                              proj_coords,
                                              radius=projected_radius)
            pymol_out += PyMOLCommands.load_cgo(projection_objname,
                                                f"{projection_objname}_obj")
            pymol_out += PyMOLCommands.line(line_objname,
                                            coords,
                                            proj_coords,
                                            rgb=projected_colour)

        pymol_out += PyMOLCommands.group(feat_ID, group)
        return pymol_out