Example #1
0
def test_glow():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    from chemlab.graphics.postprocessing.glow import GlowEffect
    from PySide import QtCore

    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    #mol = datafile('tests/data/3ZJE.pdb').read('system')

    v = QtViewer()

    colors = np.array([(255, 0, 0, 255)]*mol.n_atoms)
    colors[0][3] = 0

    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(SphereImpostorRenderer, mol.r_array, [0.1]*mol.n_atoms,
                        colors)

    ge = v.add_post_processing(GlowEffect)
    #v.add_post_processing(GammaCorrectionEffect)
    def changeglow():
        #ge.radius = np.sin(time.time()*10.0) + 2.5
        colors[0][3] = 255 * (np.sin(time.time()*10.0)*0.5 + 0.5)
        sr.update_colors(colors)
        v.widget.update()

    timer = QtCore.QTimer()
    timer.timeout.connect(changeglow)
    timer.start(10)
    #v.add_post_processing(SSAOEffect, ssao_power = 5.0)
    #v.add_post_processing(FXAAEffect)
    #v.add_post_processing(GammaCorrectionEffect)
    v.run()
Example #2
0
def test_glow():
    from PySide import QtCore
    
    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    
    v = QtViewer()
    colors = np.array([(255, 0, 0, 255)]*mol.n_atoms)
    colors[0][3] = 0

    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(SphereImpostorRenderer, mol.r_array, [0.1]*mol.n_atoms,
                        colors)

    ge = v.add_post_processing(GlowEffect)
    #v.add_post_processing(GammaCorrectionEffect)
    def changeglow():
        #ge.radius = np.sin(time.time()*10.0) + 2.5
        colors[0][3] = 255 * (np.sin(time.time()*10.0)*0.5 + 0.5)
        sr.update_colors(colors)
        v.widget.update()

    timer = QtCore.QTimer()
    timer.timeout.connect(changeglow)
    timer.start(10)
    v.run()
Example #3
0
def test_merge_system():
    # take a protein
    from chemlab.io import datafile
    from chemlab.graphics import display_system

    from chemlab.db import ChemlabDB

    water = ChemlabDB().get("molecule", "example.water")

    prot = datafile("tests/data/3ZJE.pdb").read("system")

    # Take a box of water
    NWAT = 50000
    bsize = 20.0
    pos = np.random.random((NWAT, 3)) * bsize
    wat = water.copy()

    s = System.empty(NWAT, NWAT * 3, box_vectors=np.eye(3) * bsize)
    for i in range(NWAT):
        wat.move_to(pos[i])
        s.add(wat)

    prot.r_array += 10
    s = merge_systems(s, prot, 0.5)

    display_system(s, 'ball-and-stick')
Example #4
0
def test_glow():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    from chemlab.graphics.postprocessing.glow import GlowEffect
    from PySide import QtCore

    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    #mol = datafile('tests/data/3ZJE.pdb').read('system')

    v = QtViewer()

    colors = np.array([(255, 0, 0, 255)] * mol.n_atoms)
    colors[0][3] = 0

    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(SphereImpostorRenderer, mol.r_array,
                        [0.1] * mol.n_atoms, colors)

    ge = v.add_post_processing(GlowEffect)

    #v.add_post_processing(GammaCorrectionEffect)
    def changeglow():
        #ge.radius = np.sin(time.time()*10.0) + 2.5
        colors[0][3] = 255 * (np.sin(time.time() * 10.0) * 0.5 + 0.5)
        sr.update_colors(colors)
        v.widget.update()

    timer = QtCore.QTimer()
    timer.timeout.connect(changeglow)
    timer.start(10)
    #v.add_post_processing(SSAOEffect, ssao_power = 5.0)
    #v.add_post_processing(FXAAEffect)
    #v.add_post_processing(GammaCorrectionEffect)
    v.run()
Example #5
0
def test_outline():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    from chemlab.graphics.postprocessing.outline import OutlineEffect

    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')

    mol = datafile('tests/data/3ZJE.pdb').read('system')
    #mol = datafile('tests/data/water.gro').read('system')
    #mol = datafile('tests/data/benzene.mol').read('molecule')
    v = QtViewer()

    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(AtomRenderer,
                        mol.r_array,
                        mol.type_array,
                        'impostors',
                        shading='toon')

    v.add_post_processing(OutlineEffect, 'depthnormal')
    v.add_post_processing(SSAOEffect, ssao_power=4.0)
    v.add_post_processing(FXAAEffect)
    v.add_post_processing(GammaCorrectionEffect)
    v.run()
Example #6
0
def test_glow():
    from PySide import QtCore

    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')

    v = QtViewer()
    colors = np.array([(255, 0, 0, 255)] * mol.n_atoms)
    colors[0][3] = 0

    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(SphereImpostorRenderer, mol.r_array,
                        [0.1] * mol.n_atoms, colors)

    ge = v.add_post_processing(GlowEffect)

    #v.add_post_processing(GammaCorrectionEffect)
    def changeglow():
        #ge.radius = np.sin(time.time()*10.0) + 2.5
        colors[0][3] = 255 * (np.sin(time.time() * 10.0) * 0.5 + 0.5)
        sr.update_colors(colors)
        v.widget.update()

    timer = QtCore.QTimer()
    timer.timeout.connect(changeglow)
    timer.start(10)
    v.run()
Example #7
0
def test_merge_system():
    # take a protein
    from chemlab.io import datafile
    from chemlab.graphics import display_system

    from chemlab.db import ChemlabDB

    water = ChemlabDB().get("molecule", "example.water")

    prot = datafile("tests/data/3ZJE.pdb").read("system")

    # Take a box of water
    NWAT = 50000
    bsize = 20.0
    pos = np.random.random((NWAT, 3)) * bsize
    wat = water.copy()

    s = System.empty(NWAT, NWAT*3, box_vectors=np.eye(3)*bsize)
    for i in range(NWAT):
        wat.move_to(pos[i])
        s.add(wat)

    prot.r_array += 10
    s = merge_systems(s, prot, 0.5)

    display_system(s, 'ball-and-stick')
Example #8
0
def test_random():
    '''Testing random made box'''
    from chemlab.db import ChemlabDB
    cdb = ChemlabDB()
    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])
    cl = Molecule([Atom('Cl', [0.0, 0.0, 0.0])])
    wat = cdb.get("molecule", 'gromacs.spce')

    s = random_lattice_box([na, cl, wat], [160, 160, 160], [4, 4, 4])
Example #9
0
def test_random():
    '''Testing random made box'''
    from chemlab.db import ChemlabDB
    cdb = ChemlabDB()
    na = Molecule([Atom('Na', [0.0, 0.0, 0.0])])
    cl = Molecule([Atom('Cl', [0.0, 0.0, 0.0])])
    wat = cdb.get("molecule", 'gromacs.spce')

    s = random_lattice_box([na, cl, wat], [160, 160, 160], [4, 4, 4])
Example #10
0
def test_molecular_viewer():
    from chemlab.mviewer.qtmolecularviewer import QtMolecularViewer
    from chemlab.mviewer.representations import BallAndStickRepresentation
    cdb = ChemlabDB()

    mol = cdb.get('molecule', 'example.norbornene')
    mol.guess_bonds()
    v = QtMolecularViewer()
    
    v.run()
Example #11
0
def test_molecular_viewer():
    from chemlab.mviewer.qtmolecularviewer import QtMolecularViewer
    from chemlab.mviewer.representations import BallAndStickRepresentation
    cdb = ChemlabDB()

    mol = cdb.get('molecule', 'example.norbornene')
    mol.guess_bonds()
    v = QtMolecularViewer()

    v.run()
Example #12
0
def test_molecular_viewer():
    from chemlab.graphics.qtmolecularviewer import QtMolecularViewer
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile

    cdb = ChemlabDB()

    mol = cdb.get('molecule', 'example.norbornene')

    #mol = datafile('tests/data/3ZJE.pdb').read('system')
    #mol = datafile('tests/data/naclwater.gro').read('system')
    mol.guess_bonds()

    v = QtMolecularViewer(mol)

    v.widget.camera.autozoom(mol.r_array)

    def on_action1():
        if len(v.representation.selection) == 2:
            i, j = v.representation.selection
            distsq = ((mol.r_array[j] - mol.r_array[i])**2).sum()
            print 'distance between', i, j, np.sqrt(distsq)

    def select_all_atoms():
        which = v.representation.selection[0]
        at = mol.type_array[which]
        sel = mol.type_array == at
        v.representation.make_selection(sel.nonzero()[0])

    def select_all_molecules():
        which = v.representation.last_modified
        if which is None:
            return

        at = mol.type_array[which]
        sel = mol.type_array == at
        allmol = mol.atom_to_molecule_indices(sel)
        allmol = mol.mol_to_atom_indices(allmol)
        v.representation.make_selection(allmol, additive=True)

    def change_representation():
        BallAndStickRepresentation = 0
        # We need two representations
        rep = v.add_representation(BallAndStickRepresentation, mol)
        rep.set_mask(self.selection)
        rep.set_mask(not self.selection)

    def scale_radii():
        #v.representation.scale_radii(v.representation.selection, 0.9)
        v.representation.hide(v.representation.selection)

    v.run()
Example #13
0
def test_molecular_viewer():
    from chemlab.graphics.qtmolecularviewer import QtMolecularViewer
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile

    cdb = ChemlabDB()

    mol = cdb.get('molecule', 'example.norbornene')

    #mol = datafile('tests/data/3ZJE.pdb').read('system')
    #mol = datafile('tests/data/naclwater.gro').read('system')
    mol.guess_bonds()

    v = QtMolecularViewer(mol)

    v.widget.camera.autozoom(mol.r_array)

    def on_action1():
        if len(v.representation.selection) == 2:
            i, j = v.representation.selection
            distsq = ((mol.r_array[j] - mol.r_array[i])**2).sum()
            print 'distance between', i, j, np.sqrt(distsq)

    def select_all_atoms():
        which = v.representation.selection[0]
        at = mol.type_array[which]
        sel = mol.type_array == at
        v.representation.make_selection(sel.nonzero()[0])

    def select_all_molecules():
        which = v.representation.last_modified
        if which is None:
            return

        at = mol.type_array[which]
        sel = mol.type_array == at
        allmol = mol.atom_to_molecule_indices(sel)
        allmol = mol.mol_to_atom_indices(allmol)
        v.representation.make_selection(allmol, additive=True)

    def change_representation():
        BallAndStickRepresentation = 0
        # We need two representations
        rep = v.add_representation(BallAndStickRepresentation, mol)
        rep.set_mask(self.selection)
        rep.set_mask(not self.selection)

    def scale_radii():
        #v.representation.scale_radii(v.representation.selection, 0.9)
        v.representation.hide(v.representation.selection)

    v.run()
Example #14
0
def test_molecular_viewer():
    from chemlab.graphics.qtmolecularviewer import QtMolecularViewer
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    
    cdb = ChemlabDB()
    
    mol = cdb.get('molecule', 'example.norbornene')
    
    mol = datafile('tests/data/3ZJE.pdb').read('system')
    v = QtMolecularViewer(mol)
    v.highlight([0, 2, 8])
    v.run()
    
Example #15
0
def test_multiple_post_processing():
    v = QtViewer()
    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    #mol = datafile('/home/gabriele/projects/LiCl/interface/loafintjc-heat/equilibrium.gro').read('system')
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array, 'impostors', shading='toon')

    # Adding multiple post processing effects


    v.add_post_processing(SSAOEffect)
    v.add_post_processing(GammaCorrectionEffect, 2.0)
    #v.add_post_processing(GammaCorrectionEffect, 2.0)
    #v.add_post_processing(FXAAEffect)

    v.run()
Example #16
0
def test_toon_shading():
    from chemlab.core.molecule import guess_bonds

    cdb = ChemlabDB()

    #mol = cdb.get('molecule', 'example.norbornene')

    mol = datafile('tests/data/3ZJE.pdb').read('system')
    v = QtViewer()
    #v.widget.post_processing = FXAAEffect(v.widget)
    #v.widget.post_processing = SSAOEffect(v.widget, kernel_size=64, kernel_radius=1.0, ssao_power=2.0)

    v.widget.camera.autozoom(mol.r_array)
    #sr = v.add_renderer(AtomRenderer, mol.r_array,
    #                    mol.type_array, 'impostors',
    #                    shading='toon')
    #sr = v.add_renderer(AtomRenderer, mol.r_array,
    #                    mol.type_array, 'polygons',
    #                    shading='toon')

    ar = v.add_renderer(BallAndStickRenderer,
                        mol.r_array,
                        mol.type_array,
                        guess_bonds(mol.r_array, mol.type_array),
                        shading='toon')

    v.run()
Example #17
0
def test_pickers():
    from chemlab.graphics.pickers import SpherePicker, CylinderPicker
    from chemlab.core.molecule import guess_bonds
    #mol = datafile('tests/data/benzene.mol').read('molecule')
    mol = ChemlabDB().get('molecule', 'example.water')

    centers = mol.r_array
    radii = np.array([0.05]*mol.n_atoms)
    colors = np.array([[0, 255, 255, 255]]*mol.n_atoms)
    bounds = mol.r_array.take(mol.bonds, axis=0)

    b_radii = np.array([0.05]*mol.n_bonds)
    b_colors = np.array([[0, 255, 255, 255]]*mol.n_bonds)

    v = QtViewer()
    #v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(SphereImpostorRenderer, centers, radii*1.2, colors, transparent=False)
    cr = v.add_renderer(CylinderImpostorRenderer, bounds, b_radii, b_colors)

    sp = SpherePicker(v.widget, centers, radii*1.2)
    cp = CylinderPicker(v.widget, bounds, b_radii)

    def on_click(evt):
        x, y = v.widget.screen_to_normalized(evt.x(), evt.y())
        a_i, a_d = sp.pick(x, y)
        b_i, b_d = cp.pick(x, y)
        print('A', a_d)
        print('B', b_d)

    v.widget.clicked.connect(on_click)

    v.run()
Example #18
0
def test_multiple_post_processing():
    v = QtViewer()
    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    #mol = datafile('/home/gabriele/projects/LiCl/interface/loafintjc-heat/equilibrium.gro').read('system')
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array, 'impostors', shading='toon')

    # Adding multiple post processing effects


    v.add_post_processing(SSAOEffect)
    v.add_post_processing(GammaCorrectionEffect, 2.0)
    #v.add_post_processing(GammaCorrectionEffect, 2.0)
    #v.add_post_processing(FXAAEffect)

    v.run()
Example #19
0
def test_local():
    db = ChemlabDB()
    bz = db.get("molecule", "example.norbornene")

    pre_string = bz.tojson()
    db = LocalDB("/tmp/testdb/")
    db.store("molecule", 'norbornene', bz, nowarn=True)
    
    post_string = db.get('molecule', 'norbornene').tojson()
    assert pre_string == post_string
    
    # Do the same thing for a system of 3 norbornenes
    s = System([bz.copy() for i in range(3)])
    pre_string = s.tojson()
    db.store("system", 'norbornene-3', s, nowarn=True)
    post_string = db.get('system', 'norbornene-3').tojson()
    
    assert pre_string == post_string
Example #20
0
def test_ssao():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    
    cdb = ChemlabDB()
    
    mol = cdb.get('molecule', 'example.norbornene')
    
    mol = datafile('tests/data/3ZJE.pdb').read('system')
    v = QtViewer()
    

    v.widget.camera.autozoom(mol.r_array)
    v.widget.post_processing.append(SSAOEffect(v.widget, kernel_size=16, kernel_radius=3.0, ssao_power=2.7))
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array, 'impostors')
    #ar = v.add_renderer(BallAndStickRenderer, mol.r_array, mol.type_array, [])
    
    v.run()
Example #21
0
def test_local():
    db = ChemlabDB()
    bz = db.get("molecule", "example.norbornene")
    pre_dict = bz.to_dict()

    db = LocalDB("/tmp/testdb/")
    db.store("molecule", 'norbornene', bz, nowarn=True)

    post_dict = db.get('molecule', 'norbornene').to_dict()

    npeq_(pre_dict['r_array'], post_dict['r_array'])

    # Do the same thing for a system of 3 norbornenes
    s = System([bz.copy() for i in range(3)])
    pre_dict = s.to_dict()
    db.store("system", 'norbornene-3', s, nowarn=True)
    post_dict = db.get('system', 'norbornene-3').to_dict()

    npeq_(pre_dict['r_array'], post_dict['r_array'])
Example #22
0
def test_ssao():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile

    cdb = ChemlabDB()

    mol = cdb.get('molecule', 'example.norbornene')

    mol = datafile('tests/data/3ZJE.pdb').read('system')
    v = QtViewer()

    v.widget.camera.autozoom(mol.r_array)
    v.widget.post_processing.append(
        SSAOEffect(v.widget, kernel_size=16, kernel_radius=3.0,
                   ssao_power=2.7))
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array, 'impostors')
    #ar = v.add_renderer(BallAndStickRenderer, mol.r_array, mol.type_array, [])

    v.run()
Example #23
0
def test_outline():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    from chemlab.graphics.postprocessing.outline import OutlineEffect
    
    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    
    mol = datafile('tests/data/3ZJE.pdb').read('system')
    #mol = datafile('tests/data/water.gro').read('system')
    #mol = datafile('tests/data/benzene.mol').read('molecule')
    v = QtViewer()

    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array,
                        'impostors', shading='toon')
    
    v.add_post_processing(OutlineEffect, 'depthonly')
    v.add_post_processing(FXAAEffect)
    v.add_post_processing(GammaCorrectionEffect)
    v.run()
Example #24
0
def test_ssao():
    cdb = ChemlabDB()
    mol = datafile('tests/data/3ZJE.pdb').read('system')
    v = QtViewer()

    v.widget.camera.autozoom(mol.r_array)
    v.widget.post_processing.append(SSAOEffect(v.widget, kernel_size=16,
                                               kernel_radius=3.0, ssao_power=2.7))
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array, 'impostors')
    #ar = v.add_renderer(BallAndStickRenderer, mol.r_array, mol.type_array, [])
    v.widget.camera.orbit_y(90)

    v.run()
Example #25
0
def test_local():
    db = ChemlabDB()
    bz = db.get("molecule", "example.norbornene")
    pre_dict = bz.to_dict()

    db = LocalDB("/tmp/testdb/")
    db.store("molecule", 'norbornene', bz, nowarn=True)
    
    post_dict = db.get('molecule', 'norbornene').to_dict()
    
    npeq_(pre_dict['r_array'], post_dict['r_array'])
    
    # Do the same thing for a system of 3 norbornenes
    s = System([bz.copy() for i in range(3)])
    pre_dict = s.to_dict()
    db.store("system", 'norbornene-3', s, nowarn=True)
    post_dict = db.get('system', 'norbornene-3').to_dict()
    
    npeq_(pre_dict['r_array'], post_dict['r_array'])
Example #26
0
def test_glow():
    from chemlab.db import ChemlabDB, CirDB
    from chemlab.io import datafile
    from chemlab.graphics.postprocessing.glow import GlowEffect
    
    cdb = ChemlabDB()
    mol = cdb.get('molecule', 'example.norbornene')
    #mol = datafile('tests/data/3ZJE.pdb').read('system')

    v = QtViewer()

    colors = np.array([(255, 0, 0, 255)]*mol.n_atoms)
    colors[0][3] = 0
    
    v.widget.camera.autozoom(mol.r_array)
    sr = v.add_renderer(SphereImpostorRenderer, mol.r_array, [0.1]*mol.n_atoms,
                        colors)
    
    v.add_post_processing(GlowEffect)
    #v.add_post_processing(SSAOEffect, ssao_power = 5.0)
    #v.add_post_processing(FXAAEffect)
    #v.add_post_processing(GammaCorrectionEffect)
    v.run()
Example #27
0
def test_gamma():
    cdb = ChemlabDB()

    mol = datafile('tests/data/3ZJE.pdb').read('system')
    v = QtViewer()

    v.widget.camera.autozoom(mol.r_array)
    v.widget.camera.orbit_y(3.14/3)
    sr = v.add_renderer(AtomRenderer, mol.r_array, mol.type_array,
                        'impostors', shading='phong')

    v.add_post_processing(SSAOEffect, ssao_power=4.0)
    v.add_post_processing(GammaCorrectionEffect)
    v.run()
Example #28
0
)
from ....cclib_patch.parser import gausscomparser
from ....cclib_patch.parser import gaussianparser

_types = {
    'gamess': GAMESS,
    'gamessuk': GAMESSUK,
    'gaussian': gaussianparser.Gaussian,
    'gausscom': gausscomparser.Gausscom,
    'jaguar': Jaguar,
    'molpro': Molpro,
    #'nwchem': NWChem,
    'orca': ORCA
}

cdb = ChemlabDB()
symbols = cdb.get('data', 'symbols')


def _create_cclib_handler(type):
    if type not in _types:
        raise FormatNotSupported(type)

    class _Handler(IOHandler):
        def __init__(self, fd, filetype=type):
            super(_Handler, self).__init__(fd)
            self.filetype = filetype
            self.data = _types[filetype](fd, loglevel=logging.ERROR).parse()

        def read(self, feature, *args, **kwargs):
            if feature == 'molecular orbitals':
Example #29
0
import numpy as np

# CJS changed relative paths to chemlab ones
from chemlab.graphics import colors
from chemlab.db import ChemlabDB
from chemlab.graphics.renderers.base import AbstractRenderer
from chemlab.graphics.renderers.sphere import SphereRenderer
from chemlab.graphics.renderers.sphere_imp import SphereImpostorRenderer
from chemlab.graphics.renderers.point import PointRenderer

vdw_dict = ChemlabDB().get("data", 'vdwdict')


class AtomRenderer(AbstractRenderer):
    """Render atoms by using different rendering methods.
    
    **Parameters**
    
    widget:
        The parent QChemlabWidget
    r_array: np.ndarray((NATOMS, 3), dtype=float)
        The atomic coordinate array
    type_array: np.ndarray((NATOMS, 3), dtype=object)
        An array containing all the atomic symbols like `Ar`, `H`, `O`.
        If the atomic type is unknown, use the `Xx` symbol.
    backend: "impostors" | "polygons" | "points"
        You can choose the rendering method between the sphere impostors, 
        polygonal sphere and points.
    
        .. seealso: :py:class:`~chemlab.graphics.renderers.SphereRenderer`
                    :py:class:`~chemlab.graphics.renderers.SphereImpostorRenderer`
Example #30
0
    TriangleRenderer, SphereRenderer, SphereImpostorRenderer, PointRenderer,
    AtomRenderer, BoxRenderer, LineRenderer, CylinderRenderer, BondRenderer,
    BallAndStickRenderer, WireframeRenderer, CylinderImpostorRenderer)

from chemlab.graphics.uis import TextUI

from chemlab.db import ChemlabDB, CirDB
from chemlab.io import datafile

from chemlab.graphics.qttrajectory import QtTrajectoryViewer, format_time
from chemlab.graphics.postprocessing import (SSAOEffect, FXAAEffect,
                                             GammaCorrectionEffect,
                                             OutlineEffect, GlowEffect,
                                             NoEffect)

cdb = ChemlabDB()


def test_triangle_renderer():
    '''To see if we're able to render a triangle'''
    vertices = [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [2.0, 0.0, 0.0]]
    normals = [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [0.0, 0.0, 1.0]]
    colors = [colors.blue] * 3

    v = QtViewer()
    tr = v.add_renderer(TriangleRenderer,
                        vertices,
                        normals,
                        colors,
                        shading='toon')
    v.run()