Figures marked with this icon are best examined on-screen with red(left)-cyan(right) anaglyph glasses.
Anaglyph images and animated SVGs should render correctly in Chrome.
This supplemental material provides additional, larger, extended or animated versions of figures from our main paper.
Position in this illustration corresponds to the view position in the multiview window.
Visibility and occlusion are correctly resolved for each corresponding viewpoint.
The depicted objects are rotationally symmetric, the asymmetric distortions in the left and right images originate from the camera's skewed view frustum.
A rough mesh [Ble16] and large camera offsets cause artifacts in the multiview window.
Especially Suzanne's eyebrows float around wildly: For illustration purposes they are highlighted red and magenta respectively.
One way to avoid the artifacts from the Figure above is a smaller multiview window. The employed mesh was again Suzanne [Ble16].
For this example, the multiview window setup was identical to Figure 2.
The mesh resolution of the Stanford Bunny [Sta14] is much higher than Suzanne's and therefore produces less artifacts due to incorrect matching.
(a)
(b)
(c)
(d)
(e)
(f)
Anaglyph colors only underline the stereo context, center-view contours are shown in gray.
(a) Wireframe of the used icosphere model [Ble16].
(b) Original contours.
(c) Synthetic left and right contours are equal to (b).
(d) Experimental concept for stereo-consistency.
(e) Revised stereo-consistency concept with artifact.
(d) Final result, artifacts of (e) are resolved.
Minimalistic depth information with silhouette contours only. Object Source: Head [McG11]
individual
consistent
Stereo-consistent silhouette contours and suggestive contours.
In the bottom right corner of the right image there is a one tiny line which only occurs in the left eye.
Here it appears that the view-dependent image space intersections unfortunately cut of too much information for proper visibility propagation (Section 5.3).
Object Source: Brain [DFRS03]
Stereo-consistent silhouette contours, suggestive contours and creases.
The Venus [Sta05] actually intersected the image plane which causes the head and upper torso to stand out of the screen space.
Results of an experimental multiview cube which extends the multiview window with forward and backward offset vectors in the cameras view direction.
Since the view plane is fixed, this results in a change of focal length. Object Source: Stanford Bunny [Sta14]
100%
75%
125%
50%
150%
25%
175%
0%
200%
Silhouette and suggestive contours on a Screwdriver [INR04].
Stereo offset vectors are scaled with a factor ∈[0,2] which results as scaled disparity.
Left and right viewpoints are actually outside of the multiview window when the disparity is larger than 100%. Results are stereo-consistent nevertheless.
Simple stereo-consistent line drawings are shown on the left.
On the right are examples with stylization, using relative z-depth as attribute for the stroke width.
While the bunny on the left is perfectly stereo-consistent the stylization code unfortunately collapsed a few very short lines though it operated on exactly the same segments as the picture on the left.
Object Source: Stanford Bunny [Sta14]
Arbitrary camera motion: Concatenated multiview windows of key-cameras positioned in a circle around a trefoil knot and the Utah Teapot [Kno14] respectively.
Animations on the left are created with 48 key-cameras and 10 interpolated steps, on the right with 96 key-cameras and 5 interpolated steps inbetween respectively.
Note on the top right of the teapot occasional artifacts are visible due to matching errors between contour points (Section 3.1).
Higher tessellation of the input mesh could resolve these issues.
If animations appear choppy, click on it to open the stand-alone SVG directly.
Stereo-consistent fly-around from two different elevation angles.
Small artifacts can be observed in the left animation when the circular cross-section of the middle arc becomes visible, as drastic topological changes prevent correct contour matching (Section 3.4).
If animations appear choppy, click on it to open the stand-alone SVG directly.
Stereo-consistent fly-around in a multiview window.
Object Sources: Stanford Bunny [Sta14], Max Planck Bust [DFRS03]
The employed rules to resolve ambiguous visibility states in the view graph are derived from observations and therefore come without warranty of completeness or proof of correctness.
The following algorithm formulates how these rules are applied to the graph incrementally.
Let n be the node in question with two neighbors n.left, n.right and a junction pointer n.junction.
Possible states of visibility for n.visible are True, False and None, where the latter one is obviously the ambiguous state.
The first branch (line 1-2) of the condition tree in the code above sets an ambiguous node to the state of its neighbors if they have the same state.
In the next branch (line 3), the junction of an ambiguous node becomes relevant.
If the junction is visible (line 4), a cloned node is created with inverted visibility.
This models the case that visibility actually changes along a chain if the corresponding polyline is partly occluded.
If the junction is not visible (line 15), the ambiguous node inherits a ≠None-state from its neighbors with preference on True.
The last branch (line 23) is reached if one or both neighbors are in an ambiguous state and the junction as well.
This state is not yet resolvable but as the algorithm is continues, there may be a solution after some iterations.
If not, then the graph may contains specific constellations called bridges.
Their detection and special treatment is introduced in the following.
The following algorithm determines chains of the view graph which contain ambiguous nodes and selectively applies measures to resolve them.
The function resolveAmbiguousVisibilities() returns a boolean that states if one of the operations from the algorithm above could be applied, otherwise the chain was not altered.
01 while True:
02 cIdxs = []
03 for i,chain in enumerate(chains):
04 if chain.containsAmbiguousVisibilities():
05 cIdxs.append(i)
06 if cIdxs == []:
07 break
08 unchanged = []
09 for cIdx in cIdxs:
10 unchanged.append(chains[cIdx].resolveAmbiguousVisibilities())
11 if all(unchanged):
12 for cIdx in cIdxs:
13 chains[cIdx].resolveAmbiguousVisibilitiesAtBridges()
If there are ambiguities but not a single chain could be altered then there was obviously no progress.
This is detected in line 11 of the algorithm above, the specialized function resolveAmbiguousVisibilitiesAtBridges() is applied on affected chains.
The following code describes the functionality of resolveAmbiguousVisibilitiesAtBridges().
01 if n.visible is None:
02 if n.left.visible == None:
03 if n.right.visible != None:
04 n.visible = n.right.visible
05 elif n.right.visible == None:
06 if n.left.visible != None:
07 n.visible = n.left.visible
08 elif n.junction.visible == None:
09 if n.left.visible != n.right.visible \
10 and n.junction.left.visible != n.junction.right.visible:
11 n.visible = True
12 n.junction.visible = True
Resolving bridges is a the ultima ratio and is not treated equally to simpler cases.
However, resolved bridges do not necessarily end the incremenal algorithm.
After bridges are resolved, normal processing can continue.
[Ble16]
Blender Online Community. Blender - a 3D modelling and rendering package.
Blender Foundation, Blender Institute, Amsterdam, 2016. Online; accessed August-2016, http://www.blender.org.
Figures marked with this icon are best examined on-screen with red(left)-cyan(right) anaglyph glasses.
