Volume Haptic Rendering with Dynamically Extracted Isosurface Loic Corenthy∗
Jose San Martin†
Miguel A. Otaduy‡
Universidad Politecnica de Madrid
Universidad Rey Juan Carlos
Universidad Rey Juan Carlos
Marcos Garcia § Universidad Rey Juan Carlos
A BSTRACT Haptic interfaces offer an intuitive way to interact with and manipulate 3D data, and may simplify the interpretation of visual information. This work proposes an algorithm to provide haptic feedback directly from volumetric data sets, as an aid to regular visualization. The haptic rendering algorithm lets the user perceive isosurfaces in the volumetric data, and it relies on several design features that ensure a robust and efficient rendering. Robustness is derived from existing proxy-based methods. The presented algorithm adds a novel continuous collision detection based on dynamic extraction of isosurfaces in tetrahedral meshes in order to avoid fall-through of surfaces. The isosurface is extracted dynamically in a local manner, hence there is no need to construct and store the full isosurface, thereby reducing both computational cost and storage at the same time. Isosurfaces are defined by interpolating a density field on tetrahedral meshes. The use of tetrahedral meshes guarantees continuity and watertightness of the isosurface, and it also enables smooth transitions between isosurface values. 1
I NTRODUCTION
Volumetric data representations are very popular among the scientific community, notably in medicine, thanks to acquisition techniques such as Magnetic Resonance Imaging (MRI), Nuclear Magnetic Resonance Imaging (NMRI), Computed Tomography (CT) or Confocal Microscopy Visualization [1, 2]. Unfortunately, the interpretation of dense volumetric data sets using graphical display tools is usually a complex task. It is particularly difficult to select data of interest from a large reference set. Haptic interfaces offer a simple way to interact with and manipulate 3D data, and there are many successful examples that combine visual and haptic interfaces for scientific visualization of multidimensional data and manipulation of large data sets, helping in research and comprehension tasks [3–9]. In the case of volumetric data, volume haptics complement the visual cues of volume graphics, providing help in guidance and an improvement in information analysis [10]. The computation and display of forces that result from the interaction with digital objects or data sets is referred to as haptic rendering [11]. In this paper, a robust algorithm for haptic rendering of volumetric data is presented. Robustness refers here to the algorithm capacity to avoid fall-through problems. The algorithm is based on the navigation along isosurfaces. Coherent structures in the data are typically characterized by clusters of points with similar data ∗ e-mail:
[email protected] [email protected] ‡ e-mail:
[email protected] § e-mail:
[email protected] † e-mail:
values, therefore the navigation along isosurfaces may help users in their understanding of the structure of the volumetric data. This algorithm was designed according to the following desiderata: 1. Isosurface navigation must be free of fall-through problems. 2. It should allow the exploration of the full dataset, both in space and range of values, to enable the identification of potential structures at different isovalues. 3. The isovalues of interest may not be known in advance, i.e. no data dependent pre-computation is necessary. 4. It must be computationally efficient, to ensure hard real-time haptic updates. 5. It should support local modifications to the data, as well as time-varying data. The algorithm fulfills all the previous features thanks to the following properties: • Even though the algorithm relies only on local data, the underlying isosurface is continuous. This property, combined with a novel continuous collision detection algorithm, prevents fall-through problems, feature 1. • Isosurfaces are extracted dynamically. A penetrability approach allows dynamic and intuitive modifications of the target isovalue. These are essential for features 2, 3 and 5 above. • Each step of the rendering algorithm extracts only a local portion of isosurface, which ensures computational efficiency, feature 4. • The isosurface changes smoothly in response to changes in the target isovalue, again helping the ability to explore the complete dataset. This is relevant to features 2 and 3. This paper is organized as follows. Section 2 presents the related works on which this implementation leaned upon. Section 3 describes first the tetrahedral tessellation to define a piece-wise linear reconstruction of a scalar field sampled on regular grid points. Then the local extraction of the isosurface is introduced. The extraction is based on the current location of the haptic probe and a desired isosurface value dynamically defined by the user. Section 4 explains and describes the proposed algorithm. It builds on existing constraint-based algorithms [12,13] and adds a robust novel continuous collision detection algorithm for isosurfaces defined dynamically on tetrahedral meshes. In section 5, the constraint-based algorithm is extended with a penetrability approach, which allows intuitive navigation of isosurfaces at different isovalues. Finally, section 6 presents the results of the evaluation of the algorithm. First, robustness is tested through an experiment which evaluates the error made by our method when following an isosurface. Performance is also verified by running the algorithm on various volume data sets.
2
R ELATED W ORK
Volume haptic rendering methods can be largely classified into two categories, those that render only local information, and those that try to convey structural information. Local methods process the data value at the location of the haptic probe, and display to the user a force as a function of the data value [5, 14]. The main advantage of these methods is that they are able to render many different types of data, e.g., scalar, vector or tensor data, and they are typically intended as a way to provide supplementary channels for high-dimensional data. However, their main disadvantages are the difficulty to convey global structure and the fact that the displayed force may disrupt the user’s intent, because it is difficult to remain stationary at a point of interest while the user perceives a constant force. Global methods, on the other hand, typically render isosurfaces on the volumetric data set and let the user change the desired isosurface value [15]. The user may navigate along isosurfaces, thereby obtaining global information about the structure of the data. Due to the use of isosurfaces, they work best with scalar data, or they need some conversion from high-dimensional data to scalar values. Early methods used transfer functions to convey isosurface information [16]. But, similar to the works in visual rendering, isosurfaces may be easily defined on regular grids using the marching cubes (MC) algorithm [17] or some of its variants. Limitations of standard MC, such as topological ambiguity [18], have been widely discussed in different studies, and several solutions have been proposed [19,20]. Nevertheless, these corrections imply increasing the complexity of the algorithm as well as the computational cost. One option to produce a continuous reconstruction of a scalar field in 3D could be the use of bilinear interpolation. The resulting isosurfaces are not linear. There exist haptic rendering algorithms for parametric surfaces, but they require solving costly root finding problems [21]. In [22], Li et al. introduced a method to reconstruct a C1 distance field from discretely sampled distances and gradients. Their algorithm is based on a Coons-patch interpolation method. The C1 property is better than the C0 obtained with barycentric interpolation and tetrahedral decomposition. Nevertheless, it implies pre computation of the distance field which does not meet with our requirements. It is also possible to use a marching tetrahedra (MT) algorithm for isosurface extraction from tetrahedral meshes [23–25]. Unlike MC, MT ensures the continuity of the isosurface without additional processing step to correct any possible topological ambiguity. The minimal decomposition produces five tetrahedra per voxel, but it suffers from anisotropy and is not uniquely defined [18]. Instead, the implementation adapts the body-centered cubic (BCC) lattice [26], which uses the center of the voxel as common vertex for all tetrahedra and yields a symmetric tessellation. Patera et al. [27] also show that the BCC behaves well when dealing with noisy data. However, independently of the voxel subdivision, MT can suffer from inaccurate curvature change throughout or inside one voxel. Finally, considering watertightness and low computational cost as our main requirements, the isosurface extraction of our algorithm as been implemented using a tetrahedral tessellation. Thanks to the locality of volume haptic rendering, it is not necessary to extract the full isosurface. Previous approaches consider the definition of a local virtual plane as an intermediate representation of the isosurface [28], or a local polygonal mesh [29]. The same strategy is followed here and the isosurface is not reconstructed as an explicit surface mesh, but instead as a local representation dynamically extracted. However, as already addressed, we extract the isosurface from a tetrahedral tessellation, instead of doing it directly from the cubic lattice as done before by others. The work of Palmerius et al. [10, 30, 31] is relevant in the area of volume haptic rendering. Their work combines isosurface render-
Figure 1: Modified BCC lattice. Red points: original vertices - Blue points: additional vertices
ing with dynamic adaptation of the isosurface using the concept of penetrability, to naturally give the user global information. Their algorithm uses a Gradient-Based Isosurface Definition (GBID), i.e. the reconstructed isosurface only depends on the gradient at the current position. Others have introduced additional modifications [32]. Despite the benefits of their approach, it also suffers some limitations, because the isosurface is not guaranteed to be continuous at voxel transitions. Our approach, based on isosurface extraction from a tetrahedral grid, ensures surface continuity. In [33], Chan et al. introduced a method for 6 DOF haptic rendering. Their constraint-based approach, also based on an isosurface calculation, allows the simulation of a three dimensional proxy. Similarly to our work, the update of the proxy is discretized to ensure that the isosurface is never missed. However, their implementation requires a final optimization of the proxy position, reducing the displacement of the proxy at each iteration of the algorithm until this displacement is considered small enough. In our implementation instead, the proxy moves from tetrahedron to tetrahedron (i.e. a constant displacement) until reaching the right position. 3
I SOSURFACE D EFINITION
The input data is assumed to be a scalar field sampled regularly on a cubic lattice. Given this input, we discuss here the extraction of a piecewise linear isosurface using a tetrahedral lattice, and the computation of the isosurface normal from precomputed barycentric interpolation matrices. 3.1
Cube subdivision into a tetrahedral lattice
As addressed in the previous section, the regular cubic lattice is decomposed into tetrahedra. The voxel subdivision into tetrahedra implemented here adds vertices to the BCC lattice. The additional vertices are placed at the centers of the voxel faces, see Fig. 1. This modification allows the isosurface extraction algorithm to deal with a unique voxel at a time instead of two as it is the case with the regular BCC lattice whose tetrahedra span two voxels. The scalar values at the extra vertices are determined using bilinear and trilinear interpolation. This tetrahedral decomposition produces 24 tetrahedra per voxel and is symmetric. Figures 2a and 2b illustrate the decomposition in 2 steps for an easier representation. 3.2
Isosurface extraction
Barycentric interpolation is performed inside each tetrahedron to extract a continuous piecewise linear scalar field. The barycentric coordinates (α, β , γ, δ ) for a given tetrahedron θ are related to any point p = (x p , y p , z p ) by (α, β , γ, δ )T = A−1 · x p , y p , z p , 1
T
(1)
where the columns of the matrix A are the homogenous coordinates of the 4 vertices of the tetrahedron. Thus, values of a scalar field at point p can be interpolated as d p = α · d1 + β · d2 + γ · d3 + δ · d4 .
(2)
4 C ONSTRAINT-BASED H APTIC R ENDERING Three Degree Of Freedom (DOF) haptic rendering algorithms take as input the position (and eventually orientation) of a haptic device, transform it into the corresponding position in the reference system of the 3D data set, i.e. the Haptic Interface Point (HIP) (also commonly referred as probe), compute a force value based on this HIP position, and then display this force to the user. The following paragraphs first present a general description of our algorithm. Then the details about the Continuous Collision Detection (CCD) with the tetrahedral mesh, designed to ensure a robust constraint-based haptic rendering, are presented.
(a) Cube divided into 6 pyramids (b) Each pyramid divided into 4 tetrahedra
Figure 2: Decomposition of a cube into 6x4=24 tetrahedra
where (d1 , d2 , d3 , d4 ) are the density of the tetrahedron’s vertice. Isosurface extraction can then be defined locally on each tetrahedron following a simple marching tetrahedra algorithm, i.e. finding the points inside the tetrahedron where densities match a specified isovalue, see Fig. 3. Given all the triangles or quadrangles (part of the isosurface inside the tetrahedra) corresponding to a specific isovalue, the whole isosurface can be reconstructed simply by connecting them by their common edge. This marching tetrahedra algorithm ensures the continuity of the isosurface. All the isosurfaces into a particular tetrahedron are parallel to each other. The scalar field being continuous, a continuous modification on the target isovalue produce a continuous change on the isosurface itself, a key feature for the exploration of volumetric datasets. 0.8 0.7
0.5
0.2
0.4
Figure 3: Isosurfaces corresponding to isovalues 0.3, 0.5 and 0.7 in a tetrahedron
Our haptic rendering algorithm only needs a local definition of the isosurface. Therefore the isosurface is not explicitly stored but evaluated only when desired at a particular tetrahedron. Thanks to the use of a regular lattice, we do not need to store the full tetrahedral mesh either, it is sufficient to store the meshing of one voxel, which implicitly defines the meshing of the whole volume. Similarly, the inverse of the matrix A used to compute the barycentric coordinates is precomputed only once. Therefore, there is no need to use algorithms such as the one presented by Skala −1 in [34] which avoids unnecessary divisions. Moreover, for A = ai, j , the gradient associated to a tetrahedron (p∈ θ ) can be directly computed by means of the following equation, Eq. (3). ~ grad(p) =
4
4
4
∑ ai,1 · di , ∑ ai,2 · di , ∑ ai,3 · di
i=1
i=1
f = k · (SCP − HIP)
(4)
We are referring here to constraint-based haptic rendering since the next SCP position must satisfy the constraints extracted from the dataset at the SCP position. These constraints maintain the SCP in contact with a target isosurface. The whole working space is divided into tetrahedra among which the SCP moves. If the SCP lies on a face or an edge, it belongs to all the tetrahedra sharing that face or edge at the same time. When an isosurface corresponding to a specific isovalue exists in a tetrahedron containing the SCP, the isosurface defines a constraint plane which restraint the movement of the SCP. The constraint plane’s normal is given by the opposite of the gradient (Eq. 3) of the scalar field inside the tetrahedron. The next SCP position is computed using an iterative algorithm. At each iteration, the SCP moves from tetrahedron to tetrahedron until reaching its final position. This ensures the SCP to never fall through the isosurface. Each iteration combines three steps: 1. The first looks for the target isosurface. It starts by creating a list referencing all the tetrahedra which contain the current SCP. They constitute the active tetrahedra list. Then, the algorithm verifies, among all those tetrahedra, if there exists an isosurface corresponding to the currently specified isovalue.
0.3
0.2
4.1 Description of the algorithm At every haptic update step, the haptic rendering algorithm must determine the next position of a Surface Contact Point (SCP) (also commonly referred as proxy) in order to compute a feedback force f proportional to the separation between the HIP and the SCP:
! .
(3)
i=1
This gradient is constant and orthogonal to all the isosurfaces in one tetrahedron.
2. The second step determines the GOAL position, i.e. the closer point to the HIP which verifies all the constraints. The algorithm takes into account two modes: the Free Mode and the Constraint Mode. The former is the mode set at the beginning of the simulation. It corresponds to the situation in which the SCP does not touch the isosurface. The latter is activated when the SCP is in contact with an isosurface and has therefore its motion constrained: In Free Mode the algorithm determines the intersection between the segment that joins the SCP and the HIP and the previously computed constraints (in this case, the constraints refer to the portion of the isosurface which is inside a tetrahedron). If the intersection point was outside of the current tetrahedron or if there was no isosurface in any of the active tetrahedra, the GOAL position is set to the HIP position. In the other case, the SCP is updated to the intersection point and the algorithm switches to the Constrained Mode. The third step is skipped, no GOAL is computed. In Constrained Mode the algorithm sets the GOAL to a position as close as possible to the HIP, but respecting all the constraints previously determined. In this stage, the
algorithm proposed by Ruspini et al. [13] can be used to solve the multiple constraint problem.
Isovalue: 0.3 : Isosurface
3. The third step first executes the CCD query to update the SCP, see 4.2. Then, it detects if the SCP has been displaced in a zone with a lower density value. This would mean that the user is moving away from the selected isosurface. In this situation, the algorithm switches back to the Free Mode. Finally, the algorithm checks if the last updated GOAL corresponds to the last updated SCP. In this case, the last SCP position is the output and the algorithm ends.
GOAL 4 = Final SCP
SCP = initial position
A description of the algorithm is outlined in the following pseudocode, see Fig. 4. Fig. 5 is a step by step 2D illustration of the algorithm, i.e. how the SCP is updated until it reaches its final position corresponding to the last GOAL position. The tetrahedra are represented by triangles, the voxels by the squares, and the isosurface by the dotted line. Each step corresponds to a SCP position. The algorithm is assumed to be in the Free Mode state at the beginning, until step 3. Then, from SCP 3 to the final SCP position, the algorithm is in the Constrained Mode.
GOAL 3
0.0
0.0
0.4
0.5
0.5
0.5
0.7
0.8
SCP 1
SCP 3
SCP 2
SCP 4
HIP = GOAL 1 then GOAL 2
Figure 5: Illustration of the algorithm
4.2
CCD query with Isosurfaces on Tetrahedral Meshes
The original constraint-based haptic rendering algorithm by Ruspini [13] performed CCD based on ray-intersections against an explicit triangle mesh. In our case, due to the use of a dynamically created isosurface, we have designed an algorithm that walks along // Initialization the tetrahedral mesh. Tetrahedron boundaries are the only places lookingForSCP = true where the isosurface might change its normal. As summarized in section 3, our isosurface definition based on while lookingForSCP is true do regular tetrahedral meshing allows us to compute the isosurface loexecuteStep3 = true cally in an efficient manner, and we can guarantee that the isosurface is globally closed and continuous. The robustness of this algo// Step 1 rithm is enforced by the fact that moving the SCP toward the goal tetrahedraList = ComputeActiveTetrahedraList(SCP) iteratively, one tetrahedron at a time, ensures that the proxy never constraintsList = FindConstraints(tetrahedraList, isovalue) crosses the isosurface. CCD first determines if the segment defined by the SCP and the GOAL intersects the tetrahedral mesh. In the // Step 2 positive case, the SCP is placed at the intersection point. Otherwise, if f reeMode is true then intersectionPoint = FindIntersection(SCP HIP,constraintsList) the SCP is placed at the GOAL position. if intersectionPoint is 0/ then The CCD step ensures robustness compared to algorithms whose GOAL = HIP definition of the isosurface is based only on the local gradient else (GBID). Indeed, those algorithms update the SCP position taking SCP = intersectionPoint into account the constraints defined by the gradient at the SCP poexecuteStep3 = false sition, but do not make sure that the SCP does not cross the isosurf reeMode = false face. These errors are avoided by our algorithm using CCD and the end if iterative update of the SCP. else {// Constained Mode} For instance, Fig. 6 shows a case of inaccurate update of the SCP GOAL = SolveConstraints(constraintsList, HIP) position to the goal position when using only GBID. The next SCP end if should not be updated “inside” the data but stay at the border. In practice, methods based on GBID require a very high update rate of // Step 3 the haptics loop to reduce their inaccuracy [10]. if executeStep3 is true then
Input: { SCP, HIP, isovalue, f reeMode } Output { SCP, f reeMode }
SCP = CCD(SCP, GOAL, tetrahedraList) currentDensity = getDensityAt(SCP) if currentDensity < isovalue then f reeMode = true end if if SCP = GOAL then lookingForSCP = false end if end if end while
Figure 4: Algorithm
: Isosurface Active Constraint = gradient
SCP
NEXT SCP (false)
HIP
Figure 6: Simply using GBID, the SCP could be updated “inside” the data instead of on the isosurface. This is avoided by the CCD step.
5 P ENETRABILITY F UNCTION The algorithm described in the previous section can follow an isosurface robustly. Nevertheless, in order to navigate through the whole dataset, it is necessary to be able to modify the isovalue dynamically. Inspired by the approach in [30], a penetrability function has been added to the algorithm. One specific penetrability function has been designed but could easily be modified to adopt different operation modes in a per-application basis. In Constrained Mode, this penetrability function changes the isovalue depending on the force exerted by the user. If the user presses against the surface over a force threshold, the gesture is interpreted as if the user is actually trying to navigate deeper into the data. The proxy is then placed in such a way that the force computed by Eq. 4 does not exceed the given threshold. In practice, instead of using the force, the algorithm ensures that the distance between the SCP and the HIP in the haptic coordinates does not exceed a user defined penetrability threshold PT (in millimeters). The output of the haptic loop (SCP position) is updated following Eq. 5. ( SCP if ||SCP − HIP|| ≤ PT SCP = (5) (SCP−HIP) HIP + PT ||SCP−HIP|| otherwise
inactivated by the user at any time. The penetrability model let the user explore the whole data volume. In some applications the user might be interested just in some parts of the data. To overcome this issue we let the user define some isovalue ranges where the isosurfaces should be search. Fig. 8a and 8b show the reconstructed isosurfaces corresponding to 2 different region of interest into the data, the face and the skull. The isovalue can be restricted to ranges around 0.12 and 0.36 interact with only the target regions.
The penetrability function also checks the current mode and updates the isovalue as follows. After computing Eq. 5 the density of the current SCP position might be different to the isovalue. There are two cases that might lead to this situation. If the algorithm ends in Free Mode and Eq. 5 does not change the SCP, its density will be less than the isovalue. The density could also be greater than the minimum isovalue (defined by the user), in this case the isosurface is redefined using the SCP density as isovalue and the penetrability algorithm switches to constraint mode. If Eq. 5 changes the SCP, the isosurface should be redefined. If the current density is greater than the minimum density, the isovalue takes the same value as the current density, otherwise the isovalue takes the minimum density value and the algorithm changes to Free Mode. The pseudo-code in Fig. 7 describes the whole process.
(a) isovalue 0.36 represents the skull (b) isovalue 0.12 represents the face
Figure 8: Isosurface extraction from the “Visible Male” model (Fig. 9c) corresponding to different isovalue
6 R ESULTS The algorithm has been evaluated from both the point of view of performance and robustness. To evaluate robustness concerning isosurface navigation, we have followed the same protocol proposed by [10]. The SCP moves around a cylindrical synthetic dataset to test the drift from the outer radius of the cylinder. To evaluate performance, the execution time of the haptic loop has been measured while interacting with various data sets, both synthetic and real, see Fig. 9.
Require: 0 < minIsovalue < 1 // Defined by the user Require: 0 < PT // Penetrability threshold Input: {SCP, f reeMode} Output: {SCP, isovalue, f reeMode} if freeMode is false then dist = ||SCP − HIP|| if dist > PT then (SCP−HIP) SCP = HIP + PT ||SCP−HIP|| end if end if density = calculateDensityAt(SCP) if density > minIsovalue then isovalue = density f reeMode = false else isovalue = minIsovalue f reeMode = true end if
(a) Cylinder
(b) Daisy particule
(c) Visible Male
(d) Lobster
(e) Neurone
(f) Orange
Figure 9: Data sets and their current isovalue Figure 7: Penetrability function
With a view to ease the navigation and the exploration of an isosurface of interest, the penetrability function can be activated or
6.1 Robustness test This evaluation consists in initializing the target isovalue (0.53) as the one corresponding to the outer surface of the cylinder and posi-
tioning the SCP on the surface. The cylinder, Fig. 9a, has a radial distribution of its density, increasing toward its center. The SCP is repeatedly moved around the cylinder without leaving its surface. At each iteration, the density value at the SCP’s position is recorded (in this test, the penetrability function is deactivated for convenience). The results are compared with those obtained with the common algorithm using GBID. Figure 10 shows how the original isovalue is robustly followed by our method, while with GBID it slowly decreases at each iteration. This is due to an accumulation of small unintentional fall-through into the dataset. An improved method to GBID is presented in [10], but it also defines the isosurface solely based on the local gradient, and therefore, as shown in their results, reduces drift but cannot prevent it.
7 C ONCLUSION AND F UTURE W ORK This paper presents a robust algorithm for haptic rendering of volumetric data based on dynamical extraction of isosurfaces. In the various tests performed, no situation where the proxy penetrates through the isosurface has been found. This demonstrates the robustness of the algorithm. The algorithm exploits tetrahedral mesh properties to define a closed surface and surface constraints that are constant within each tetrahedron. Using a proxy combined with a constraint-based haptic rendering algorithm, users perceive a smooth and stable representation of the data. A penetrability function was also proposed, allowing the exploration of the complete dataset while dynamically adapting the target isovalue. We believe that specific penetrability functions should be designed and tested on a per-application basis. As previously explained, the isosurface extracted by the marching tetrahedra method use in this algorithm is only continous and might suffer from curvature sign change. The possibility of obtaining an isosurface C1 , without the previous curvature problem, and still meeting the requirements stated in the introduction will be investigated as an improvement of this work. Future work also include the investigation of practical aspects of our rendering algorithm, such as parameter and function choices for specific applications. Finally, this work can easily be extended into a six DOF haptic rendering algorithm.
Figure 10: Isovalue drift comparision
ACKNOWLEDGMENT This work has been partially funded by the Spanish Ministry of Science and Innovation (grants TIN2007-67188, TIN2009-07942, TIN2010-21289 and the Cajal Blue Brain Project).
6.2
Performance test
All the datasets except for the “Cylinder” (Fig. 9a) are real datasets obtained from diverse sources as confocal microscopy, MRI or CT. As the proposed algorithm is iterative, it is important to ensure it converges to the solution fast enough to maintain the frequency required to display a good haptic feedback sensation, i.e. 1kHz. This evaluation was conducted on a PC with an Intel Core 2 Duo CPU running at 3.00 Ghz and 3.25 GB of RAM. The feedback forces are rendered through a PHANToM OMNi of the SensAble family of haptic devices. The performance of the algorithm, tested on the various data sets, were measured and summarized in Table 1. First, this table presents the mean time (in milliseconds) spent on the execution of the haptic loop. The table also shows the mean velocity (in meters per second) of the HIP and the percentage of time spent in Constrained Mode. These two last parameters demonstrate that the experiments were conducted within a “normal” scenario of exploration and interaction of the data sets. The user begins by translating and rotating the dataset in order to find a zone of interest. This exploration part is executed directly with the haptic device. The algorithm is mainly in Free Mode during this time. Once the zone of interest is located, the user starts to touch an isosurface, changing or not the isovalue depending on the objective. During this exploration part, the algorithm is mainly in Constrained Mode. The mean time depends on the grid resolution: the bigger the resolution, the more tetrahedra the SCP has to go through before reaching its final position. The mean time also depends on the amplitude of the user motion. The measurements shown in Tab. 1 were taken at two different resolutions: a low resolution (LR) where a 1mm displacement of the phantom correspond to 0.5 voxel, and a high resolution (HR) where a 1mm displacement of the phantom correspond to 3 voxels. One can see that the mean time remains, in all the cases, under one millisecond, validating the efficiency of the algorithm. The fact that the algorithm fits with the haptic rate requirements at both low and high resolution confirm its usability on data sets with a wide size range.
R EFERENCES [1] A. Amruta, A. Gole, and Y. Karunakar, “A systematic algorithm for 3-D reconstruction of MRI based brain tumors using morphological operators and bicubic interpolation,” in 2010 2nd International Conference on Computer Technology and Development. IEEE, November 2010, pp. 305–309. [2] D. Heeraman, J. Hopmans, and V. Clausnitzer, “Three dimensional imaging of plant roots in situ with X-ray Computed Tomography,” Plant and Soil, vol. 189, no. 2, pp. 167–179, February 1997. [3] S. V. Brown, C. D. Lee, L. Y. Pao, D. A. Lawrence, and A. M. Dougherty, “Combined Visual / Haptic Rendering Modes for Scientific Visualization,” in ASME Dynamic Systems and Control Division. ASME, 1999, pp. 93–99. [4] E. Vidholm and I. Nystrom, “A Haptic Interaction Technique for Volume Images Based on Gradient Diffusion,” in Proceedings of the First Joint Eurohaptics Conference and Symposium on Haptic Interfaces for Virtual Environment and Teleoperator Systems. IEEE Computer Society, 2005, pp. 336–341. [5] D. A. Lawrence, C. D. Lee, R. Y. Novoselov, and L. Y. Pao, “Shock and Vortex Visualization Using a Combined Visual/Haptic Interface,” in Proceedings of the conference on Visualization ’00. IEEE Computer Society Press, 2000, pp. 131–137. [6] K. Hirota, M. Hirayama, A. Tanaka, M. Hirose, and T. Kaneko, “ Physically-Based Simulation of Object Manipulation,” in Proc. ASME Dynamic Systems and Control Division. ASME, 2000, pp. 1167– 1174. [7] D. Lawrence, L. Pao, C. Lee, and R. Novoselov, “Synergistic visual/haptic rendering modes for scientific visualization,” IEEE Computer Graphics and Applications, vol. 24, no. 6, pp. 22–30, November 2004. [8] M. Ikits, J. Brederson, C. D. Hansen, and C. R. Johnson, “A Constraint-Based Technique for Haptic Volume Exploration,” in IEEE Transactions on Ultrasonics, Ferroelectrics and Frequency Control. IEEE Computer Society, 2003, pp. 263–269. [9] E. Vidholm, X. Tizon, I. Nystrom, and E. Bengtsson, “Haptic guided seeding of MRA images for semi-automatic segmentation,” in 2nd IEEE International Symposium on Biomedical Imaging: Macro to Nano (IEEE Cat No. 04EX821), vol. 2. IEEE, 2004, pp. 288–291.
Table 1: Performance evaluation Volume: Dimensions: LR - Mean time (ms): LR - Mean device velocity (cm/s) LR - Constrained Mode HR - Mean time (ms): HR - Mean device velocity (cm/s) HR - Constrained Mode
Cylinder 100 x 100 x 30 0.052 9.54 72.09% 0.072 3.04 93.16%
Daisy particule 192 x 180 x 168 0.046 3.98 61.59% 0.094 4.31 55.13%
[10] K. Lundin and G. Baravdish, “Higher Precision in Volume Haptics through Subdivision of Proxy Movements,” Haptics: Perception, Devices and Scenarios, vol. 5024/2008, pp. 694–699, 2008. [11] K. Salisbury, D. Brock, T. Massie, N. Swarup, and C. Zilles, “Haptic rendering: Programming touch interaction with virtual objects,” in Proceedings of the 1995 symposium on Interactive 3D graphics. ACM, 1995, pp. 123–130. [12] C. Zilles and J. Salisbury, “A constraint-based god-object method for haptic display,” in Proceedings 1995 IEEE/RSJ International Conference on Intelligent Robots and Systems. Human Robot Interaction and Cooperative Robots. IEEE Comput. Soc. Press, 1995, pp. 146–151. [13] D. C. Ruspini, K. Kolarov, and O. Khatib, “The haptic display of complex graphical environments,” in Proceedings of the 24th annual conference on Computer graphics and interactive techniques - SIGGRAPH ’97. ACM Press, 1997, pp. 345–352. [14] H. Iwata and H. Noma, “Volume haptization,” in Proceedingsof the Symposium on Research Frontiers in Virtual Reality, October 1993, pp. 16 –23. [15] O. K¨orner, M. Schill, C. Wagner, H. Bender, and R. M¨anner, “Haptic volume rendering with an intermediate local representation,” in Proceedings of the 1st International Workshop on Haptic Devices in Medical Applications, 1999, pp. 79–84. [16] R. S. Avila and L. M. Sobierajski, “A Haptic Interaction Method for Volume Visualization,” in Proceedings of the 7th IEEE Visualization Conference (VIS’96), vol. VI. IEEE Comput. Soc. Press, 1996, pp. 197–204. [17] W. E. Lorensen and H. E. Cline, “Marching cubes: A high resolution 3d surface construction algorithm,” in Proceedings of the 14th annual conference on Computer graphics and interactive techniques, ser. SIGGRAPH ’87. ACM, 1987, pp. 163–169. [18] Y. Zhou, W. Chen, and Z. Tang, “An elaborate ambiguity detection method for constructing isosurfaces within tetrahedral meshes,” Computers & Graphics, vol. 19, no. 3, pp. 355 – 364, 1995. [19] R. Strand and P. Stelldinger, “Topology preserving marching cubeslike algorithms on the face-centered cubic grid,” in 14th International Conference on Image Analysis and Processing, ICIAP 2007, September 2007, pp. 781 –788. [20] J. H. Ryu, H. S. Byun, and K. H. Lee, “High-quality isosurface generation using an oversampling method,” The International Journal of Advanced Manufacturing Technology, vol. 28, pp. 1161–1168, 2006. [21] T. V. Thompson II and E. Cohen, “Direct haptic rendering of complex trimmed NURBS models,” in Proc. 8th Annual Symp. on Haptic Interfaces for Virtual Environment and Teleoperator Systems. ASME, 1999. [22] W. Li and Y. Shon, “Haptic rendering using C1 continuous reconstructed distance fields,” Shape Modeling and Applications, vol. 1, pp. 1–8, 2009. [23] A. Gu´eziec and R. Hummel, “Exploiting triangulated surface extraction using tetrahedral decomposition,” IEEE Transactions on Visualization and Computer Graphics, vol. 1, pp. 328–342, December 1995. [24] G. M. Treece, R. W. Prager, and A. H. Gee, “Regularised marching tetrahedra: Improved iso-surface extraction,” Computers and Graphics, vol. 23, pp. 583–598, 1998. [25] J. Georgii and R. Westermann, “A generic and scalable pipeline for gpu tetrahedral grid rendering,” IEEE Transactions on Visualization
Visible Male 128 x 256 x 256 0.066 10.32 79.41% 0.103 5.40 56.80%
Lobster 301 x 324 x 56 0.045 4.89 62.36% 0.083 3.14 50.14%
Neurone 1024 x 1024 x 39 0.046 3.03 75.72% 0.061 2.48 45.09%
Orange 256 x 256 x64 0.055 4.70 89.35% 0.071 3.02 60.60%
and Computer Graphics, vol. 12, pp. 1345–1352, September 2006. [26] S. Chan and E. Purisima, “A new tetrahedral tesselation scheme for isosurface generation,” Computers & Graphics, vol. 22, no. 1, pp. 83– 90, February 1998. [27] J. Patera and V. Skala, “Centered Cubic Lattice Method Comparison,” in Proceedings of Algoritmy. Slovak University of Technology, 2005, pp. 309–318. [28] K.-W. Chen, P.-A. Heng, and H. Sun, “Direct haptic rendering of isosurface by intermediate representation,” in Proceedings of the ACM symposium on Virtual reality software and technology - VRST ’00. ACM Press, 2000, pp. 188–194. [29] S. H. Rizzi, C. J. Luciano, and P. P. Banerjee, “Haptic Interaction with Volumetric Datasets Using Surface-based Haptic Libraries,” in Proceedings of IEEE Haptics Symposium. IEEE Computer Society, March 2010, pp. 243–250. [30] K. Lundin, A. Ynnerman, and B. Gudmundsson, “Proxy-based Haptic Feedback from Volumetric Density Data,” in Eurohaptic Conference, 2002, pp. 104–109. [31] K. Lundin, M. Cooper, and A. Ynnerman, “The Orthogonal Constraints Problem with the Constraint Approach to Proxy-based Volume Haptics and a Solution,” in SIGRAD Conference, vol. 1, 2005, pp. 45–49. [32] B. M´en´elas, M. Ammi, and P. Bourdot, “A Flexible Method for Haptic Rendering of Isosurface from Volumetric Data,” in Proceedings of EuroHaptics, M. Ferre, Ed. Springer, 2008, pp. 687–693. [33] S. Chan, F. Conti, N. H. Blevins, and K. Salisbury, “Constraint-Based Six Degree-Of-Freedom Haptic Rendering of Volume-Embedded Isosurfaces,” in Proceedings of the World Haptics Conference 2011, C. Basodogan, C. Seugmoon, M. Harders, L. Jones, and Y. Yokokojhi, Eds. IEEE, 2011, pp. 89–94. [34] V. Skala, “Barycentric coordinates computation in homogeneous coordinates,” Computers & Graphics, vol. 32, no. 1, pp. 120–127, February 2008.
