def __init__(self, systemtype, parent=None):
QtGui.QWidget.__init__(self)
self.ui = MainWindow.Ui_MainWindow()
self.ui.setupUi(self)
self.listMinima = [
self.ui.listWidget,
self.ui.listMinima1,
self.ui.listMinima2,
self.ui.listFrom
]
self.systemtype = systemtype
self.NewSystem()
self.transition=None
#try to load the pymol viewer.
self.usepymol = True
try:
from pymol_viewer import PymolViewer
self.pymolviewer = PymolViewer(self.system.load_coords_pymol)
except (ImportError or NotImplementedError):
self.usepymol = False
#note: glutInit() must be called exactly once. pymol calls it
#during pymol.finish_launching(), so if we call it again it will
#give an error. On the other hand, if we're not using pymol we
#must call it.
from OpenGL.GLUT import glutInit
glutInit()
def start_pyasteroids():
random.seed()
import sys
from OpenGL.GLUT import glutInit
glutInit(sys.argv)
app = QApplication(argv)
# Game state
Player()
# Load the config files in memory
ConfigManager()
# Add the custom fonts to the Qt database
FontManager()
# Creates the window (GLWidget is created there)
win = AsteroidsMainWindow()
# Pop-up the window
win.show()
# Faster processing
try:
import psyco
except:
print 'You currently do not have the Psyco module in your PYTHONPATH.'
print 'It is highly advisable to install it for a much better gaming performance.'
print 'Official site: http://psyco.sourceforge.net/'
# Gives control to Qt
app.exec_()
def glut_context():
from OpenGL.GLUT import glutInit, glutCreateWindow, glutHideWindow
glutInit()
context = glutCreateWindow('Hidden window for OpenGL context')
glutHideWindow()
logger.debug('glut context created')
yield context
def main():
moons = [Moon(pos) for pos in d12_input]
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(800, 800)
glutInitWindowPosition(350, 200)
glutCreateWindow('name')
glClearColor(0., 0., 0., 1.)
glShadeModel(GL_SMOOTH)
glEnable(GL_CULL_FACE)
glEnable(GL_DEPTH_TEST)
glEnable(GL_LIGHTING)
lightZeroPosition = [10., 4., 10., 1.]
lightZeroColor = [0.8, 1.0, 0.8, 1.0]
glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition)
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor)
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1)
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05)
glEnable(GL_LIGHT0)
glutDisplayFunc(lambda: display_scene(moons))
glutTimerFunc(0, timer, 0)
glMatrixMode(GL_PROJECTION)
gluPerspective(40., 1., 1., 40.)
glMatrixMode(GL_MODELVIEW)
gluLookAt(0, -10, 10, 0, 0, 0, 0, 1, 0)
glPushMatrix()
glutMainLoop()
def start_pyasteroids():
random.seed()
import sys
from OpenGL.GLUT import glutInit
glutInit(sys.argv)
app = QApplication(argv)
# Game state
Player()
# Load the config files in memory
ConfigManager()
# Add the custom fonts to the Qt database
FontManager()
# Creates the window (GLWidget is created there)
win = AsteroidsMainWindow()
# Pop-up the window
win.show()
# Faster processing
try:
import psyco
except:
print 'You currently do not have the Psyco module in your PYTHONPATH.'
print 'It is highly advisable to install it for a much better gaming performance.'
print 'Official site: http://psyco.sourceforge.net/'
# Gives control to Qt
app.exec_()
def __init__(self,
title,
width=1024,
height=768,
background_color=color.Smoke):
self.base_width = width
self.base_height = height
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(width, height)
glutInitWindowPosition((self.screen_width - width) // 2,
(self.screen_height - height) // 2)
glutCreateWindow(title)
glutKeyboardFunc(self.handle_key)
glutDisplayFunc(self._draw)
glutIdleFunc(self.handle_idle)
glutMouseFunc(self.handle_mouse)
glutSpecialFunc(self.handle_special_key)
glutReshapeFunc(self.handle_reshape)
glEnable(GL_DEPTH_TEST)
if background_color is not None:
self.fill_color(*color.Smoke, 1.)
def init_interface(self):
""" initialize the window and register the render function """
glutInit()
glutInitWindowSize(640, 480)
glutCreateWindow("3D Modeller")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
glutDisplayFunc(self.render)
def create_window(self, params):
if self.__glut_window is None:
# init GLUT !
pymt_logger.debug('WinGlut: GLUT initialization')
glutInit('')
glutInitDisplayMode(
GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH |
GLUT_MULTISAMPLE | GLUT_STENCIL | GLUT_ACCUM)
# create the window
self.__glut_window = glutCreateWindow('pymt')
# register all callbcaks
glutReshapeFunc(self._glut_reshape)
glutMouseFunc(self._glut_mouse)
glutMotionFunc(self._glut_mouse_motion)
glutKeyboardFunc(self._glut_keyboard)
# update window size
glutShowWindow()
self.size = params['width'], params['height']
if params['fullscreen']:
pymt_logger.debug('WinGlut: Set window to fullscreen mode')
glutFullScreen()
super(MTWindowGlut, self).create_window(params)
def create_window(self, params):
if self.__glut_window is None:
# init GLUT !
pymt_logger.debug('WinGlut: GLUT initialization')
glutInit('')
if 'PYMT_GLUT_UNITTEST' in os.environ:
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE)
else:
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_ALPHA
| GLUT_DEPTH | GLUT_MULTISAMPLE
| GLUT_STENCIL | GLUT_ACCUM)
# create the window
self.__glut_window = glutCreateWindow('pymt')
# register all callbcaks
glutReshapeFunc(self._glut_reshape)
glutMouseFunc(self._glut_mouse)
glutMotionFunc(self._glut_mouse_motion)
glutKeyboardFunc(self._glut_keyboard)
# update window size
glutShowWindow()
self.size = params['width'], params['height']
if params['fullscreen']:
pymt_logger.debug('WinGlut: Set window to fullscreen mode')
glutFullScreen()
super(MTWindowGlut, self).create_window(params)
def init_interface(self):
""" initialize the window and register the render function """
glutInit()
glutInitWindowSize(640, 480)
glutCreateWindow("3D Modeller")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
glutDisplayFunc(self.render)
def init_interface(self):
""" 初始化窗口并注册渲染函数 """
glutInit()
glutInitWindowSize(640, 480)
glutCreateWindow("python-three-body by lovememo")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
#注册窗口渲染函数
glutDisplayFunc(self.render)
def init_interface(self):
""" 初始化窗口并注册渲染函数 """
glutInit()
glutInitWindowSize(640, 480)
glutCreateWindow(b"3D Modeller")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
#注册窗口渲染函数
glutDisplayFunc(self.render)
def __init_display(self):
"""Initialize the viewport with specified size."""
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_ALPHA | GLUT_DEPTH)
glutInitWindowSize(*self.__size)
glutInitWindowPosition(0, 0)
glutInit(sys.argv)
glutCreateWindow(b"Morphable face model")
def init_interface(self):
glutInit()
glutInitWindowSize(640, 480)
glutCreateWindow(b"3D Modeller")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
#register render function
glutDisplayFunc(self.render)
def __init_display(self):
"""Initialize the viewport with specified size."""
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_ALPHA | GLUT_DEPTH)
glutInitWindowSize(*self.__size)
glutInitWindowPosition(0, 0)
glutInit(sys.argv)
glutCreateWindow(b"Morphable face model")
def __init__(self, parent, dataModel, rotation=True, **keywords):
super(Torus5dGLWidget, self).__init__(parent, rotation=rotation)
if not boxfish_glut_initialized:
boxfish_glut_initialzed = True
glutInit()
def kwarg(name, default_value):
setattr(self, name, keywords.get(name, default_value))
self.parent = parent
self.dataModel = None
# Note: axis refers to which axis we're looking down in the 3d torus
# view. The axis we're looking down in the overview (the 4th dimension)
# is the last value in the tuple (w, h, d) for each axis in [0, 1, 2, 3] below
self.axis = 0 # Which axis the display should look down (default A)
self.axis_index = 0 # Which horizontal and veritcal axis (default B, C)
self.axis_map = { 0: [(1,2,3), (1,3,2), (2,3,1)], 1: [(0,2,3), (0,3,2), (2,3,0)], \
2: [(0,1,3), (0,3,1), (1,3,0)], 3: [(0,1,2), (0,2,1), (1,2,0)]}
# Constants for MiniMaps - user cannot modify
self.node_size = 0.2
self.node_pack_factor = 3.5 # How close to each link is (1.5 is .5 box space)
self.gap = 2
# Constants for Main View, user modifies link_width, e-link length (figure out)
self.link_width = 4. # 24
self.link_pack_factor = 1 # 8.4
# self.gap above
self.elink_offset_center_x = 0.5 # 0.7
self.elink_offset_center_y = 0.45 # 0.7
self.elink_offset_diagonal_x = 0.4 # 2.2
self.elink_offset_diagonal_y = 1.5 # 5.55
self.outOfRangeOpacity = 0.07
#self.gap = 10 * self.node_size * self.node_pack_factor # Spacing between successive cylinders
kwarg("default_node_color", (0.2, 0.2, 0.2, 0.3))
kwarg("node_cmap", self.parent.agent.requestScene("nodes").color_map)
kwarg("default_link_color", (0.2, 0.2, 0.2, 0.3))
kwarg("link_cmap", self.parent.agent.requestScene("links").color_map)
# Color map bound changing
self.delta = 0.05
self.lowerBoundLinks = 0.
self.upperBoundLinks = 1.
self.lowerBoundNodes = 0.
self.upperBoundNodes = 1.
# Directions in which coords are laid out on the axes
self.axis_directions = np.array([1, -1, -1])
self.setDataModel(dataModel)
self.clearNodes()
self.clearLinks()
def init(self):
glutInit(sys.argv)
glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE)
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
glutCreateWindow('Main Window')
glutDisplayFunc(self.display)
glutKeyboardFunc(self.keyboard)
glutMainLoop()
def create_display(width=WIDTH, height=HEIGHT) -> int:
glutInit([])
glutInitWindowSize(width, height)
window_id = glutCreateWindow('Test window title')
glutHideWindow()
glViewport(0, 0, width, height)
return window_id
def init_interface(self):
''' 初始化窗口并注册 渲染函数 '''
glutInit()
glutInitWindowSize(640, 480)
glutInitWindowPosition(200, 200)
glutCreateWindow(b"3D Modeller")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
# 注册窗口函数
glutDisplayFunc(self.render)
def _test_for_opengl():
try:
# from OpenGL.GLUT import glutInit
glutInit()
except Exception as e:
print >> sys.stderr, e
print 'failure'
else:
print 'success'
def init():
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(*WINDOW_SIZE)
glutInitWindowPosition(50, 50)
glutCreateWindow("PyGLSnake")
glClearColor(
*(ELEMENT_TYPES[0] + [255])
) #All our colors are 3-ints, this one needs alpha channel too so we just tack it on
gluOrtho2D(0, WINDOW_SIZE[0], WINDOW_SIZE[1], 0)
def run(title='QT Window', simulation=None, trackball=None,
step_callback=None, keyboard_callback=None, cls=PyDartQtWindow):
glutInit(())
app = QtGui.QApplication([title])
w = cls(title, simulation)
w.setTrackball(trackball)
w._step_callback = step_callback
w._keyboard_callback = keyboard_callback
w.show()
app.exec_()
def __init__(self):
GladeWrapper.__init__(self, "plugins/basic/gui.glade", "wi_measurements", "window")
self.window.hide()
self.init_callbacks(self.__class__)
labels_chain2 = ["distances",
"label_12", "distance_12"
]
labels_chain3 = ["angles", "distances_to_line",
"label_23", "distance_23",
"label_123", "angle_123",
"label_1_23", "distance_1_23",
]
labels_chain_only3 = [
"label_12_3", "distance_12_3",
]
labels_chain4 = [
"dihedral_angles", "out_of_plane_angles",
"distances_to_plane", "distances_between_lines",
"label_34", "distance_34",
"label_234", "angle_234",
"label_123_234", "angle_123_234",
"label_12_234", "angle_12_234",
"label_123_34", "angle_123_34",
"label_1_234", "distance_1_234",
"label_123_4", "distance_123_4",
"label_23_4", "distance_23_4",
"label_12_34", "distance_12_34",
]
labels_chain_closed = [
"label_31", "distance_31",
"label_231", "angle_231",
"label_312", "angle_312",
"label_31_2", "distance_31_2",
]
self.init_proxies(
labels_chain2 + labels_chain3 + labels_chain_only3 + labels_chain4 +
labels_chain_closed
)
self.labels_chain2 = [self.__dict__[label] for label in labels_chain2]
self.labels_chain3 = [self.__dict__[label] for label in labels_chain3]
self.labels_chain_only3 = [self.__dict__[label] for label in labels_chain_only3]
self.labels_chain4 = [self.__dict__[label] for label in labels_chain4]
self.labels_chain_closed = [self.__dict__[label] for label in labels_chain_closed]
context.application.action_manager.connect("action-started", self.on_action_started)
context.application.action_manager.connect("action-ends", self.on_action_ended)
context.application.action_manager.connect("action-cancels", self.on_action_ended)
self.model_objects = []
self.points = []
self.vectors = []
glutInit([])
def main(path=None):
glutInit(sys.argv)
if sys.platform == 'darwin':
if not path:
path = dialog()
if not path:
sys.exit(0)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE)
glutInitWindowPosition(0, 0)
glutInitWindowSize(730, 650)
win = glutCreateWindow(b'MIDI Player')
(width, height, img) = read_image(join(dirname(__file__), 'mixer.ppm'))
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
GL_UNSIGNED_BYTE, img)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glMatrixMode(GL_TEXTURE)
glLoadIdentity()
glScale(1 / width, 1 / height, 1)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0, 730, 0, 650, 0, 1)
player = Player(win, path, width, height)
glutDisplayFunc(player.display_func)
glutKeyboardFunc(player.keyboard_func)
glutMouseFunc(player.mouse_func)
glutMotionFunc(player.motion_func)
glutIdleFunc(player.process_events)
submenus = []
for instrument in range(128):
if instrument % 8 == 0:
submenus.append([
families[instrument // 8],
glutCreateMenu(player.change_instrument)
])
glutAddMenuEntry(instruments[instrument].encode('ascii'), instrument)
glutCreateMenu(player.change_instrument)
for family, submenu in submenus:
glutAddSubMenu(family.encode('ascii'), submenu)
glutAttachMenu(GLUT_RIGHT_BUTTON)
glutMainLoop()
def main(path=None):
glutInit(sys.argv)
if sys.platform == 'darwin':
if not path:
path = dialog()
if not path:
sys.exit(0)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE)
glutInitWindowPosition(0, 0)
glutInitWindowSize(730, 650)
win = glutCreateWindow(b'MIDI Player')
(width, height, img) = read_image('mixer.ppm')
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
rbo = c_uint(int(glGenRenderbuffersEXT(1)))
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbo)
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, width, height)
fbo = c_uint(int(glGenFramebuffersEXT(1)))
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, fbo)
glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT,
GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, rbo)
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo)
glClear(GL_COLOR_BUFFER_BIT)
glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, img)
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0)
player = Player(win, path, width, height)
glutDisplayFunc(player.display_func)
glutKeyboardFunc(player.keyboard_func)
glutMouseFunc(player.mouse_func)
glutMotionFunc(player.motion_func)
glutIdleFunc(player.process_events)
submenus = []
for instrument in range(128):
if instrument % 8 == 0:
submenus.append([families[instrument // 8],
glutCreateMenu(player.change_instrument)])
glutAddMenuEntry(instruments[instrument].encode('ascii'), instrument)
glutCreateMenu(player.change_instrument)
for family, submenu in submenus:
glutAddSubMenu(family.encode('ascii'), submenu)
glutAttachMenu(GLUT_RIGHT_BUTTON)
glutMainLoop()
def _verify_glut_init():
# According to the documentation, just checking bool(glutInit) is supposed to be enough
# However on Windows with no GLUT DLL that can still pass, even if calling the method throws a null function error.
if bool(glutInit):
try:
glutInit()
return True
except NullFunctionError as _:
pass
return False
def main(path=None):
glutInit(sys.argv)
if sys.platform == 'darwin':
if not path:
path = dialog()
if not path:
sys.exit(0)
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE)
glutInitWindowPosition(0, 0)
glutInitWindowSize(730, 650)
win = glutCreateWindow(b'MIDI Player')
(width, height, img) = read_image(join(dirname(__file__), 'mixer.ppm'))
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0,
GL_RGB, GL_UNSIGNED_BYTE, img)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
glMatrixMode(GL_TEXTURE)
glLoadIdentity()
glScale(1/width, 1/height, 1)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glOrtho(0, 730, 0, 650, 0, 1)
player = Player(win, path, width, height)
glutDisplayFunc(player.display_func)
glutKeyboardFunc(player.keyboard_func)
glutMouseFunc(player.mouse_func)
glutMotionFunc(player.motion_func)
glutIdleFunc(player.process_events)
submenus = []
for instrument in range(128):
if instrument % 8 == 0:
submenus.append([families[instrument // 8],
glutCreateMenu(player.change_instrument)])
glutAddMenuEntry(instruments[instrument].encode('ascii'), instrument)
glutCreateMenu(player.change_instrument)
for family, submenu in submenus:
glutAddSubMenu(family.encode('ascii'), submenu)
glutAttachMenu(GLUT_RIGHT_BUTTON)
glutMainLoop()
def main():
from OpenGL.GLUT import glutInit, glutInitDisplayMode, GLUT_DOUBLE, GLUT_RGBA
from ModelViewWindow import GLUTWindow, View
glutInit()
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA)
#TODO -------- COPY CODE FROM LSystem.py ----------
''' Replace the following L-system speicfication with the one you did
in LSystem.py '''
# L-system specification
TorchPlant = {'init' : 'X',
'rule' : 'X->F-[[X]+X]+F[+FXL]-XL;F->FF',
'depth': 5, 'angle': 25, 'growth_factor': .5,
'init_angle_axis':{'angle':90, 'axis': [0, 0, 1]},
}
'''
ModelList is a convenient way to add all the models with their position
in a python list of dictionaries which can be used by the GardenScene class.
NOTE that using this is optional. If you want you can add all the transformation
code in GardenScene.draw_scene()
'''
ModelList = [{'pos':[0, 0, 0], 'model': LSystem(TorchPlant)},
]
#--------------------------------------------------
#TODO ---------------- BEGIN SOLUTION -----------------
'''
Represent the terrain using a Bicubic patch. Replace the
control points below with the control points for your terrain.
'''
control_points = np.zeros((16, 3))
control_points[:,0] = np.transpose([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3])
control_points[:,1] = np.transpose([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3])
control_points[:,2] = np.transpose([0, 2, 2, 3, 0, 2, 2, 3, 0, 2, 2, 3, 0, 2, 2, 3])
BCPatch = BicubicPatch(control_points)
# ------------ END SOLUTION ------------------------
# main camera
cam_spec = {'eye' : [0, 4.5, 4], 'center' : [0, 2, 0], 'up' : [0, 1, 0],
'fovy': 40, 'aspect': 1.0, 'near' : 0.1, 'far' : 100.0}
cam = FlythroughCamera(GardenScene(BCPatch, ModelList),
cam_spec, HermiteCurve())
GLUTWindow('Garden Scene', cam, window_size = (640 * 1.2, 480), window_pos = (320, 0))
# external camera
cam_spec2 = {'eye' : [5, 5, 5], 'center' : [0, 1, 0], 'up' : [0, 1, 0],
'fovy': 60, 'aspect': 1.0, 'near' : 0.1, 'far' : 200.0}
external_cam = View(cam, cam_spec2)
GLUTWindow("External Camera View", external_cam, window_size = (640 * 1.2, 480), window_pos = (320, 520))
glutMainLoop()
def init_opengl(self, width, height, x, y):
glutInit()
glutInitWindowPosition(x, y)
glutInitWindowSize(width, height)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE)
glutCreateWindow("Rainbow Alga")
glutDisplayFunc(self.render)
glutIdleFunc(self.render)
glutReshapeFunc(self.resize)
glutMouseFunc(self.mouse)
glutMotionFunc(self.drag)
glutKeyboardFunc(self.keyboard)
glutSpecialFunc(self.special_keyboard)
glClearDepth(1.0)
glClearColor(0.0, 0.0, 0.0, 0.0)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 3000)
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT)
# Lighting
light_ambient = (0.0, 0.0, 0.0, 1.0)
light_diffuse = (1.0, 1.0, 1.0, 1.0)
light_specular = (1.0, 1.0, 1.0, 1.0)
light_position = (-100.0, 100.0, 100.0, 0.0)
mat_ambient = (0.7, 0.7, 0.7, 1.0)
mat_diffuse = (0.8, 0.8, 0.8, 1.0)
mat_specular = (1.0, 1.0, 1.0, 1.0)
high_shininess = (100)
glEnable(GL_LIGHT0)
glEnable(GL_NORMALIZE)
glEnable(GL_COLOR_MATERIAL)
glEnable(GL_LIGHTING)
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient)
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse)
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular)
glLightfv(GL_LIGHT0, GL_POSITION, light_position)
glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient)
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse)
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular)
glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess)
# Transparency
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
def create_window(winname, size=(800, 600), display=None, resize=None):
glutInit(argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(size[0], size[1])
glutCreateWindow(winname.encode('ascii'))
if display is not None:
display_func = _display_wrapper(display)
glutDisplayFunc(display_func)
glutIdleFunc(display_func)
if resize is not None:
glutReshapeFunc(resize)
def run():
global window
glutInit(sys.argv)
# Select type of Display mode:
# Double buffer
# RGBA color
# Alpha components supported
# Depth buffer
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
# get a 640 x 480 window
resolution = get_state()["camera"]["resolution"]
glutInitWindowSize(int(resolution[0]), int(resolution[1]))
# the window starts at the upper left corner of the screen
glutInitWindowPosition(0, 0)
# Okay, like the C version we retain the window id to use when closing, but for those of you new
# to Python (like myself), remember this assignment would make the variable local and not global
# if it weren't for the global declaration at the start of main.
window = glutCreateWindow("Waffle")
# Register the drawing function with glut, BUT in Python land, at least using PyOpenGL, we need to
# set the function pointer and invoke a function to actually register the callback, otherwise it
# would be very much like the C version of the code.
glutDisplayFunc(DrawGLScene)
# Uncomment this line to get full screen.
# glutFullScreen()
# When we are doing nothing, redraw the scene.
glutIdleFunc(idleFunc)
# Register the function called when our window is resized.
glutReshapeFunc(ReSizeGLScene)
# Register the function called when the keyboard is pressed.
glutKeyboardFunc(keyDown)
glutKeyboardUpFunc(keyUp)
glutMouseFunc(onMouseClick)
glutMotionFunc(onMouseClickMove)
glutPassiveMotionFunc(onMouseMove)
# Initialize our window.
InitGL()
init_world()
init_interface()
# Start Event Processing Engine
glutMainLoop()
def ContextMainLoop(cls, *args, **named):
"""Mainloop for the GLUT testing context"""
from OpenGL.GLUT import glutInit, glutMainLoop
# initialize GLUT windowing system
import sys
try:
glutInit(sys.argv)
except TypeError:
glutInit(' '.join(sys.argv))
render = cls(*args, **named)
if hasattr(render, 'createMenus'):
render.createMenus()
return glutMainLoop()
def run(title='QT Window',
simulation=None,
trackball=None,
step_callback=None,
keyboard_callback=None,
cls=PyDartQtWindow):
glutInit(())
app = QtGui.QApplication([title])
w = cls(title, simulation)
w.setTrackball(trackball)
w._step_callback = step_callback
w._keyboard_callback = keyboard_callback
w.show()
app.exec_()
def test():
from OpenGL.GLUT import glutInit
import sys
import pylab as pl
app = QtGui.QApplication(sys.argv)
from pele.systems import LJCluster
pl.ion()
natoms = 13
system = LJCluster(natoms)
system.params.double_ended_connect.local_connect_params.NEBparams.iter_density = 5.
dbname = "lj%dtest.db" % (natoms,)
db = system.create_database(dbname)
#get some minima
if False:
bh = system.get_basinhopping(database=db)
bh.run(10)
minima = db.minima()
else:
x1, e1 = system.get_random_minimized_configuration()[:2]
x2, e2 = system.get_random_minimized_configuration()[:2]
min1 = db.addMinimum(e1, x1)
min2 = db.addMinimum(e2, x2)
minima = [min1, min2]
# connect some of the minima
nmax = min(3, len(minima))
m1 = minima[0]
for m2 in minima[1:nmax]:
connect = system.get_double_ended_connect(m1, m2, db)
connect.connect()
if True:
from pele.thermodynamics import get_thermodynamic_information
get_thermodynamic_information(system, db, nproc=4)
wnd = GraphViewDialog(db, app=app)
# decrunner = DECRunner(system, db, min1, min2, outstream=wnd.textEdit_writer)
glutInit()
wnd.show()
from PyQt4.QtCore import QTimer
def start():
wnd.start()
QTimer.singleShot(10, start)
sys.exit(app.exec_())
def test():
from OpenGL.GLUT import glutInit
import sys
import pylab as pl
app = QtGui.QApplication(sys.argv)
from pele.systems import LJCluster
pl.ion()
natoms = 13
system = LJCluster(natoms)
system.params.double_ended_connect.local_connect_params.NEBparams.iter_density = 5.
dbname = "lj%dtest.db" % (natoms,)
db = system.create_database(dbname)
#get some minima
if False:
bh = system.get_basinhopping(database=db)
bh.run(10)
minima = db.minima()
else:
x1, e1 = system.get_random_minimized_configuration()[:2]
x2, e2 = system.get_random_minimized_configuration()[:2]
min1 = db.addMinimum(e1, x1)
min2 = db.addMinimum(e2, x2)
minima = [min1, min2]
# connect some of the minima
nmax = min(3, len(minima))
m1 = minima[0]
for m2 in minima[1:nmax]:
connect = system.get_double_ended_connect(m1, m2, db)
connect.connect()
if True:
from pele.thermodynamics import get_thermodynamic_information
get_thermodynamic_information(system, db, nproc=4)
wnd = GraphViewDialog(db, app=app)
# decrunner = DECRunner(system, db, min1, min2, outstream=wnd.textEdit_writer)
glutInit()
wnd.show()
from PyQt4.QtCore import QTimer
def start():
wnd.start()
QTimer.singleShot(10, start)
sys.exit(app.exec_())
def ContextMainLoop( cls, *args, **named ):
"""Mainloop for the GLUT testing context"""
from OpenGL.GLUT import glutInit, glutMainLoop
# initialize GLUT windowing system
import sys
try:
glutInit( sys.argv)
except TypeError:
import string
glutInit( ' '.join(sys.argv))
render = cls( *args, **named)
if hasattr( render, 'createMenus' ):
render.createMenus()
return glutMainLoop()
def _initGL(self, extraArgs):
"""initializes OpenGL and creates the Window"""
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
glutInitWindowSize(self.size, self.size)
glutInitWindowPosition(self.initx, self.inity)
glutInit(extraArgs.split(" "))
glutCreateWindow(VERSIONSTRING.encode("ascii"))
glutDisplayFunc(self.Draw)
glutIdleFunc(glutPostRedisplay)
glutReshapeFunc(self.Reshape)
glutKeyboardFunc(self.HandleKeys)
glutSpecialFunc(self.HandleKeys)
glutMouseFunc(self.HandleMouse)
glClearColor(*(self.bgcolor + [0.0]))
glEnable(GL_LINE_SMOOTH)
glLineWidth(1.3)
def init(self, hide_window):
# Shift from ARGB to RGBA
self.color_palette = [((x << 8) & 0xFFFFFFFF) | 0x000000FF
for x in self.color_palette]
self.alphamask = 0x000000FF
self.color_format = u"RGB"
self.buffer_dims = (144, 160)
if not glutInit():
raise Exception("OpenGL couldn't initialize!")
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self._scale, self._scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
if hide_window:
logger.warning("Hiding the window is not supported in OpenGL")
def main(argv):
if len(argv) > 2:
# Start a remote window
MeshViewerRemote(
titlebar=argv[1], subwins_vert=int(argv[2]),
subwins_horz=int(argv[3]), width=int(argv[4]), height=int(argv[5])
)
elif len(argv) == 2:
# Just a test for opengl working
try:
from OpenGL.GLUT import glutInit
glutInit()
except Exception as e: # pylint: disable=broad-except
print >>sys.stderr, e
print 'failure'
else:
print 'success'
def __init__(self, app, systemtype, parent=None):
QtGui.QWidget.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.systemtype = systemtype
self.transition = None
self.app = app
self.double_ended_connect_runs = []
self.pick_count = 0
self.minima_selection = MySelection()
self.on_minimum_1_selected = Signal()
self.on_minimum_2_selected = Signal()
# set up the list manager
self.list_manager = ListViewManager(self)
# define the system
self.NewSystem()
# finish setting up the list manager (this must be done after NewSystem() is called)
self.list_manager.finish_setup()
# try to load the pymol viewer.
try:
self.usepymol = self.system.params.gui.use_pymol
except (KeyError, AttributeError):
self.usepymol = config.getboolean("gui", "use_pymol")
if self.usepymol:
try:
from pymol_viewer import PymolViewer
self.pymolviewer = PymolViewer(self.system.load_coords_pymol)
except (ImportError or NotImplementedError):
self.usepymol = False
if self.usepymol == False:
# note: glutInit() must be called exactly once. pymol calls it
# during pymol.finish_launching(), so if we call it again it will
# give an error. On the other hand, if we're not using pymol we
# must call it.
from OpenGL.GLUT import glutInit
glutInit()
self.bhmanager = None
def show_OpenGL(csg):
if not _have_OpenGL:
raise RuntimeError("PyOpenGL not available")
renderable = TestRenderable(csg)
glutInit()
glutInitWindowSize(640, 480)
renderable.win_id = glutCreateWindow("CSG Test")
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_CONTINUE_EXECUTION)
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
glutDisplayFunc(renderable.display)
glutKeyboardFunc(renderable.keypress)
glutSpecialFunc(renderable.special_keypress)
renderable.init()
glutMainLoop()
def __init__(self, app, systemtype, parent=None):
QtGui.QWidget.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.systemtype = systemtype
self.transition = None
self.app = app
self.double_ended_connect_runs = []
self.pick_count = 0
self.minima_selection = MySelection()
self.on_minimum_1_selected = Signal()
self.on_minimum_2_selected = Signal()
# set up the list manager
self.list_manager = ListViewManager(self)
# define the system
self.NewSystem()
# finish setting up the list manager (this must be done after NewSystem() is called)
self.list_manager.finish_setup()
# try to load the pymol viewer.
try:
self.usepymol = self.system.params.gui.use_pymol
except (KeyError, AttributeError):
self.usepymol = config.getboolean("gui", "use_pymol")
if self.usepymol:
try:
from .pymol_viewer import PymolViewer
self.pymolviewer = PymolViewer(self.system.load_coords_pymol)
except (ImportError or NotImplementedError):
self.usepymol = False
if not self.usepymol:
# note: glutInit() must be called exactly once. pymol calls it
# during pymol.finish_launching(), so if we call it again it will
# give an error. On the other hand, if we're not using pymol we
# must call it.
from OpenGL.GLUT import glutInit
glutInit()
self.bhmanager = None
def main():
global texture
print bool(glutInit)
glutInit(sys.argv)
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(500, 500)
glutInitWindowPosition(0, 0)
glutCreateWindow("Simple PyOpenGL example")
glutDisplayFunc(display)
# glutIdleFunc(animate)
glutReshapeFunc(reshape)
glutKeyboardFunc(keyPressed)
init()
texture = loadTexture("Results\\EmptyInterface.png")
glutMainLoop()
def init(self):
# Shift from ARGB to RGBA
self.color_palette = [((x << 8) & 0xFFFFFFFF) | 0x000000FF for x in self.color_palette]
self.alphamask = 0x000000FF
self.color_format = u"RGB"
glutInit()
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self._scale, self._scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
def __init__(self, app, system, nested_sampling):
QtGui.QWidget.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.app = app
self.system = system
self.nested_sampling = nested_sampling
self.show3d = self.ui.show3d
self.ui.show3d.setSystem(system)
self.update_list()
from OpenGL.GLUT import glutInit
glutInit()
self.selected = None
self.Emax = max([r.energy for r in self.nested_sampling.replicas])
def __init__(self, app, system, nested_sampling):
QtGui.QWidget.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.app = app
self.system = system
self.nested_sampling = nested_sampling
self.show3d = self.ui.show3d
self.ui.show3d.setSystem(system)
self.update_list()
from OpenGL.GLUT import glutInit
glutInit()
self.selected = None
self.Emax = max([r.energy for r in self.nested_sampling.replicas])
def main():
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE)
glutInitWindowSize(800, 600)
glutInitWindowPosition(100, 100)
glutCreateWindow('Particle System')
fountains = Context()
glutDisplayFunc(fountains.display)
glutReshapeFunc(fountains.reshape)
glEnable(GL_POINT_SMOOTH)
glutMainLoop()
def init(self):
# Shift from ARGB to RGBA
self.color_palette = [((x << 8) & 0xFFFFFFFF) | 0x000000FF
for x in self.color_palette]
self.alphamask = 0x000000FF
self.color_format = u"RGB"
glutInit()
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
glutInitWindowSize(*self._scaledresolution)
glutCreateWindow("PyBoy")
glutKeyboardFunc(self._key)
glutKeyboardUpFunc(self._keyUp)
glutSpecialFunc(self._spec)
glutSpecialUpFunc(self._specUp)
self.events = []
glPixelZoom(self._scale, self._scale)
glutReshapeFunc(self._glreshape)
glutDisplayFunc(self._gldraw)
def main():
from OpenGL.GLUT import glutInit, glutInitDisplayMode, \
glutMainLoop, GLUT_DOUBLE, GLUT_RGBA
from ModelViewWindow import View, GLUTWindow
glutInit()
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA)
cam_spec = {'eye' : [2, 2, 2], 'center' : [0, 0, 0], 'up' : [0, 1, 0],
'fovy': 30, 'aspect': 1.0, 'near' : 0.01, 'far' : 200.0}
data_points = np.zeros((16, 3))
data_points[:,0] = np.transpose([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3])
data_points[:,1] = np.transpose([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3])
data_points[:,2] = np.transpose([0, -2, 2, -3, 0, -2, 2, -3, 0, -2, 2, -3, 0, -2, 2, -3])
BCPatch = BicubicPatch(data_points)
cam = View(BCPatch, cam_spec)
GLUTWindow('Bicubic Patch', cam, window_size = (512, 512), window_pos =(520, 0))
glutMainLoop()
def __init__ (self, definition = None, **named ):
# set up double buffering and rgb display mode
if definition is None:
definition = contextdefinition.ContextDefinition( **named )
else:
for key,value in named.items():
setattr( definition, key, value )
self.contextDefinition = definition
glutInitDisplayMode( self.glutFlagsFromDefinition( definition ) )
glutInit([])
if glutInitContextVersion and definition.version[0]:
glutInitContextVersion(*definition.version)
if glutInitContextProfile and definition.profile == 'core':
glutInitContextProfile(GLUT_CORE_PROFILE)
glutInitDisplayMode( self.DISPLAYMODE )
# set up window size for newly created windows
apply ( glutInitWindowSize, [int(i) for i in definition.size] )
# create a new rendering window
self.windowID = glutCreateWindow(
definition.title or
self.getApplicationName()
)
Context.__init__ (self, definition)
import struct
import sys
import ModernGL
from OpenGL.GLUT import (
GLUT_DEPTH, GLUT_DOUBLE, GLUT_RGB, glutCreateWindow, glutDisplayFunc, glutIdleFunc, glutInit, glutInitDisplayMode,
glutInitWindowSize, glutMainLoop, glutSwapBuffers
)
width, height = 1280, 720
glutInit(sys.argv)
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
glutInitWindowSize(width, height)
glutCreateWindow(b'')
ctx = ModernGL.create_context()
prog = ctx.program(
ctx.vertex_shader('''
#version 330
uniform vec2 WindowSize;
in vec2 in_vert;
in vec3 in_color;
out vec3 v_color;
void main() {
v_color = in_color;
def main():
from OpenGL.GLUT import glutInit, glutInitDisplayMode, GLUT_DOUBLE, GLUT_RGBA
from ModelViewWindow import GLUTWindow, View
glutInit()
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA)
#TODO -------- COPY CODE FROM LSystem.py ----------
''' Replace the following L-system speicfication with the one you did
in LSystem.py '''
# L-system specification
Tree1 = {'init' : 'X',
'rule' : 'X->F[+yX][++PX][-YX]FX;F->FF', # modified from Algorithmic Botany, p.25
'depth' : 7, 'angle': 25.7, 'growth_factor': .53, 'XZScale': 2,
'init_angle_axis': {'angle':90, 'axis':[0, 0, 1]},
}
Tree2 = {'init' : 'X',
'rule' : 'X->wFL[RX][rX[pX]X]X[YX][yX];F->FWF', # adapted from Algorithmic Botany, p.24 + Tree3D
'depth' : 4, 'angle': 22.5, 'growth_factor': .6,
'init_angle_axis': {'angle':90, 'axis': [0, 0, 1]},
}
Tree3 = {'init' : 'X',
'rule' : 'X->BLr[[XL]RyXXL]pBL[PBX]YXL;B->BB', # adapted from Algorithmic Botany, p.25
'depth': 4, 'angle': 22.5, 'growth_factor': .55,
'init_angle_axis':{'angle':90, 'axis':[0, 0, 1]},
}
'''
ModelList is a convenient way to add all the models with their position
in a python list of dictionaries which can be used by the GardenScene class.
NOTE that using this is optional. If you want you can add all the transformation
code in GardenScene.draw_scene()
'''
ModelList = [{'pos':[0, 0, 0], 'model': LSystem(Tree1)},
{'pos': [0, 0, 0], 'model': LSystem(Tree2)},
{'pos': [0, 0, 0], 'model' :LSystem(Tree3)}
]
#--------------------------------------------------
#TODO ---------------- BEGIN SOLUTION -----------------
'''
Represent the terrain using a Bicubic patch. Replace the
control points below with the control points for your terrain.
'''
control_points = np.zeros((16, 3))
# uniform grid with different ranges, as asked
# note grid is on xz plane, and y gets height values
control_points[:,0] = np.transpose([0, 0, 0, 0, 2, 2, 2, 2, 4, 4, 4, 4, 6, 6, 6, 6])
control_points[:,2] = np.transpose([1, 2, 4, 6, 0, 2, 4, 6, 0, 2, 4, 6, 0, 2, 4, 6])
control_points[:,1] = np.transpose([-1, 0, 2, 1, 1, 1, 0, 0, 0, 2, 3, 1, -1, 0, 1, -1])
BCPatch = BicubicPatch(control_points)
# ------------ END SOLUTION ------------------------
# main camera
cam_spec = {'eye' : [0, 4.5, 4], 'center' : [0, 2, 0], 'up' : [0, 1, 0],
'fovy': 40, 'aspect': 1.0, 'near' : 0.1, 'far' : 100.0}
cam = FlythroughCamera(GardenScene(BCPatch, ModelList),
cam_spec, HermiteCurve())
GLUTWindow('Garden Scene', cam, window_size = (640 * 1.2, 480), window_pos = (320, 0))
# external camera
cam_spec2 = {'eye' : [5, 5, 5], 'center' : [0, 1, 0], 'up' : [0, 1, 0],
'fovy': 60, 'aspect': 1.0, 'near' : 0.1, 'far' : 200.0}
external_cam = View(cam, cam_spec2)
GLUTWindow("External Camera View", external_cam, window_size = (640 * 1.2, 480), window_pos = (320, 520))
glutMainLoop()
def process_events():
app.processEvents()
#setup system
natoms = 13
system = LJCluster(natoms)
system.params.double_ended_connect.local_connect_params.NEBparams.iter_density = 10.
system.params.double_ended_connect.local_connect_params.NEBparams.image_density = 3.
# system.params.double_ended_connect.local_connect_params.NEBparams.adaptive_nimages = 5.
system.params.double_ended_connect.local_connect_params.NEBparams.reinterpolate = 400
system.params.double_ended_connect.local_connect_params.NEBparams.max_images = 40
x1, e1 = system.get_random_minimized_configuration()[:2]
x2, e2 = system.get_random_minimized_configuration()[:2]
db = Database()
min1 = db.addMinimum(e1, x1)
min2 = db.addMinimum(e2, x2)
#setup neb dialog
wnd = ConnectExplorerDialog(system, app)
wnd.show()
glutInit()
#initilize the NEB and run it.
#we have to do it through QTimer because the gui has to
#be intitialized first... I don't really understand it
from PyQt4.QtCore import QTimer
QTimer.singleShot(10, start)
sys.exit(app.exec_())
def __init__(self, parent, dataModel, rotation = True, **keywords):
super(Torus5dGLWidget, self).__init__(parent, rotation = rotation)
if not boxfish_glut_initialized:
boxfish_glut_initialzed = True
glutInit()
def kwarg(name, default_value):
setattr(self, name, keywords.get(name, default_value))
self.parent = parent
self.dataModel = None
# Note: axis refers to which axis we're looking down in the 3d torus
# view. The axis we're looking down in the overview (the 4th dimension)
# is the last value in the tuple (w, h, d) for each axis in [0, 1, 2, 3] below
self.axis = 0 # Which axis the display should look down (default A)
self.axis_index = 0 # Which horizontal and veritcal axis (default B, C)
self.axis_map = { 0: [(1,2,3), (1,3,2), (2,3,1)], 1: [(0,2,3), (0,3,2), (2,3,0)], \
2: [(0,1,3), (0,3,1), (1,3,0)], 3: [(0,1,2), (0,2,1), (1,2,0)]}
# Constants for MiniMaps - user cannot modify
self.node_size = 0.2
self.node_pack_factor = 3.5 # How close to each link is (1.5 is .5 box space)
self.gap = 2
# Constants for Main View, user modifies link_width, e-link length (figure out)
self.link_width = 4. # 24
self.link_pack_factor = 1 # 8.4
# self.gap above
self.elink_offset_center_x = 0.5 # 0.7
self.elink_offset_center_y = 0.45 # 0.7
self.elink_offset_diagonal_x = 0.4 # 2.2
self.elink_offset_diagonal_y = 1.5 # 5.55
self.outOfRangeOpacity = 0.07
#self.gap = 10 * self.node_size * self.node_pack_factor # Spacing between successive cylinders
kwarg("default_node_color", (0.2, 0.2, 0.2, 0.3))
kwarg("node_cmap", self.parent.agent.requestScene("nodes").color_map)
kwarg("default_link_color", (0.2, 0.2, 0.2, 0.3))
kwarg("link_cmap", self.parent.agent.requestScene("links").color_map)
# Color map bound changing
self.delta = 0.05
self.lowerBoundLinks = 0.
self.upperBoundLinks = 1.
self.lowerBoundNodes = 0.
self.upperBoundNodes = 1.
# Directions in which coords are laid out on the axes
self.axis_directions = np.array([1, -1, -1])
self.setDataModel(dataModel)
self.clearNodes()
self.clearLinks()
""" By importing this module you agree to call glutInit """ from OpenGL.GLUT import glutInit from sys import argv glutInit(argv)
