def OnDown(self, event):
""" Called when the mouse is pressed down in the axes.
"""
# Only process left mouse button
if event.button != 1:
return False
# Store location
self._active = Point(event.x2d, event.y2d)
# Clear temp line object
if self._line1:
self._line1.Destroy()
# Create line objects
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(self._active)
self._line1 = vv.plot(tmp, lc='r', lw='1', axes=self._a, axesAdjust=0)
# Draw
self._a.Draw()
# Prevent dragging by indicating the event needs no further handling
return True
def test_gui(self):
pp = Pointset(3)
pp.append(0, 0, 0)
pp.append(0, 1, 0)
pp.append(1, 2, 0)
pp.append(0, 2, 1)
# Create all solids
vv.solidBox((0, 0, 0))
sphere = vv.solidSphere((3, 0, 0))
cone = vv.solidCone((6, 0, 0))
# a cone with 4 faces is a pyramid
pyramid = vv.solidCone((9, 0, 0), N=4)
vv.solidCylinder((0, 3, 0), (1, 1, 2))
ring = vv.solidRing((3, 3, 0))
vv.solidTeapot((6, 3, 0))
vv.solidLine(pp+Point(9, 3, 0), radius=0.2)
# Make the ring green
ring.faceColor = 'g'
# Make the sphere dull
sphere.specular = 0
sphere.diffuse = 0.4
# Show lines in yellow pyramid
pyramid.faceColor = 'r'
pyramid.edgeShading = 'plain'
# Colormap example
N = cone._vertices.shape[0]
cone.SetValues(np.linspace(0, 1, N))
cone.colormap = vv.CM_JET
def compareGraphsVisually(graph1, graph2, fig=None):
""" compareGraphsVisually(graph1, graph2, fig=None)
Show the two graphs together in a figure. Matched nodes are
indicated by lines between them.
"""
# Get figure
if isinstance(fig,int):
fig = vv.figure(fig)
elif fig is None:
fig = vv.figure()
# Prepare figure and axes
fig.Clear()
a = vv.gca()
a.cameraType = '3d'; a.daspectAuto = False
# Draw both graphs
graph1.Draw(lc='b', mc='b')
graph2.Draw(lc='r', mc='r')
# Set the limits
a.SetLimits()
# Make a line from the edges
pp = Pointset(3)
for node in graph1:
if hasattr(node, 'match') and node.match is not None:
pp.append(node); pp.append(node.match)
# Plot edges
vv.plot(pp, lc='g', ls='+')
def on_down(self, event):
if event.button != 1:
return False
if not vv.KEY_SHIFT in event.modifiers:
return False
# Store location
self._active = Point(event.x2d, event.y2d)
# Clear any line object
for l in self._lines:
l.Destroy()
# Create line objects
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(self._active)
l1 = vv.plot(tmp, lc='g', lw='3', axes=self._a2, axesAdjust=0)
l2 = vv.plot(tmp[:1], ls='', ms='.', mc='g', axes=self._a2, axesAdjust=0)
self._lines = [l1, l2]
# Draw
self._a2.Draw()
# Prevent dragging by indicating the event needs no further handling
return True
def create_mesh(graph, radius=1.0, fullPaths=True):
""" Create a polygonal model from the stent and return it as
a visvis.BaseMesh object. To draw the mesh, instantiate
a normal mesh using vv.Mesh(vv.gca(), thisMesh).
"""
from visvis.processing import lineToMesh, combineMeshes
from visvis import Pointset # lineToMesh does not like the new PointSet class
# Init list of meshes
meshes = []
for n1, n2 in graph.edges():
# Obtain path of edge and make mesh
if fullPaths:
path = graph.edge[n1][n2]['path']
path = Pointset(path) # Make a visvis pointset
else:
path = Pointset(3)
path.append(n1)
path.append(n2)
meshes.append(lineToMesh(path, radius, 8))
# Combine meshes and return
if meshes:
return combineMeshes(meshes)
else:
return None
def compareGraphsVisually(graph1, graph2, fig=None):
""" compareGraphsVisually(graph1, graph2, fig=None)
Show the two graphs together in a figure. Matched nodes are
indicated by lines between them.
"""
# Get figure
if isinstance(fig,int):
fig = vv.figure(fig)
elif fig is None:
fig = vv.figure()
# Prepare figure and axes
fig.Clear()
a = vv.gca()
a.cameraType = '3d'; a.daspectAuto = False
# Draw both graphs
graph1.Draw(lc='b', mc='b')
graph2.Draw(lc='r', mc='r')
# Set the limits
a.SetLimits()
# Make a line from the edges
pp = Pointset(3)
for node in graph1:
if hasattr(node, 'match') and node.match is not None:
pp.append(node); pp.append(node.match)
# Plot edges
vv.plot(pp, lc='g', ls='+')
def OnDown(self, event):
""" Called when the mouse is pressed down in the axes.
"""
# Only process left mouse button
if event.button != 1:
return False
# Store location
self._active = Point(event.x2d, event.y2d)
# Clear temp line object
if self._line1:
self._line1.Destroy()
# Create line objects
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(self._active)
self._line1 = vv.plot(tmp, lc="r", lw="1", axes=self._a, axesAdjust=0)
# Draw
self._a.Draw()
# Prevent dragging by indicating the event needs no further handling
return True
def on_motion(self, event):
if self._active and self._lines:
# Update line
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(event.x2d, event.y2d)
l1 = self._lines[0]
l1.SetPoints(tmp)
# Draw
self._a2.Draw()
def Pack(self):
""" Pack()
Pack the contents in an ssdf struct, such that it can be stored.
"""
# If nodelist is empty, ndim defaults to two
ndim = 2
# Get a list of all edges
cc = self.GetEdges()
# Check whether the nodes are homogenous, otherwise we cannot store
if len(self):
ndim = self[0].ndim
for node in self:
if not node.ndim == ndim:
raise ValueError('All nodes should have the same dimension.')
# Init struct
struct = ssdf.new()
# Create array of nodes
pp = Pointset(ndim)
for node in self:
pp.append(node)
struct.nodes = pp.data
# Create the edges
tmp = np.zeros((len(cc), 2), dtype=np.uint32)
for i in range(len(cc)):
c = cc[i]
tmp[i,0] = c._i1
tmp[i,1] = c._i2
struct.edges = tmp
# Store the properties of the edges. The propRefs array
# Does contain redundant data, but it can be stored efficiently
# because the compression handles that...
allProps = ''
propRefs = np.zeros((len(cc), 2), dtype=np.uint32)
for i in range(len(cc)):
tmp = serializeProps(cc[i].props)
propRefs[i, 0] = len(allProps)
propRefs[i, 1] = len(allProps) + len(tmp)
allProps += tmp
struct.edgePropRefs = propRefs
if allProps:
struct.edgeProps = np.frombuffer( allProps, dtype=np.uint8)
else:
struct.edgeProps = np.zeros( (0,), dtype=np.uint8)
# done
return struct
def Pack(self):
""" Pack()
Pack the contents in an ssdf struct, such that it can be stored.
"""
# If nodelist is empty, ndim defaults to two
ndim = 2
# Get a list of all edges
cc = self.GetEdges()
# Check whether the nodes are homogenous, otherwise we cannot store
if len(self):
ndim = self[0].ndim
for node in self:
if not node.ndim == ndim:
raise ValueError('All nodes should have the same dimension.')
# Init struct
struct = ssdf.new()
# Create array of nodes
pp = Pointset(ndim)
for node in self:
pp.append(node)
struct.nodes = pp.data
# Create the edges
tmp = np.zeros((len(cc), 2), dtype=np.uint32)
for i in range(len(cc)):
c = cc[i]
tmp[i,0] = c._i1
tmp[i,1] = c._i2
struct.edges = tmp
# Store the properties of the edges. The propRefs array
# Does contain redundant data, but it can be stored efficiently
# because the compression handles that...
allProps = b''
propRefs = np.zeros((len(cc), 2), dtype=np.uint32)
for i in range(len(cc)):
tmp = serializeProps(cc[i].props)
propRefs[i, 0] = len(allProps)
propRefs[i, 1] = len(allProps) + len(tmp)
allProps += tmp
struct.edgePropRefs = propRefs
if allProps:
struct.edgeProps = np.frombuffer( allProps, dtype=np.uint8)
else:
struct.edgeProps = np.zeros( (0,), dtype=np.uint8)
# done
return struct
def OnMotion(self, event):
""" Called when the mouse is moved in the axes.
"""
if self._active and self._line1:
# Update line
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(event.x2d, event.y2d)
self._line1.SetPoints(tmp)
# Draw
self._a.Draw()
def OnMotion(self, event):
""" Called when the mouse is moved in the axes.
"""
if self._active and self._line1:
# Update line
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(event.x2d, event.y2d)
self._line1.SetPoints(tmp)
# Draw
self._a.Draw()
def apply(self, event=None):
# Get axes
a1 = self._a1
# Get sampling
grid_sampling = self._sampling, self._sampling * 2**self._levels
# Create grid
tmp = self._pp[:, 0]
tmp.shape = (tmp.size, 1)
pp = Pointset(tmp)
grid1 = SplineGrid.from_points_multiscale(
(self._fieldSize, ), grid_sampling, pp.data, self._pp[:, 1])
# Get copy
grid2 = grid1.copy()
# Freeze edges
self.freeze_edges(grid1)
# # Create second grid
# grid2 = SplineGrid.from_field(grid.get_field(), grid.grid_sampling)
# grid3 = SplineGrid.from_field_multiscale(grid.get_field(), grid.grid_sampling)
# Get grid points
ppg1 = Pointset(2)
ppg2 = Pointset(2)
for gx in range(grid1.grid_shape[0]):
ppg1.append((gx - 1) * grid1.grid_sampling, grid1.knots[gx])
ppg2.append((gx - 1) * grid2.grid_sampling, grid2.knots[gx])
# Get field
field = grid1.get_field()
#field2 = grid2.get_field()
#field3 = grid3.get_field()
# Delete objects in scene
for ob in a1.wobjects:
if ob is not self._line1 and not isinstance(
ob, vv.axises.BaseAxis):
ob.Destroy()
# Draw
vv.plot(ppg1, ls='', ms='x', mc='b', mw=9, axes=a1, axesAdjust=False)
vv.plot(ppg2, ls='', ms='x', mc='c', mw=9, axes=a1, axesAdjust=False)
vv.plot(np.arange(0, field.size),
field,
ls='-',
lc='g',
lw=3,
axes=a1,
axesAdjust=False)
def Draw(self, mc='g', lc='y', mw=7, lw=0.6, alpha=0.5, axes=None):
""" Draw(mc='g', lc='y', mw=7, lw=0.6, alpha=0.5, axes=None)
Draw nodes and edges.
"""
# We can only draw if we have any nodes
if not len(self):
return
# Make sure there are elements in the lines list
while len(self._lines)<2:
self._lines.append(None)
# Build node list
if mc and mw:
pp = Pointset(self[0].ndim)
for p in self:
pp.append(p)
# Draw nodes, reuse if possible!
l_node = self._lines[0]
if l_node and len(l_node._points) == len(pp):
l_node.SetPoints(pp)
elif l_node:
l_node.Destroy()
l_node = None
if l_node is None:
l_node = vv.plot(pp, ls='', ms='o', mc=mc, mw=mw,
axesAdjust=0, axes=axes, alpha=alpha)
self._lines[0] = l_node
# For simplicity, always redraw edges
if self._lines[1] is not None:
self._lines[1].Destroy()
# Build edge list
if lc and lw:
cc = self.GetEdges()
# Draw edges
pp = Pointset(self[0].ndim)
for c in cc:
pp.append(c.end1); pp.append(c.end2)
tmp = vv.plot(pp, ms='', ls='+', lc=lc, lw=lw,
axesAdjust=0, axes=axes, alpha=alpha)
self._lines[1] = tmp
def Draw(self, mc='g', lc='y', mw=7, lw=0.6, alpha=0.5, axes=None):
""" Draw(mc='g', lc='y', mw=7, lw=0.6, alpha=0.5, axes=None)
Draw nodes and edges.
"""
# We can only draw if we have any nodes
if not len(self):
return
# Make sure there are elements in the lines list
while len(self._lines)<2:
self._lines.append(None)
# Build node list
if mc and mw:
pp = Pointset(self[0].ndim)
for p in self:
pp.append(p)
# Draw nodes, reuse if possible!
l_node = self._lines[0]
if l_node and len(l_node._points) == len(pp):
l_node.SetPoints(pp)
elif l_node:
l_node.Destroy()
l_node = None
if l_node is None:
l_node = vv.plot(pp, ls='', ms='o', mc=mc, mw=mw,
axesAdjust=0, axes=axes, alpha=alpha)
self._lines[0] = l_node
# For simplicity, always redraw edges
if self._lines[1] is not None:
self._lines[1].Destroy()
# Build edge list
if lc and lw:
cc = self.GetEdges()
# Draw edges
pp = Pointset(self[0].ndim)
for c in cc:
pp.append(c.end1); pp.append(c.end2)
tmp = vv.plot(pp, ms='', ls='+', lc=lc, lw=lw,
axesAdjust=0, axes=axes, alpha=alpha)
self._lines[1] = tmp
plain color, colormaps and texture.
On the website, this example also demonstrates the fly camera to fly through
the mesh objects.
"""
import numpy as np
import visvis as vv
from visvis import Point, Pointset
vv.figure()
a = vv.gca()
# Define points for the line
pp = Pointset(3)
pp.append(0,0,0); pp.append(0,1,0); pp.append(1,2,0); pp.append(0,2,1)
# Create all solids
box = vv.solidBox((0,0,0))
sphere = vv.solidSphere((3,0,0))
cone = vv.solidCone((6,0,0))
pyramid = vv.solidCone((9,0,0), N=4) # a cone with 4 faces is a pyramid
cylinder = vv.solidCylinder((0,3,0),(1,1,2))
ring = vv.solidRing((3,3,0))
teapot = vv.solidTeapot((6,3,0))
line = vv.solidLine(pp+Point(9,3,0), radius = 0.2)
# Let's put a face on that cylinder
# This works because 2D texture coordinates are automatically generated for
# the sphere, cone, cylinder and ring.
im = vv.imread('astronaut.png')
def apply(self):
# Get sampling
grid_sampling = self._sampling, self._sampling*2**self._levels
# Init field and deform
if not self._pp1:
# Unit deform
deform = self.DeformationField(FieldDescription(self._im))
elif self._multiscale:
deform = self.DeformationField.from_points_multiscale(self._im, grid_sampling,
self._pp1.data, self._pp2.data,
injective=self._injective, frozenedge=self._frozenedge)
else:
DeformationGrid = DeformationGridForward
if not self._forward:
DeformationGrid = DeformationGridBackward
grid = DeformationGrid.from_points(self._im, self._sampling,
self._pp1.data, self._pp2.data,
injective=self._injective, frozenedge=self._frozenedge)
deform = grid.as_deformation_field()
# Store grid
field0 = self.DeformationField(FieldDescription(self._im))
self._field2 = deform
field3 = self._field1.compose(self._field2)
# Deform
im2 = self._field1.apply_deformation(self._im)
im3 = field3.apply_deformation(self._im)
# Update imagesf
self._t2.SetData(im2)
self._t3.SetData(im3)
# Update grids
for a, field in zip( [self._a4, self._a5, self._a6],
[field0, self._field1, field3] ):
a.Clear()
field.show(a, False)
a.axis.visible = False
# Update lines
tmp = Pointset(2)
for i in range(len(self._pp1)):
tmp.append(self._pp1[i])
tmp.append(self._pp2[i])
self._line1.SetPoints(self._pp1)
self._line2.SetPoints(tmp)
# Draw
self._a2.Draw()
# Show text
text1 = 'B-spline (S) with sampling %i (U/D) and %i levels (L/R).' % (
self._sampling, self._levels)
text2 = 'Multiscale %i (M), injective %1.1f (I), frozen edge %i (E), forward %i (F).' % (
self._multiscale, self._injective, self._frozenedge, self._forward)
# Display and apply
self._text1.text = text1
self._text2.text = text2
class Drawer:
def __init__(self):
# Create figure and axes
vv.figure()
self._a = a = vv.gca()
vv.title("Hold mouse to draw lines. Use 'rgbcmyk' and '1-9' keys.")
# Set axes
a.SetLimits((0, 1), (0, 1))
a.cameraType = "2d"
a.daspectAuto = False
a.axis.showGrid = True
# Init variables needed during drawing
self._active = None
self._pp = Pointset(2)
# Create null and empty line objects
self._line1 = None
self._line2 = vv.plot(vv.Pointset(2), ls="+", lc="c", lw="2", axes=a)
# Bind to events
a.eventMouseDown.Bind(self.OnDown)
a.eventMouseUp.Bind(self.OnUp)
a.eventMotion.Bind(self.OnMotion)
a.eventKeyDown.Bind(self.OnKey)
def OnKey(self, event):
""" Called when a key is pressed down in the axes.
"""
if event.text and event.text.lower() in "rgbcmywk":
self._line2.lc = event.text.lower()
else:
try:
tickness = int(event.text)
except Exception:
tickness = 0
if tickness > 0:
self._line2.lw = tickness
def OnDown(self, event):
""" Called when the mouse is pressed down in the axes.
"""
# Only process left mouse button
if event.button != 1:
return False
# Store location
self._active = Point(event.x2d, event.y2d)
# Clear temp line object
if self._line1:
self._line1.Destroy()
# Create line objects
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(self._active)
self._line1 = vv.plot(tmp, lc="r", lw="1", axes=self._a, axesAdjust=0)
# Draw
self._a.Draw()
# Prevent dragging by indicating the event needs no further handling
return True
def OnMotion(self, event):
""" Called when the mouse is moved in the axes.
"""
if self._active and self._line1:
# Update line
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(event.x2d, event.y2d)
self._line1.SetPoints(tmp)
# Draw
self._a.Draw()
def OnUp(self, event):
""" Called when the mouse is released (when first pressed down
in the axes).
"""
# Only if a point is active
if self._active is None:
return False
# Get points
p1 = self._active
p2 = Point(event.x2d, event.y2d)
# Add!
self._pp.append(p1)
self._pp.append(p2)
# We're done with this one
self._active = None
# Clear temp line object
if self._line1:
self._line1.Destroy()
self._line1 = None
# Update lines
self._line2.SetPoints(self._pp)
# Draw
self._a.Draw()
class SplineByHand:
""" SplineByHand()
Demo application to influence a 1D spline grid using control points.
"""
def __init__(self):
# Setup visualization
self._fig = fig = vv.figure()
self._a1 = a1 = vv.subplot(111)
# Init pointset with control points
self._pp = Pointset(2)
# Init lines to show control points
self._line1 = vv.plot(self._pp, ls='', ms='.', mc='r', mw=11, axes=a1)
self._line1.hitTest = True
# Init grid properties
self._fieldSize = 100
self._sampling = 10
self._levels = 5
# Member to indicate the point being dragged (as an index)
self._active = None
# Bind to events
a1.eventDoubleClick.Bind(self.on_doubleclick)
self._line1.eventDoubleClick.Bind(self.on_doubleclick_line)
self._line1.eventMouseDown.Bind(self.on_down_line)
self._line1.eventMouseUp.Bind(self.on_up_line)
a1.eventMotion.Bind(self.on_motion)
fig.eventKeyDown.Bind(self.on_key_down)
print(
'Use left/right to control #levels and up/down to control grid sampling.'
)
# Init
self.apply()
a1.daspectAuto = False
a1.SetLimits()
a1.axis.showGrid = True
def on_key_down(self, event):
# Update level
if event.key == vv.KEY_UP:
self._sampling += 1
elif event.key == vv.KEY_DOWN:
self._sampling -= 1
elif event.key == vv.KEY_RIGHT:
self._levels += 1
elif event.key == vv.KEY_LEFT:
self._levels -= 1
else:
return
# Correct
if self._sampling < 1:
self._sampling = 1
# Apply and print
print('Using B-spline grid with %i sampling and %i levels.' %
(self._sampling, self._levels))
self.apply()
def on_doubleclick(self, event): # On axes
# Get new point
p = Point(event.x2d, event.y2d)
# Add to pointset
self._pp.append(p)
self._line1.SetPoints(self._pp)
# Apply
self.apply()
def on_doubleclick_line(self, event): # On axes
# Get closest point
dists = Point(event.x2d, event.y2d).distance(self._pp)
I, = np.where(dists == dists.min())
if not len(I):
return False
# Remove from pointset
self._pp.Pop(I[0])
self._line1.SetPoints(self._pp)
# Apply
self._a1.Draw()
self.apply()
def on_down_line(self, event): # On line instance
if event.button != 1:
return False
# Get closest point
dists = Point(event.x2d, event.y2d).distance(self._pp)
I, = np.where(dists == dists.min())
if not len(I):
return False
# Store
self._active = I[0]
# Prevent dragging by indicating the event needs no further handling
return True
def on_motion(self, event):
if self._active is None:
return False
# Update line
self._pp[self._active] = Point(event.x2d, event.y2d)
self._line1.SetPoints(self._pp)
# Draw
self._a1.Draw()
def on_up_line(self, event):
if self._active is None:
return False
# Update point
self.on_motion(event)
# Deactivate
self._active = None
# Apply
self.apply()
def apply(self, event=None):
# Get axes
a1 = self._a1
# Get sampling
grid_sampling = self._sampling, self._sampling * 2**self._levels
# Create grid
tmp = self._pp[:, 0]
tmp.shape = (tmp.size, 1)
pp = Pointset(tmp)
grid1 = SplineGrid.from_points_multiscale(
(self._fieldSize, ), grid_sampling, pp.data, self._pp[:, 1])
# Get copy
grid2 = grid1.copy()
# Freeze edges
self.freeze_edges(grid1)
# # Create second grid
# grid2 = SplineGrid.from_field(grid.get_field(), grid.grid_sampling)
# grid3 = SplineGrid.from_field_multiscale(grid.get_field(), grid.grid_sampling)
# Get grid points
ppg1 = Pointset(2)
ppg2 = Pointset(2)
for gx in range(grid1.grid_shape[0]):
ppg1.append((gx - 1) * grid1.grid_sampling, grid1.knots[gx])
ppg2.append((gx - 1) * grid2.grid_sampling, grid2.knots[gx])
# Get field
field = grid1.get_field()
#field2 = grid2.get_field()
#field3 = grid3.get_field()
# Delete objects in scene
for ob in a1.wobjects:
if ob is not self._line1 and not isinstance(
ob, vv.axises.BaseAxis):
ob.Destroy()
# Draw
vv.plot(ppg1, ls='', ms='x', mc='b', mw=9, axes=a1, axesAdjust=False)
vv.plot(ppg2, ls='', ms='x', mc='c', mw=9, axes=a1, axesAdjust=False)
vv.plot(np.arange(0, field.size),
field,
ls='-',
lc='g',
lw=3,
axes=a1,
axesAdjust=False)
#vv.plot(field2, ls=':', lc=(0,0.5,0), lw=6, axes=a1, axesAdjust=False)
#vv.plot(field3, ls=':', lc=(0,0.75,0), lw=6, axes=a1, axesAdjust=False)
def freeze_edges(self, grid):
# Store grid for debugging
self._grid = grid
# Freeze left edge
grid.knots[1] = 0
grid.knots[0] = -grid.knots[2]
# c0, c1, c2, c3 = pirt.get_cubic_spline_coefs(0, 'B')
# k1, k2, k3 = grid.knots[0], grid.knots[1], grid.knots[2]
# grid.knots[0] = 0
# grid.knots[1]=0
# grid.knots[2]= )
# Calculate t factor
field_edge = (grid.field_shape[0] - 1) * grid.field_sampling[0]
grid_edge = (grid.grid_shape[0] - 4) * grid.grid_sampling
t = (field_edge - grid_edge) / grid.grid_sampling
# Get coefficients
c0, c1, c2, c3 = interp.get_cubic_spline_coefs(t, 'B')
# Freeze right edge
# grid.knots[-3] = t*grid.knots[-3] # + (1-t)*0
# k0, k1 = grid.knots[-4], grid.knots[-3]
# grid.knots[-2] = t**2 * (k1-k0) + t*(2*k0-k1) - k0
# k0, k1, k2, k3 = grid.knots[-4], grid.knots[-3], grid.knots[-2], grid.knots[-1]
# grid.knots[-1] = -(k0*c0 + k1*c1 + k2*c2)/c3
grid.knots[-3] = t * grid.knots[-3] # + (1-t)*0
grid.knots[-1] = 0
k0, k1 = grid.knots[-4], grid.knots[-3]
grid.knots[-2] = -(k0 * c0 + k1 * c1) / c2
plain color, colormaps and texture.
On the website, this example also demonstrates the fly camera to fly through
the mesh objects.
"""
import numpy as np
import visvis as vv
from visvis import Point, Pointset
vv.figure()
a = vv.gca()
# Define points for the line
pp = Pointset(3)
pp.append(0,0,0); pp.append(0,1,0); pp.append(1,2,0); pp.append(0,2,1)
# Create all solids
box = vv.solidBox((0,0,0))
sphere = vv.solidSphere((3,0,0))
cone = vv.solidCone((6,0,0))
pyramid = vv.solidCone((9,0,0), N=4) # a cone with 4 faces is a pyramid
cylinder = vv.solidCylinder((0,3,0),(1,1,2))
ring = vv.solidRing((3,3,0))
teapot = vv.solidTeapot((6,3,0))
line = vv.solidLine(pp+Point(9,3,0), radius = 0.2)
# Let's put a face on that cylinder
# This works because 2D texture coordinates are automatically generated for
# the sphere, cone, cylinder and ring.
im = vv.imread('lena.png')
class DeformByHand:
""" DeformByHand(im, grid_sampling=40)
Demo application to deform a 2D image by hand using a spline grid.
Use the grid property to obtain the deformation grid.
Use the run() method to wait for the user to close the figure.
"""
def __init__(self, im, grid_sampling=40):
# Store image
self._im = im
# Setup visualization
self._fig = fig = vv.figure()
self._a1 = a1 = vv.subplot(231);
self._a2 = a2 = vv.subplot(232);
self._a3 = a3 = vv.subplot(233);
self._a4 = a4 = vv.subplot(234);
self._a5 = a5 = vv.subplot(235);
self._a6 = a6 = vv.subplot(236);
# Text objects
self._text1 = vv.Label(fig)
self._text1.position = 5, 2
self._text2 = vv.Label(fig)
self._text2.position = 5, 20
# Move axes
a1.parent.position = 0.0, 0.1, 0.33, 0.45
a2.parent.position = 0.33, 0.1, 0.33, 0.45
a3.parent.position = 0.66, 0.1, 0.33, 0.45
a4.parent.position = 0.0, 0.55, 0.33, 0.45
a5.parent.position = 0.33, 0.55, 0.33, 0.45
a6.parent.position = 0.66, 0.55, 0.33, 0.45
# Correct axes, share camera
cam = vv.cameras.TwoDCamera()
for a in [a1, a2, a3, a4, a5, a6]:
a.axis.visible = False
a.camera = cam
# Show images
im0 = im*0
self._t1 = vv.imshow(im, axes=a1)
self._t2 = vv.imshow(im, axes=a2)
self._t3 = vv.imshow(im, axes=a3)
self._t4 = vv.imshow(im0, axes=a4)
self._t5 = vv.imshow(im0, axes=a5)
self._t6 = vv.imshow(im0, axes=a6)
# Init pointsets
self._pp1 = Pointset(2)
self._pp2 = Pointset(2)
self._active = None
self._lines = []
# Init lines to show all deformations
tmp = vv.Pointset(2)
self._line1 = vv.plot(tmp, ls='', ms='.', mc='c', axes=a2)
self._line2 = vv.plot(tmp, ls='+', lc='c', lw='2', axes=a2)
# Init grid properties
self._sampling = grid_sampling
self._levels = 5
self._multiscale = True
self._injective = 0.5
self._frozenedge = 1
self._forward = True
# Init grid
self.DeformationField = DeformationFieldForward
self._field1 = self.DeformationField(FieldDescription(self._im))
self._field2 = self.DeformationField(FieldDescription(self._im))
# Bind to events
a2.eventMouseDown.Bind(self.on_down)
a2.eventMouseUp.Bind(self.on_up)
a2.eventMotion.Bind(self.on_motion)
fig.eventKeyDown.Bind(self.on_key_down)
#a1.eventDoubleClick.Bind(self.OnDone)
# Apply
self.apply()
def on_key_down(self, event):
# Update level
if event.key == vv.KEY_UP:
self._sampling += 2
elif event.key == vv.KEY_DOWN:
self._sampling -= 2
elif event.key == vv.KEY_RIGHT:
self._levels += 1
elif event.key == vv.KEY_LEFT:
self._levels -= 1
#
elif event.text.upper() == 'M':
self._multiscale = not self._multiscale
elif event.text.upper() == 'I':
self._injective += 0.4
if self._injective > 0.8:
self._injective = -0.8
elif event.text.upper() == 'E':
self._frozenedge = not self._frozenedge
elif event.text.upper() == 'F':
self._forward = not self._forward
# reset global field
if self._forward:
self.DeformationField = DeformationFieldForward
else:
self.DeformationField = DeformationFieldBackward
self._field1 = self.DeformationField(FieldDescription(self._im))
#
elif event.key == vv.KEY_ESCAPE:
self._pp1.clear()
self._pp2.clear()
self.apply()
elif event.text == ' ':
self.apply_deform()
#
else:
return
# Correct
if self._sampling < 1:
self._sampling = 1
self.apply()
def on_down(self, event):
if event.button != 1:
return False
if not vv.KEY_SHIFT in event.modifiers:
return False
# Store location
self._active = Point(event.x2d, event.y2d)
# Clear any line object
for l in self._lines:
l.Destroy()
# Create line objects
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(self._active)
l1 = vv.plot(tmp, lc='g', lw='3', axes=self._a2, axesAdjust=0)
l2 = vv.plot(tmp[:1], ls='', ms='.', mc='g', axes=self._a2, axesAdjust=0)
self._lines = [l1, l2]
# Draw
self._a2.Draw()
# Prevent dragging by indicating the event needs no further handling
return True
def on_motion(self, event):
if self._active and self._lines:
# Update line
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(event.x2d, event.y2d)
l1 = self._lines[0]
l1.SetPoints(tmp)
# Draw
self._a2.Draw()
def on_up(self, event):
if self._active is None:
return False
# Get points
p1 = self._active
p2 = Point(event.x2d, event.y2d)
# Add!
self._pp1.append(p1)
self._pp2.append(p2)
# We're done with this one
self._active = None
# Clear any line object
for l in self._lines:
l.Destroy()
# Apply
self.apply()
def apply_deform(self):
# Apply current point-wise deformation
# Compose deformations
self._field1 = self._field1.compose(self._field2)
# Clear points
self._pp1.clear()
self._pp2.clear()
# Update
self.apply()
def apply(self):
# Get sampling
grid_sampling = self._sampling, self._sampling*2**self._levels
# Init field and deform
if not self._pp1:
# Unit deform
deform = self.DeformationField(FieldDescription(self._im))
elif self._multiscale:
deform = self.DeformationField.from_points_multiscale(self._im, grid_sampling,
self._pp1.data, self._pp2.data,
injective=self._injective, frozenedge=self._frozenedge)
else:
DeformationGrid = DeformationGridForward
if not self._forward:
DeformationGrid = DeformationGridBackward
grid = DeformationGrid.from_points(self._im, self._sampling,
self._pp1.data, self._pp2.data,
injective=self._injective, frozenedge=self._frozenedge)
deform = grid.as_deformation_field()
# Store grid
field0 = self.DeformationField(FieldDescription(self._im))
self._field2 = deform
field3 = self._field1.compose(self._field2)
# Deform
im2 = self._field1.apply_deformation(self._im)
im3 = field3.apply_deformation(self._im)
# Update imagesf
self._t2.SetData(im2)
self._t3.SetData(im3)
# Update grids
for a, field in zip( [self._a4, self._a5, self._a6],
[field0, self._field1, field3] ):
a.Clear()
field.show(a, False)
a.axis.visible = False
# Update lines
tmp = Pointset(2)
for i in range(len(self._pp1)):
tmp.append(self._pp1[i])
tmp.append(self._pp2[i])
self._line1.SetPoints(self._pp1)
self._line2.SetPoints(tmp)
# Draw
self._a2.Draw()
# Show text
text1 = 'B-spline (S) with sampling %i (U/D) and %i levels (L/R).' % (
self._sampling, self._levels)
text2 = 'Multiscale %i (M), injective %1.1f (I), frozen edge %i (E), forward %i (F).' % (
self._multiscale, self._injective, self._frozenedge, self._forward)
# Display and apply
self._text1.text = text1
self._text2.text = text2
@property
def field(self):
return self._field1
def run(self):
# Setup detecting closing of figure
self._closed = False
def callback(event):
self._closed = True
self._fig.eventClose.Bind(callback)
while not self._closed:
time.sleep(0.02)
vv.processEvents()
self.apply_deform()
On the website, this example also demonstrates the fly camera to fly through the mesh objects. """ import numpy as np import visvis as vv from visvis import Point, Pointset vv.figure() a = vv.gca() # Define points for the line pp = Pointset(3) pp.append(0, 0, 0) pp.append(0, 1, 0) pp.append(1, 2, 0) pp.append(0, 2, 1) # Create all solids box = vv.solidBox((0, 0, 0)) sphere = vv.solidSphere((3, 0, 0)) cone = vv.solidCone((6, 0, 0)) pyramid = vv.solidCone((9, 0, 0), N=4) # a cone with 4 faces is a pyramid cylinder = vv.solidCylinder((0, 3, 0), (1, 1, 2)) ring = vv.solidRing((3, 3, 0)) teapot = vv.solidTeapot((6, 3, 0)) line = vv.solidLine(pp + Point(9, 3, 0), radius=0.2) # Let's put a face on that cylinder
def compareGraphs(graph1, graph2, maxDist):
""" compareGraphs(graph1, graph2, maxDist)
Compare two graphs to produce a matching score. Returns a MatchingScore
instance.
Matching and not-matching edges are counted to obtain a matching
score. nodes should be closer than maxDist to be considered 'at the
same location'.
"""
# Check graphs
if not graph1 or not graph2:
print('Warning: one of the graphs to compare is empty.')
return MatchingScore(0,1,0)
#raise ValueError('One of the graphs to compare is empty.')
# Create pointsets of the nodes
pp1 = Pointset(3)
for node in graph1:
pp1.append(node)
pp2 = Pointset(3)
for node in graph2:
pp2.append(node)
# Match the nodes of graph1 to graph2
for node in graph1:
dists = node.distance(pp2)
i, = np.where(dists==dists.min())
node.match = None
if len(i):
i = int(i[0])
dist = float(dists[i])
if dist < maxDist:
node.match = graph2[i]
# if not hasattr(node, 'dontCare'):
# node.dontCare = False
# Match the nodes of graph2 to graph1
for node in graph2:
dists = node.distance(pp1)
i, = np.where(dists==dists.min())
node.match = None
if len(i):
i = int(i[0])
dist = float(dists[i])
if dist < maxDist:
node.match = graph1[i]
# if not hasattr(node, 'dontCare'):
# node.dontCare = False
# Init amounts
nmatch1, nmatch2, nmiss, nwrong = 0,0,0,0
# Count matches and wrongs
for c in graph1.GetEdges():
end1 = c.end1.match
end2 = c.end2.match
if end1 and end2:
if end1 in end2.GetNeighbours():
nmatch1 += 1
continue
# elif c.end1.dontCare or c.end2.dontCare:
# continue
nwrong += 1
# todo: use dontCare 'beleid' or not?
# Count matches and misses
for c in graph2.GetEdges():
end1 = c.end1.match
end2 = c.end2.match
if end1 and end2:
if end1 in end2.GetNeighbours():
nmatch2 += 1
continue
# elif c.end1.dontCare or c.end2.dontCare:
# continue
nmiss += 1
# Compose score
return MatchingScore(nmatch1, nmiss, nwrong)
class Drawer:
def __init__(self):
# Create figure and axes
vv.figure()
self._a = a = vv.gca()
vv.title("Hold mouse to draw lines. Use 'rgbcmyk' and '1-9' keys.")
# Set axes
a.SetLimits((0,1), (0,1))
a.cameraType = '2d'
a.daspectAuto = False
a.axis.showGrid = True
# Init variables needed during drawing
self._active = None
self._pp = Pointset(2)
# Create null and empty line objects
self._line1 = None
self._line2 = vv.plot(vv.Pointset(2), ls='+', lc='c', lw='2', axes=a)
# Bind to events
a.eventMouseDown.Bind(self.OnDown)
a.eventMouseUp.Bind(self.OnUp)
a.eventMotion.Bind(self.OnMotion)
a.eventKeyDown.Bind(self.OnKey)
def OnKey(self, event):
""" Called when a key is pressed down in the axes.
"""
if event.text and event.text.lower() in 'rgbcmywk':
self._line2.lc = event.text.lower()
else:
try:
tickness = int(event.text)
except Exception:
tickness = 0
if tickness > 0:
self._line2.lw = tickness
def OnDown(self, event):
""" Called when the mouse is pressed down in the axes.
"""
# Only process left mouse button
if event.button != 1:
return False
# Store location
self._active = Point(event.x2d, event.y2d)
# Clear temp line object
if self._line1:
self._line1.Destroy()
# Create line objects
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(self._active)
self._line1 = vv.plot(tmp, lc='r', lw='1', axes=self._a, axesAdjust=0)
# Draw
self._a.Draw()
# Prevent dragging by indicating the event needs no further handling
return True
def OnMotion(self, event):
""" Called when the mouse is moved in the axes.
"""
if self._active and self._line1:
# Update line
tmp = Pointset(2)
tmp.append(self._active)
tmp.append(event.x2d, event.y2d)
self._line1.SetPoints(tmp)
# Draw
self._a.Draw()
def OnUp(self, event):
""" Called when the mouse is released (when first pressed down
in the axes).
"""
# Only if a point is active
if self._active is None:
return False
# Get points
p1 = self._active
p2 = Point(event.x2d, event.y2d)
# Add!
self._pp.append(p1)
self._pp.append(p2)
# We're done with this one
self._active = None
# Clear temp line object
if self._line1:
self._line1.Destroy()
self._line1 = None
# Update lines
self._line2.SetPoints(self._pp)
# Draw
self._a.Draw()
def compareGraphs(graph1, graph2, maxDist):
""" compareGraphs(graph1, graph2, maxDist)
Compare two graphs to produce a matching score. Returns a MatchingScore
instance.
Matching and not-matching edges are counted to obtain a matching
score. nodes should be closer than maxDist to be considered 'at the
same location'.
"""
# Check graphs
if not graph1 or not graph2:
print('Warning: one of the graphs to compare is empty.')
return MatchingScore(0,1,0)
#raise ValueError('One of the graphs to compare is empty.')
# Create pointsets of the nodes
pp1 = Pointset(3)
for node in graph1:
pp1.append(node)
pp2 = Pointset(3)
for node in graph2:
pp2.append(node)
# Match the nodes of graph1 to graph2
for node in graph1:
dists = node.distance(pp2)
i, = np.where(dists==dists.min())
node.match = None
if len(i):
i = int(i[0])
dist = float(dists[i])
if dist < maxDist:
node.match = graph2[i]
# if not hasattr(node, 'dontCare'):
# node.dontCare = False
# Match the nodes of graph2 to graph1
for node in graph2:
dists = node.distance(pp1)
i, = np.where(dists==dists.min())
node.match = None
if len(i):
i = int(i[0])
dist = float(dists[i])
if dist < maxDist:
node.match = graph1[i]
# if not hasattr(node, 'dontCare'):
# node.dontCare = False
# Init amounts
nmatch1, nmatch2, nmiss, nwrong = 0,0,0,0
# Count matches and wrongs
for c in graph1.GetEdges():
end1 = c.end1.match
end2 = c.end2.match
if end1 and end2:
if end1 in end2.GetNeighbours():
nmatch1 += 1
continue
# elif c.end1.dontCare or c.end2.dontCare:
# continue
nwrong += 1
# todo: use dontCare 'beleid' or not?
# Count matches and misses
for c in graph2.GetEdges():
end1 = c.end1.match
end2 = c.end2.match
if end1 and end2:
if end1 in end2.GetNeighbours():
nmatch2 += 1
continue
# elif c.end1.dontCare or c.end2.dontCare:
# continue
nmiss += 1
# Compose score
return MatchingScore(nmatch1, nmiss, nwrong)