def test_color_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
for renderer in renderers:
im_shape = renderer.shape
lighting = lightings[renderer.num_channels]
# Get pixels and dI/dC
mesh = get_earthmesh(trans=np.array([0,0,5]), rotation = np.array([math.pi/2.,0,0]))
mesh_verts = Ch(mesh.v)
mesh_colors = Ch(mesh.vc)
camera.set(v=mesh_verts)
# import pdb; pdb.set_trace()
# print '-------------------------------------------'
#lighting.set(vc=mesh_colors, v=mesh_verts)
lighting.vc = mesh_colors[:,:renderer.num_channels]
lighting.v = mesh_verts
renderer.set(v=mesh_verts, vc=lighting)
r = renderer.r
dr = renderer.dr_wrt(mesh_colors).copy()
# Establish a random direction
eps = .4
direction = (np.random.randn(mesh.v.size).reshape(mesh.v.shape)*.1 + np.sin(mesh.v*19)*.1).flatten()
# Find empirical forward derivatives in that direction
mesh_colors = Ch(mesh.vc+direction.reshape(mesh.vc.shape)*eps/2.)
lighting.set(vc=mesh_colors[:,:renderer.num_channels])
renderer.set(vc=lighting)
rfwd = renderer.r
# Find empirical backward derivatives in that direction
mesh_colors = Ch(mesh.vc-direction.reshape(mesh.vc.shape)*eps/2.)
lighting.set(vc=mesh_colors[:,:renderer.num_channels])
renderer.set(vc=lighting)
rbwd = renderer.r
dr_empirical = (np.asarray(rfwd, np.float64) - np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(dr_empirical.shape)
images = OrderedDict()
images['shifted colors'] = np.asarray(rfwd, np.float64)-.5
images[r'empirical colors $\left(\frac{dI}{dC}\right)$'] = dr_empirical
images[r'predicted colors $\left(\frac{dI}{dC}\right)$'] = dr_predicted
images['difference colors'] = dr_predicted-dr_empirical
nonzero = images['difference colors'][np.nonzero(images['difference colors']!=0)[0]]
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6*3, 2*3))
for idx, title in enumerate(images.keys()):
plt.subplot(1,len(images.keys()), idx+1)
im = process(images[title].reshape(im_shape), vmin=-.5, vmax=.5)
plt.title(title)
plt.imshow(im)
plt.show()
print 'color: median nonzero %.2e' % (np.median(np.abs(nonzero)),)
print 'color: mean nonzero %.2e' % (np.mean(np.abs(nonzero)),)
self.assertLess(np.mean(np.abs(nonzero)), 2e-2)
self.assertLess(np.median(np.abs(nonzero)), 4.5e-3)
def test_vert_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
for renderer in renderers:
lighting = lightings[renderer.num_channels]
im_shape = renderer.shape
# Render a rotating mesh
mesh = get_earthmesh(trans=np.array([0,0,5]), rotation = np.array([math.pi/2.,0,0]))
mesh_verts = Ch(mesh.v.flatten())
camera.set(v=mesh_verts)
lighting.set(v=mesh_verts)
renderer.set(camera=camera)
renderer.set(vc=lighting)
# Get pixels and derivatives
r = renderer.r
dr = renderer.dr_wrt(mesh_verts)
# Establish a random direction
direction = (np.random.rand(mesh.v.size).reshape(mesh.v.shape)-.5)*.1 + np.sin(mesh.v*10)*.2
direction *= .5
eps = .2
# Render going forward in that direction
mesh_verts = Ch(mesh.v+direction*eps/2.)
lighting.set(v=mesh_verts)
renderer.set(v=mesh_verts, vc=lighting)
rfwd = renderer.r
# Render going backward in that direction
mesh_verts = Ch(mesh.v-direction*eps/2.)
lighting.set(v=mesh_verts)
renderer.set(v=mesh_verts, vc=lighting)
rbwd = renderer.r
# Establish empirical and predicted derivatives
dr_empirical = (np.asarray(rfwd, np.float64) - np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(dr_empirical.shape)
images = OrderedDict()
images['shifted verts'] = np.asarray(rfwd, np.float64)-.5
images[r'empirical verts $\left(\frac{dI}{dV}\right)$'] = dr_empirical
images[r'predicted verts $\left(\frac{dI}{dV}\right)$'] = dr_predicted
images['difference verts'] = dr_predicted - dr_empirical
nonzero = images['difference verts'][np.nonzero(images['difference verts']!=0)[0]]
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6*3, 2*3))
for idx, title in enumerate(images.keys()):
plt.subplot(1,len(images.keys()), idx+1)
im = process(images[title].reshape(im_shape), vmin=-.5, vmax=.5)
plt.title(title)
plt.imshow(im)
print 'verts: median nonzero %.2e' % (np.median(np.abs(nonzero)),)
print 'verts: mean nonzero %.2e' % (np.mean(np.abs(nonzero)),)
plt.draw()
plt.show()
self.assertLess(np.mean(np.abs(nonzero)), 7e-2)
self.assertLess(np.median(np.abs(nonzero)), 4e-2)
def test_lightpos_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
for renderer in renderers:
im_shape = renderer.shape
lighting = lightings[renderer.num_channels]
# Render a rotating mesh
mesh = get_earthmesh(trans=np.array([0,0,5]), rotation = np.array([math.pi/2.,0,0]))
mesh_verts = Ch(mesh.v.flatten())
camera.set(v=mesh_verts)
# Get predicted derivatives wrt light pos
light1_pos = Ch(np.array([-1000,-1000,-1000]))
lighting.set(light_pos=light1_pos, v=mesh_verts)
renderer.set(vc=lighting, v=mesh_verts)
dr = renderer.dr_wrt(light1_pos).copy()
# Establish a random direction for the light
direction = (np.random.rand(3)-.5)*1000.
eps = 1.
# Find empirical forward derivatives in that direction
lighting.set(light_pos = light1_pos.r + direction*eps/2.)
renderer.set(vc=lighting)
rfwd = renderer.r
# Find empirical backward derivatives in that direction
lighting.set(light_pos = light1_pos.r - direction*eps/2.)
renderer.set(vc=lighting)
rbwd = renderer.r
# Establish empirical and predicted derivatives
dr_empirical = (np.asarray(rfwd, np.float64) - np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(dr_empirical.shape)
images = OrderedDict()
images['shifted lightpos'] = np.asarray(rfwd, np.float64)-.5
images[r'empirical lightpos $\left(\frac{dI}{dL_p}\right)$'] = dr_empirical
images[r'predicted lightpos $\left(\frac{dI}{dL_p}\right)$'] = dr_predicted
images['difference lightpos'] = dr_predicted-dr_empirical
nonzero = images['difference lightpos'][np.nonzero(images['difference lightpos']!=0)[0]]
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6*3, 2*3))
for idx, title in enumerate(images.keys()):
plt.subplot(1,len(images.keys()), idx+1)
im = process(images[title].reshape(im_shape), vmin=-.5, vmax=.5)
plt.title(title)
plt.imshow(im)
plt.show()
print 'lightpos: median nonzero %.2e' % (np.median(np.abs(nonzero)),)
print 'lightpos: mean nonzero %.2e' % (np.mean(np.abs(nonzero)),)
self.assertLess(np.mean(np.abs(nonzero)), 2.4e-2)
self.assertLess(np.median(np.abs(nonzero)), 1.2e-2)
def test_cam_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
camparms = {
'c': {'mednz' : 2.2e-2, 'meannz': 4.2e-2, 'desc': 'center of proj diff', 'eps0': 4., 'eps1': .1},
#'f': {'mednz' : 2.5e-2, 'meannz': 6e-2, 'desc': 'focal diff', 'eps0': 100., 'eps1': .1},
't': {'mednz' : 1.2e-1, 'meannz': 3.0e-1, 'desc': 'trans diff', 'eps0': .25, 'eps1': .1},
'rt': {'mednz' : 8e-2, 'meannz': 1.8e-1, 'desc': 'rot diff', 'eps0': 0.02, 'eps1': .5},
'k': {'mednz' : 7e-2, 'meannz': 5.1e-1, 'desc': 'distortion diff', 'eps0': .5, 'eps1': .05}
}
for renderer in renderers:
im_shape = renderer.shape
lighting = lightings[renderer.num_channels]
# Render a rotating mesh
mesh = get_earthmesh(trans=np.array([0,0,5]), rotation = np.array([math.pi/2.,0,0]))
mesh_verts = Ch(mesh.v.flatten())
camera.v = mesh_verts
lighting.v = mesh_verts
renderer.vc = lighting
renderer.camera = camera
for atrname, info in camparms.items():
# Get pixels and derivatives
r = renderer.r
atr = lambda : getattr(camera, atrname)
satr = lambda x : setattr(camera, atrname, x)
atr_size = atr().size
dr = renderer.dr_wrt(atr())
# Establish a random direction
tmp = np.random.rand(atr().size) - .5
direction = (tmp / np.linalg.norm(tmp))*info['eps0']
#direction = np.sin(np.ones(atr_size))*info['eps0']
#direction = np.zeros(atr_size)
# try:
# direction[4] = 1.
# except: pass
#direction *= info['eps0']
eps = info['eps1']
# Render going forward in that direction
satr(atr().r + direction*eps/2.)
rfwd = renderer.r
# Render going backward in that direction
satr(atr().r - direction*eps/1.)
rbwd = renderer.r
# Put back
satr(atr().r + direction*eps/2.)
# Establish empirical and predicted derivatives
dr_empirical = (np.asarray(rfwd, np.float64) - np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(dr_empirical.shape)
images = OrderedDict()
images['shifted %s' % (atrname,)] = np.asarray(rfwd, np.float64)-.5
images[r'empirical %s' % (atrname,)] = dr_empirical
images[r'predicted %s' % (atrname,)] = dr_predicted
images[info['desc']] = dr_predicted - dr_empirical
nonzero = images[info['desc']][np.nonzero(images[info['desc']]!=0)[0]]
mederror = np.median(np.abs(nonzero))
meanerror = np.mean(np.abs(nonzero))
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6*3, 2*3))
for idx, title in enumerate(images.keys()):
plt.subplot(1,len(images.keys()), idx+1)
im = process(images[title].reshape(im_shape), vmin=-.5, vmax=.5)
plt.title(title)
plt.imshow(im)
print '%s: median nonzero %.2e' % (atrname, mederror,)
print '%s: mean nonzero %.2e' % (atrname, meanerror,)
plt.draw()
plt.show()
self.assertLess(meanerror, info['meannz'])
self.assertLess(mederror, info['mednz'])
def test_color_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
for renderer in renderers:
im_shape = renderer.shape
lighting = lightings[renderer.num_channels]
# Get pixels and dI/dC
mesh = get_earthmesh(trans=np.array([0, 0, 5]),
rotation=np.array([math.pi / 2., 0, 0]))
mesh_verts = Ch(mesh.v)
mesh_colors = Ch(mesh.vc)
camera.set(v=mesh_verts)
# import pdb; pdb.set_trace()
# print '-------------------------------------------'
#lighting.set(vc=mesh_colors, v=mesh_verts)
lighting.vc = mesh_colors[:, :renderer.num_channels]
lighting.v = mesh_verts
renderer.set(v=mesh_verts, vc=lighting)
r = renderer.r
dr = renderer.dr_wrt(mesh_colors).copy()
# Establish a random direction
eps = .4
direction = (
np.random.randn(mesh.v.size).reshape(mesh.v.shape) * .1 +
np.sin(mesh.v * 19) * .1).flatten()
# Find empirical forward derivatives in that direction
mesh_colors = Ch(mesh.vc +
direction.reshape(mesh.vc.shape) * eps / 2.)
lighting.set(vc=mesh_colors[:, :renderer.num_channels])
renderer.set(vc=lighting)
rfwd = renderer.r
# Find empirical backward derivatives in that direction
mesh_colors = Ch(mesh.vc -
direction.reshape(mesh.vc.shape) * eps / 2.)
lighting.set(vc=mesh_colors[:, :renderer.num_channels])
renderer.set(vc=lighting)
rbwd = renderer.r
dr_empirical = (np.asarray(rfwd, np.float64) -
np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(
dr_empirical.shape)
images = OrderedDict()
images['shifted colors'] = np.asarray(rfwd, np.float64) - .5
images[
r'empirical colors $\left(\frac{dI}{dC}\right)$'] = dr_empirical
images[
r'predicted colors $\left(\frac{dI}{dC}\right)$'] = dr_predicted
images['difference colors'] = dr_predicted - dr_empirical
nonzero = images['difference colors'][np.nonzero(
images['difference colors'] != 0)[0]]
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6 * 3, 2 * 3))
for idx, title in enumerate(images.keys()):
plt.subplot(1, len(images.keys()), idx + 1)
im = process(images[title].reshape(im_shape),
vmin=-.5,
vmax=.5)
plt.title(title)
plt.imshow(im)
plt.show()
print 'color: median nonzero %.2e' % (np.median(
np.abs(nonzero)), )
print 'color: mean nonzero %.2e' % (np.mean(np.abs(nonzero)), )
self.assertLess(np.mean(np.abs(nonzero)), 2e-2)
self.assertLess(np.median(np.abs(nonzero)), 4.5e-3)
def test_lightpos_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
for renderer in renderers:
im_shape = renderer.shape
lighting = lightings[renderer.num_channels]
# Render a rotating mesh
mesh = get_earthmesh(trans=np.array([0, 0, 5]),
rotation=np.array([math.pi / 2., 0, 0]))
mesh_verts = Ch(mesh.v.flatten())
camera.set(v=mesh_verts)
# Get predicted derivatives wrt light pos
light1_pos = Ch(np.array([-1000, -1000, -1000]))
lighting.set(light_pos=light1_pos, v=mesh_verts)
renderer.set(vc=lighting, v=mesh_verts)
dr = renderer.dr_wrt(light1_pos).copy()
# Establish a random direction for the light
direction = (np.random.rand(3) - .5) * 1000.
eps = 1.
# Find empirical forward derivatives in that direction
lighting.set(light_pos=light1_pos.r + direction * eps / 2.)
renderer.set(vc=lighting)
rfwd = renderer.r
# Find empirical backward derivatives in that direction
lighting.set(light_pos=light1_pos.r - direction * eps / 2.)
renderer.set(vc=lighting)
rbwd = renderer.r
# Establish empirical and predicted derivatives
dr_empirical = (np.asarray(rfwd, np.float64) -
np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(
dr_empirical.shape)
images = OrderedDict()
images['shifted lightpos'] = np.asarray(rfwd, np.float64) - .5
images[
r'empirical lightpos $\left(\frac{dI}{dL_p}\right)$'] = dr_empirical
images[
r'predicted lightpos $\left(\frac{dI}{dL_p}\right)$'] = dr_predicted
images['difference lightpos'] = dr_predicted - dr_empirical
nonzero = images['difference lightpos'][np.nonzero(
images['difference lightpos'] != 0)[0]]
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6 * 3, 2 * 3))
for idx, title in enumerate(images.keys()):
plt.subplot(1, len(images.keys()), idx + 1)
im = process(images[title].reshape(im_shape),
vmin=-.5,
vmax=.5)
plt.title(title)
plt.imshow(im)
plt.show()
print 'lightpos: median nonzero %.2e' % (np.median(
np.abs(nonzero)), )
print 'lightpos: mean nonzero %.2e' % (np.mean(
np.abs(nonzero)), )
self.assertLess(np.mean(np.abs(nonzero)), 2.4e-2)
self.assertLess(np.median(np.abs(nonzero)), 1.2e-2)
def test_vert_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
for renderer in renderers:
lighting = lightings[renderer.num_channels]
im_shape = renderer.shape
# Render a rotating mesh
mesh = get_earthmesh(trans=np.array([0, 0, 5]),
rotation=np.array([math.pi / 2., 0, 0]))
mesh_verts = Ch(mesh.v.flatten())
camera.set(v=mesh_verts)
lighting.set(v=mesh_verts)
renderer.set(camera=camera)
renderer.set(vc=lighting)
# Get pixels and derivatives
r = renderer.r
dr = renderer.dr_wrt(mesh_verts)
# Establish a random direction
direction = (np.random.rand(mesh.v.size).reshape(mesh.v.shape) -
.5) * .1 + np.sin(mesh.v * 10) * .2
direction *= .5
eps = .2
# Render going forward in that direction
mesh_verts = Ch(mesh.v + direction * eps / 2.)
lighting.set(v=mesh_verts)
renderer.set(v=mesh_verts, vc=lighting)
rfwd = renderer.r
# Render going backward in that direction
mesh_verts = Ch(mesh.v - direction * eps / 2.)
lighting.set(v=mesh_verts)
renderer.set(v=mesh_verts, vc=lighting)
rbwd = renderer.r
# Establish empirical and predicted derivatives
dr_empirical = (np.asarray(rfwd, np.float64) -
np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(
dr_empirical.shape)
images = OrderedDict()
images['shifted verts'] = np.asarray(rfwd, np.float64) - .5
images[
r'empirical verts $\left(\frac{dI}{dV}\right)$'] = dr_empirical
images[
r'predicted verts $\left(\frac{dI}{dV}\right)$'] = dr_predicted
images['difference verts'] = dr_predicted - dr_empirical
nonzero = images['difference verts'][np.nonzero(
images['difference verts'] != 0)[0]]
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6 * 3, 2 * 3))
for idx, title in enumerate(images.keys()):
plt.subplot(1, len(images.keys()), idx + 1)
im = process(images[title].reshape(im_shape),
vmin=-.5,
vmax=.5)
plt.title(title)
plt.imshow(im)
print 'verts: median nonzero %.2e' % (np.median(
np.abs(nonzero)), )
print 'verts: mean nonzero %.2e' % (np.mean(np.abs(nonzero)), )
plt.draw()
plt.show()
self.assertLess(np.mean(np.abs(nonzero)), 7e-2)
self.assertLess(np.median(np.abs(nonzero)), 4e-2)
def test_cam_derivatives(self):
mesh, lightings, camera, frustum, renderers = self.load_basics()
camparms = {
'c': {
'mednz': 2.2e-2,
'meannz': 4.3e-2,
'desc': 'center of proj diff',
'eps0': 4.,
'eps1': .1
},
#'f': {'mednz' : 2.5e-2, 'meannz': 6e-2, 'desc': 'focal diff', 'eps0': 100., 'eps1': .1},
't': {
'mednz': 1.2e-1,
'meannz': 3.0e-1,
'desc': 'trans diff',
'eps0': .25,
'eps1': .1
},
'rt': {
'mednz': 8e-2,
'meannz': 1.8e-1,
'desc': 'rot diff',
'eps0': 0.02,
'eps1': .5
},
'k': {
'mednz': 7e-2,
'meannz': 5.1e-1,
'desc': 'distortion diff',
'eps0': .5,
'eps1': .05
}
}
for renderer in renderers:
im_shape = renderer.shape
lighting = lightings[renderer.num_channels]
# Render a rotating mesh
mesh = get_earthmesh(trans=np.array([0, 0, 5]),
rotation=np.array([math.pi / 2., 0, 0]))
mesh_verts = Ch(mesh.v.flatten())
camera.v = mesh_verts
lighting.v = mesh_verts
renderer.vc = lighting
renderer.camera = camera
for atrname, info in camparms.items():
# Get pixels and derivatives
r = renderer.r
atr = lambda: getattr(camera, atrname)
satr = lambda x: setattr(camera, atrname, x)
atr_size = atr().size
dr = renderer.dr_wrt(atr())
# Establish a random direction
tmp = np.random.rand(atr().size) - .5
direction = (tmp / np.linalg.norm(tmp)) * info['eps0']
#direction = np.sin(np.ones(atr_size))*info['eps0']
#direction = np.zeros(atr_size)
# try:
# direction[4] = 1.
# except: pass
#direction *= info['eps0']
eps = info['eps1']
# Render going forward in that direction
satr(atr().r + direction * eps / 2.)
rfwd = renderer.r
# Render going backward in that direction
satr(atr().r - direction * eps / 1.)
rbwd = renderer.r
# Put back
satr(atr().r + direction * eps / 2.)
# Establish empirical and predicted derivatives
dr_empirical = (np.asarray(rfwd, np.float64) -
np.asarray(rbwd, np.float64)).ravel() / eps
dr_predicted = dr.dot(col(direction.flatten())).reshape(
dr_empirical.shape)
images = OrderedDict()
images['shifted %s' %
(atrname, )] = np.asarray(rfwd, np.float64) - .5
images[r'empirical %s' % (atrname, )] = dr_empirical
images[r'predicted %s' % (atrname, )] = dr_predicted
images[info['desc']] = dr_predicted - dr_empirical
nonzero = images[info['desc']][np.nonzero(
images[info['desc']] != 0)[0]]
mederror = np.median(np.abs(nonzero))
meanerror = np.mean(np.abs(nonzero))
if visualize:
matplotlib.rcParams.update({'font.size': 18})
plt.figure(figsize=(6 * 3, 2 * 3))
for idx, title in enumerate(images.keys()):
plt.subplot(1, len(images.keys()), idx + 1)
im = process(images[title].reshape(im_shape),
vmin=-.5,
vmax=.5)
plt.title(title)
plt.imshow(im)
print '%s: median nonzero %.2e' % (
atrname,
mederror,
)
print '%s: mean nonzero %.2e' % (
atrname,
meanerror,
)
plt.draw()
plt.show()
self.assertLess(meanerror, info['meannz'])
self.assertLess(mederror, info['mednz'])
