def __init__(self, sim):
super().__init__(sim)
self.key_pressed = None
self.custom_text = None
self.prog_info = None
glfw.set_window_size(self.window, 840, 680)
def _set_logical_size(self):
# There is unclarity about the window size in "screen pixels".
# It appears that on Windows and X11 its the same as the
# framebuffer size, and on macOS it's logical pixels.
# See https://github.com/glfw/glfw/issues/845
# Here, we simply do a quick test so we can compensate.
# The target logical size
lsize = self._logical_size
pixel_ratio = glfw.get_window_content_scale(self._window)[0]
# The current screen size and physical size, and its ratio
ssize = glfw.get_window_size(self._window)
psize = glfw.get_framebuffer_size(self._window)
# Apply
if is_wayland:
# Not sure why, but on Wayland things work differently
screen_ratio = ssize[0] / lsize[0]
glfw.set_window_size(
self._window,
int(lsize[0] / screen_ratio),
int(lsize[1] / screen_ratio),
)
else:
screen_ratio = ssize[0] / psize[0]
glfw.set_window_size(
self._window,
int(lsize[0] * pixel_ratio / screen_ratio),
int(lsize[1] * pixel_ratio / screen_ratio),
)
def __init__(self, parent, monitor):
self.parent = parent
self.monitor = monitor
self.running = True
self.modman = ModuleManager()
self.currentSheet = None
self.sheetObjects = {}
self.subsheets = {}
self.miscdata = {} # Special cases are ~fun~! (The f stands for "FUUUCK why did I do this?!")
self.videomode = glfw.get_video_mode(monitor)
self.window = glfw.create_window(100, 100, "Hello World", monitor, None)
#self.window = glfw.create_window(100, 100, "Hello World", None, None)
if not self.window:
raise Exception("Creating window failed")
glfw.set_window_size(self.window, self.videomode[0][0], self.videomode[0][1])
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.set_framebuffer_size_callback(self.window, self.framebufferSizeCallback)
self.deltatime = 0
self.time = glfw.get_time()
self.beatlow = False
self.beatmid = False
self.beathigh = False
self.bpm = 0
def render(self, mode: RenderMode = RenderMode(), render_step: int = 1):
if self._curr_step % render_step == 0:
# Call base class
super().render(mode)
# Print to console
if mode.text:
print(
f"step: {self._curr_step:4d} | r_t: {self._curr_rew: 1.3f} | a_t: {self._curr_act} | s_t+1: {self.state}"
)
# Forward to MuJoCo viewer
if mode.video:
if self.viewer is None:
# Create viewer if not existent (see 'human' mode of OpenAI Gym's MujocoEnv)
self.viewer = mujoco_py.MjViewer(self.sim)
# Adjust window size and position to custom values
import glfw
glfw.make_context_current(self.viewer.window)
glfw.set_window_size(self.viewer.window, 1280, 720)
glfw.set_window_pos(self.viewer.window, 50, 50)
self.configure_viewer()
self.viewer.render()
def loadImgFromArray(self, img=None):
self.img = img.copy()
self.img_height, self.img_width, self.channels = self.img.shape
self.numLevels = 1 + math.floor(
math.log2(max(self.img_width, self.img_height)))
if self.visualize:
glfw.set_window_size(self.window, self.img_width, self.img_height)
#self.updateTexture()
gazePosition = self.gazePosition
if gazePosition[0] < 0:
gazePosition = (self.img_height / 2, self.img_width / 2)
x, step = np.linspace(0,
self.img_height - 1,
num=self.img_height,
retstep=True,
dtype=np.float32)
y, step = np.linspace(0,
self.img_width - 1,
num=self.img_width,
retstep=True,
dtype=np.float32)
self.ix, self.iy = np.meshgrid(y, x, sparse=False, indexing='xy')
self.updateGaze(gazePosition)
self.updateTexture()
def loadImgFromArray(self, img=None):
self.img = img.copy()
self.img_width, self.img_height = self.img.size
self.numLevels = 1 + math.floor(
math.log2(max(self.img_width, self.img_height)))
if self.visualize:
glfw.set_window_size(self.window, self.img_width, self.img_height)
#self.updateTexture()
if self.gazePosition[0] < 0:
self.gazePosition = (self.img_height / 2, self.img_width / 2)
#self.updateGaze(gazePosition)
x, step = np.linspace(0,
self.img_height - 1,
num=self.img_height,
retstep=True,
dtype=np.float32)
y, step = np.linspace(0,
self.img_width - 1,
num=self.img_width,
retstep=True,
dtype=np.float32)
self.ix, self.iy = np.meshgrid(y, x, sparse=False, indexing='xy')
self.dotPitch = computeDotPitch(pix2deg=self.pix2deg,
viewDist=self.viewDist,
imgWidth=self.img_width)
self.updateGaze(gazePosition)
self.updateTexture()
def loadImgFromFile(self, imgFilename='images/Yarbus_scaled.jpg'):
self.img = cv2.imread(imgFilename)
self.img_height, self.img_width, self.channels = self.img.shape
self.numLevels = 1 + math.floor(
math.log2(max(self.img_width, self.img_height)))
if self.visualize:
glfw.set_window_size(self.window, self.img_width, self.img_height)
if self.gazePosition[0] < 0:
gazePosition = (self.img_height / 2, self.img_width / 2)
else:
gazePosition = self.gazePosition
x, step = np.linspace(0,
self.img_height - 1,
num=self.img_height,
retstep=True,
dtype=np.float32)
y, step = np.linspace(0,
self.img_width - 1,
num=self.img_width,
retstep=True,
dtype=np.float32)
self.ix, self.iy = np.meshgrid(y, x, sparse=False, indexing='xy')
#self.dotPitch = computeDotPitch(pix2deg=self.pix2deg, viewDist=self.viewDist, imgWidth=self.img_width)
self.updateGaze(gazePosition)
self.updateTexture()
def morph_2D_mesh(self, H, W, points_coord, points_text_coord, triangles):
glfw.set_window_size(self.window, W, H)
self.__draw_2d_mesh(H, W, points_coord, points_text_coord, triangles)
image_buffer = glReadPixels(0, 0, W, H, OpenGL.GL.GL_RGB,
OpenGL.GL.GL_UNSIGNED_BYTE)
image = numpy.frombuffer(image_buffer,
dtype=numpy.uint8).reshape(H, W, 3)
return image[:H, :W]
def get_image(self, image):
width, height = image.shape[1], image.shape[0]
glfw.set_window_size(self.window, width, height)
self.__draw_image(image)
image_buffer = glReadPixels(0, 0, width, height, OpenGL.GL.GL_RGB,
OpenGL.GL.GL_UNSIGNED_BYTE)
image = numpy.frombuffer(image_buffer,
dtype=numpy.uint8).reshape(height, width, 3)
return image
def loadImgFromArray(self, img=None):
self.img = img.copy()
self.img_width, self.img_height = self.img.size
if self.visualize:
glfw.set_window_size(self.window, self.img_width, self.img_height)
self.updateTexture()
if self.gazePosition[0] < 0:
self.gazePosition = (self.img_height / 2, self.img_width / 2)
self.updateGaze(gazeRadius, gazePosition)
def activate(self, width, height):
"""Called when entering the `make_current` context manager.
Args:
width: Integer specifying the new framebuffer width in pixels.
height: Integer specifying the new framebuffer height in pixels.
"""
self._previous_context = glfw.get_current_context()
glfw.make_context_current(self._context)
if (width, height) != glfw.get_window_size(self._context):
glfw.set_window_size(self._context, width, height)
def on_cursor_pos(self, window, x, y):
pos = ivec2(x, y)
delta = pos - self.prev_pos
self.prev_pos = pos
if self.is_drag_window:
win_pos = ivec2(*glfw.get_window_pos(window))
win_pos += delta
glfw.set_window_pos(window, *win_pos)
if self.is_scale_window:
win_size = ivec2(*glfw.get_window_size(window))
win_size += delta
glfw.set_window_size(window, *win_size)
def loadImgFromFile(self, imgFilename='images/Yarbus_scaled.jpg'):
self.img = Image.open(imgFilename)
self.img_width, self.img_height = self.img.size
if self.visualize:
glfw.set_window_size(self.window, self.img_width, self.img_height)
self.updateTexture()
if self.gazePosition[0] < 0:
gazePosition = (self.img_height / 2, self.img_width / 2)
else:
gazePosition = self.gazePosition
self.updateGaze(self.gazeRadius, gazePosition)
def on_scroll(self, window, x, y):
self._isresizing = True
w, h = glfw.get_window_size(window)
a = 1.1 if y > 0.0 else 0.9
w, h = w * a, h * a
w, h = int(clamp(w, 128, 4096)), int(clamp(h, 128, 4096))
old_w, old_h = glfw.get_window_size(window)
glfw.set_window_size(window, w, h)
x, y = glfw.get_window_pos(window)
glfw.set_window_pos(window, x - (w - old_w) // 2, y - (h - old_h) // 2)
self._isresizing = False
def set_window_size():
# Get default window size
f_width, f_height = window_size_default
# Get current display scale factor
content_scale = gl_utils.get_content_scale(main_window)
framebuffer_scale = gl_utils.get_framebuffer_scale(main_window)
display_scale_factor = content_scale / framebuffer_scale
# Scale the capture frame size by display scale factor
f_width *= display_scale_factor
f_height *= display_scale_factor
# Set the newly calculated size (scaled capture frame size + scaled icon bar width)
glfw.set_window_size(main_window, int(f_width), int(f_height))
def _get_viewer(self, mode) -> mujoco_py.MjViewer:
self.viewer = self._viewers.get(mode)
if self.viewer is not None:
return self.viewer
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
# we turn off the overlay and make the window smaller.
self.viewer._hide_overlay = True
import glfw
glfw.set_window_size(self.viewer.window, self.default_window_width, self.default_window_height)
else:
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, -1)
self.viewer_setup()
self._viewers[mode] = self.viewer
return self.viewer
def display_image(image, zoom=None, size=None, title=None): # HWC
# Import OpenGL and glfw.
import OpenGL.GL as gl
import glfw
# Zoom image if requested.
image = np.asarray(image)
if size is not None:
assert zoom is None
zoom = max(1, size // image.shape[0])
if zoom is not None:
image = image.repeat(zoom, axis=0).repeat(zoom, axis=1)
height, width, channels = image.shape
# Initialize window.
if title is None:
title = 'Debug window'
global _glfw_window
if _glfw_window is None:
glfw.init()
_glfw_window = glfw.create_window(width, height, title, None, None)
glfw.make_context_current(_glfw_window)
glfw.show_window(_glfw_window)
glfw.swap_interval(0)
else:
glfw.make_context_current(_glfw_window)
glfw.set_window_title(_glfw_window, title)
glfw.set_window_size(_glfw_window, width, height)
# Update window.
glfw.poll_events()
gl.glClearColor(0, 0, 0, 1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glWindowPos2f(0, 0)
gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1)
gl_format = {3: gl.GL_RGB, 2: gl.GL_RG, 1: gl.GL_LUMINANCE}[channels]
gl_dtype = {
'uint8': gl.GL_UNSIGNED_BYTE,
'float32': gl.GL_FLOAT
}[image.dtype.name]
gl.glDrawPixels(width, height, gl_format, gl_dtype, image[::-1])
glfw.swap_buffers(_glfw_window)
if glfw.window_should_close(_glfw_window):
return False
return True
def set_window_size():
# Get current capture frame size
f_width, f_height = g_pool.capture.frame_size
# Get current display scale factor
content_scale = gl_utils.get_content_scale(main_window)
framebuffer_scale = gl_utils.get_framebuffer_scale(main_window)
display_scale_factor = content_scale / framebuffer_scale
# Scale the capture frame size by display scale factor
f_width *= display_scale_factor
f_height *= display_scale_factor
# Increas the width to account for the added scaled icon bar width
f_width += icon_bar_width * display_scale_factor
# Set the newly calculated size (scaled capture frame size + scaled icon bar width)
glfw.set_window_size(main_window, int(f_width), int(f_height))
def render(self, mode='human', width=None, height=None):
"""
returns images of modality <modeL
:param mode: One of ['human', 'rgb', 'rgbd', 'depth']
:param kwargs: width, height (in pixels) of the image.
:return: image(, depth). image is between [0, 1), depth is distance.
"""
width = width or self.width
height = height or self.height
viewer = self._get_viewer(mode, cam_id=self.cam_id)
viewer.render(width, height)
if mode in ['rgb', 'rgb_array']:
data = viewer.read_pixels(width, height, depth=False)
# original image is upside-down, so flip it
return data[::-1, :, :]
elif mode == 'rgbd':
rgb, d = viewer.read_pixels(width, height, depth=True)
# original image is upside-down, so flip it
return rgb[::-1, :, :], d[::-1, :]
elif mode == 'depth':
_, d = viewer.read_pixels(width, height, depth=True)
# original image is upside-down, so flip it
return d[::-1, :]
elif mode == 'grey':
data = viewer.read_pixels(width, height, depth=False)
# original image is upside-down, so flip it
return data[::-1, :, :].mean(axis=-1).astype(np.uint8)
elif mode == 'notebook':
from PIL import Image
from IPython.display import display
data = viewer.read_pixels(width, height, depth=False)
img = Image.fromarray(data[::-1])
display(img)
return data[::-1]
elif mode == 'human':
if width and height:
import glfw
glfw.set_window_size(viewer.window, width, height)
viewer.render()
def _get_viewer(self, mode, cam_id) -> mujoco_py.MjViewer:
mode_cam_id = mode, cam_id
self.viewer = self._viewers.get(mode_cam_id)
if self.viewer is not None:
if sys.platform == 'darwin':
# info: to fix the black image of death.
self.viewer._set_mujoco_buffers()
return self.viewer
if mode == 'human':
self.viewer = mujoco_py.MjViewer(self.sim)
# we turn off the overlay and make the window smaller.
self.viewer._hide_overlay = True
import glfw
glfw.set_window_size(self.viewer.window, self.width, self.height)
else:
self.viewer = mujoco_py.MjRenderContextOffscreen(self.sim, -1)
self.viewer_setup()
self._viewers[mode_cam_id] = self.viewer
return self.viewer
def render(self, mode='human', width=None, height=None):
"""
returns images of modality <modeL
:param mode: One of ['human', 'rgb', 'rgbd', 'depth']
:param kwargs: width, height (in pixels) of the image.
:return: image(, depth). image is between [0, 1), depth is distance.
"""
width = width or self.default_window_width
height = height or self.default_window_height
viewer = self._get_viewer(mode)
self._before_render()
if mode in ['rgb', 'rgb_array']:
viewer.render(width, height)
data = viewer.read_pixels(width, height, depth=False)
# original image is upside-down, so flip it
return data[::-1, :, :]
elif mode == 'rgbd':
viewer.render(width, height)
rgb, d = viewer.read_pixels(width, height, depth=True)
# original image is upside-down, so flip it
return rgb[::-1, :, :], d[::-1, :]
elif mode == 'depth':
viewer.render(width, height)
_, d = viewer.read_pixels(width, height, depth=True)
# original image is upside-down, so flip it
return d[::-1, :]
elif mode == 'grey':
viewer.render(width, height)
data = viewer.read_pixels(width, height, depth=False)
# original image is upside-down, so flip it
return data[::-1, :, :].mean(axis=-1).astype(np.uint8)
elif mode == 'human':
if width and height:
import glfw
glfw.set_window_size(viewer.window, width, height)
viewer.render()
def set_window_size():
# Get current capture frame size
f_width, f_height = g_pool.capture.frame_size
# Eye camera resolutions are too small to be used as default window sizes.
# We use double their size instead.
frame_scale_factor = 2
f_width *= frame_scale_factor
f_height *= frame_scale_factor
# Get current display scale factor
content_scale = gl_utils.get_content_scale(main_window)
framebuffer_scale = gl_utils.get_framebuffer_scale(main_window)
display_scale_factor = content_scale / framebuffer_scale
# Scale the capture frame size by display scale factor
f_width *= display_scale_factor
f_height *= display_scale_factor
# Increas the width to account for the added scaled icon bar width
f_width += icon_bar_width * display_scale_factor
# Set the newly calculated size (scaled capture frame size + scaled icon bar width)
glfw.set_window_size(main_window, int(f_width), int(f_height))
def draw(self, return_mat=False):
if self.client:
img = self.client.new_frame_image()
if img and img.texture_size().width and img.texture_size().height:
if self.first_frame_flg:
# set window size and show option
glfw.set_window_size(self.window, int(img.texture_size().width), int(img.texture_size().height))
if not self.show:
glfw.hide_window(self.window) # hide window
# OpenGL init
glMatrixMode(GL_PROJECTION)
glOrtho(0, int(img.texture_size().width), int(img.texture_size().height), 0, 1, -1)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glDisable(GL_DEPTH_TEST)
glClearColor(0.0, 0.0, 0.0, 0.0)
glEnable(GL_TEXTURE_RECTANGLE)
self.first_frame_flg = False
print(f"server: \"{self.server.app_name}/{self.server.name}\", window: \"{self.window_name}\", size: \"{img.texture_size().width} × {img.texture_size().height}\"")
glfw.make_context_current(self.window)
# Clear screen
glClearColor(0.0, 0.0, 0.0, 0.0)
glClear(GL_COLOR_BUFFER_BIT)
# Bind the texture
glEnable(GL_TEXTURE_RECTANGLE)
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_RECTANGLE, img.texture_name())
# Configure texturing as we want it
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP)
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP)
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
glColor4f(1.0, 1.0, 1.0, 1.0)
texCoords = np.array([
0.0, img.texture_size().height,
img.texture_size().width, img.texture_size().height,
img.texture_size().width, 0.0,
0.0, 0.0], dtype=GLfloat)
verts = np.array([
0.0, 0.0,
img.texture_size().width, 0.0,
img.texture_size().width, img.texture_size().height,
0.0, img.texture_size().height], dtype=GLfloat)
glEnableClientState( GL_TEXTURE_COORD_ARRAY )
glTexCoordPointer(2, GL_FLOAT, 0, texCoords)
glEnableClientState(GL_VERTEX_ARRAY)
glVertexPointer(2, GL_FLOAT, 0, verts)
glDrawArrays( GL_TRIANGLE_FAN, 0, 4 )
if return_mat:
x_scale, y_scale = glfw.get_window_content_scale(self.window)
frame = np.zeros((int(img.texture_size().height * x_scale), int(img.texture_size().width * y_scale), 4), np.uint8)
glPixelStorei(GL_PACK_ALIGNMENT, 1)
glPixelStorei(GL_PACK_ROW_LENGTH, (int(img.texture_size().width * x_scale)))
glReadPixels(0, 0, int(img.texture_size().width * x_scale), int(img.texture_size().height * y_scale), GL_BGRA, GL_UNSIGNED_BYTE, frame.data)
frame = cv2.resize(frame, (int(img.texture_size().width), int(img.texture_size().height)))
frame = cv2.flip(frame, 0)
return frame
glfw.swap_buffers(self.window)
glfw.poll_events()
# unbind our sender texture
glBindTexture(GL_TEXTURE_RECTANGLE, 0)
def size(self, value: Tuple[int, int]):
glfw.set_window_size(self._window, value[0], value[1])
def _vispy_set_size(self, w, h):
if self._id is None:
return
# Set size of the widget or window
glfw.set_window_size(self._id, w, h)
def change_size(self, width, height):
glfw.set_window_size(self.window, width, height)
def set_window_size(self, widht, hight):
if self.minimumSize_guard(widht, hight):
glfw.set_window_size(self.Window, widht, hight)
def _before_make_current(self, width, height):
previous_context = glfw.get_current_context()
glfw.make_context_current(self._context)
if (width, height) != glfw.get_window_size(self._context):
glfw.set_window_size(self._context, width, height)
return previous_context
def _set_initial_window_state(self):
glfw.set_window_pos(self._window,
*self._general_settings.window_position)
glfw.set_window_size(self._window, *self._general_settings.window_size)
