class ColoredRenderer(BaseRenderer):
terms = 'f', 'frustum', 'background_image', 'overdraw', 'num_channels'
dterms = 'vc', 'camera', 'bgcolor'
@property
def shape(self):
if not hasattr(self, 'num_channels'):
self.num_channels = 3
if self.num_channels > 1:
return (self.frustum['height'], self.frustum['width'],
self.num_channels)
else:
return (self.frustum['height'], self.frustum['width'])
def compute_r(self):
tmp = self.camera.r
return self.color_image # .reshape((self.frustum['height'], self.frustum['width'], -1)).squeeze()
def compute_dr_wrt(self, wrt):
if wrt is not self.camera and wrt is not self.vc and wrt is not self.bgcolor:
return None
visibility = self.visibility_image
shape = visibility.shape
color = self.color_image
visible = np.nonzero(visibility.ravel() != 4294967295)[0]
num_visible = len(visible)
barycentric = self.barycentric_image
if wrt is self.camera:
if self.overdraw:
return common.dImage_wrt_2dVerts_bnd(
color, visible, visibility, barycentric,
self.frustum['width'], self.frustum['height'],
int(self.v.r.size / 3), self.f,
self.boundaryid_image != 4294967295)
else:
return common.dImage_wrt_2dVerts(color, visible, visibility,
barycentric,
self.frustum['width'],
self.frustum['height'],
int(self.v.r.size / 3),
self.f)
elif wrt is self.vc:
return common.dr_wrt_vc(visible,
visibility,
self.f,
barycentric,
self.frustum,
self.vc.size,
num_channels=self.num_channels)
elif wrt is self.bgcolor:
return common.dr_wrt_bgcolor(visibility,
self.frustum,
num_channels=self.num_channels)
def on_changed(self, which):
if 'frustum' in which:
w = self.frustum['width']
h = self.frustum['height']
self.glf = OsContext(w, h, typ=GL_FLOAT)
self.glf.Viewport(0, 0, w, h)
self.glb = OsContext(w, h, typ=GL_UNSIGNED_BYTE)
self.glb.Viewport(0, 0, w, h)
if 'frustum' in which or 'camera' in which:
setup_camera(self.glb, self.camera, self.frustum)
setup_camera(self.glf, self.camera, self.frustum)
# pass
if not hasattr(self, 'num_channels'):
self.num_channels = 3
if not hasattr(self, 'bgcolor'):
self.bgcolor = Ch(np.array([.5] * self.num_channels))
which.add('bgcolor')
if not hasattr(self, 'overdraw'):
self.overdraw = True
if 'bgcolor' in which or ('frustum' in which
and hasattr(self, 'bgcolor')):
self.glf.ClearColor(self.bgcolor.r[0],
self.bgcolor.r[1 % self.num_channels],
self.bgcolor.r[2 % self.num_channels], 1.)
def flow_to(self, v_next, cam_next=None):
return common.flow_to(self, v_next, cam_next)
def filter_for_triangles(self, which_triangles):
cim = self.color_image
vim = self.visibility_image + 1
arr = np.zeros(len(self.f) + 1)
arr[which_triangles + 1] = 1
relevant_pixels = arr[vim.ravel()]
cim2 = cim.copy() * np.atleast_3d(relevant_pixels.reshape(vim.shape))
relevant_pixels = np.nonzero(arr[vim.ravel()])[0]
xs = relevant_pixels % vim.shape[1]
ys = relevant_pixels / vim.shape[1]
return cim2[np.min(ys):np.max(ys), np.min(xs):np.max(xs), :]
@depends_on('f', 'camera', 'vc')
def boundarycolor_image(self):
return self.draw_boundarycolor_image(with_vertex_colors=True)
def draw_color_image(self, gl):
self._call_on_changed()
gl.Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# use face colors if given
# FIXME: this won't work for 2 channels
draw_colored_verts(gl, self.v.r, self.f, self.vc.r)
result = np.asarray(
deepcopy(gl.getImage()[:, :, :self.num_channels].squeeze()),
np.float64)
if hasattr(self, 'background_image'):
bg_px = np.tile(
np.atleast_3d(self.visibility_image) == 4294967295,
(1, 1, self.num_channels)).squeeze()
fg_px = 1 - bg_px
result = bg_px * self.background_image + fg_px * result
return result
@depends_on(dterms + terms)
def color_image(self):
gl = self.glf
gl.PolygonMode(GL_FRONT_AND_BACK, GL_FILL)
no_overdraw = self.draw_color_image(gl)
if not self.overdraw:
return no_overdraw
gl.PolygonMode(GL_FRONT_AND_BACK, GL_LINE)
overdraw = self.draw_color_image(gl)
gl.PolygonMode(GL_FRONT_AND_BACK, GL_FILL)
boundarybool_image = self.boundarybool_image
if self.num_channels > 1:
boundarybool_image = np.atleast_3d(boundarybool_image)
return np.asarray((overdraw * boundarybool_image + no_overdraw *
(1 - boundarybool_image)),
order='C')
@depends_on('f', 'frustum', 'camera')
def boundary_images(self):
self._call_on_changed()
return draw_boundary_images(self.glb, self.v.r, self.f, self.vpe,
self.fpe, self.camera)
@depends_on(terms + dterms)
def boundarycolor_image(self):
self._call_on_changed()
gl = self.glf
colors = self.vc.r.reshape((-1, 3))[self.vpe.ravel()]
gl.Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
draw_colored_primitives(gl, self.v.r.reshape((-1, 3)), self.vpe,
colors)
return np.asarray(deepcopy(gl.getImage()), np.float64)
