## 5 Practical Issues on Haptic Representation
### Haptic Representation of a 3D Model in Mid-Air Haptic Scenario  
Once the alignment problem has been solved, another key issue is how to \"translate\" the 3D model (as said before, composed by vertices and faces) into a haptic representation. In Section 3, different approaches to representation considering object fidelity were proposed: high-fidelity and feature-based approaches. We next describe how to implement them in practice, in particular, over the Ultrahaptics. As this device enables the developer to represent _haptic points_, any model to be represented has to be decomposed in a series of haptic point references. In general, the whole process can be divided into the  
Figure 7: Manual alignment over the Ultrahaptics: The user has positioned three digital cube anchors over three physical stickers. following phases: (a) data model encoding, (b) volume checking (and resizing if required), (c) vertices extraction, (d) duplicated vertices removal, and (e) the haptic representation itself. The _feature-based representation_ is the straightest one to implement, as few reference haptic points are needed (even one may be enough). This could be, for example, the centroid calculated from all the vertices of the model. As has been mentioned, this kind of representation is quite appropriate for very small elements or/and for reinforcing the interactive metaphor for a given representation (e.g., a button). _High-fidelity representation_ may be faced in a different mode depending on whether it is _vertices-based_ or _volume-based_. For vertices-based, the procedure is focused on extracting the vertices of the model to represent them on the Ultrahaptics. It is important to note that a volume-adaptation check must be done on the 3D model to guarantee that the representation fits the available volume over the device. It should be mentioned that the received 3D model is encoded as described in Section 4.1, which facilitates the process of extracting the vertices and faces of the 3D model. Then, a vertices redundancy check is done. This is necessary because some platforms introduce redundancies when loading from or exporting to certain 3D formats. From there, all that remains is to translate those vertices into the format required by the Ultrahaptics and to represent them. Nevertheless, the device version used during the development stage (UHDK5) presents a limitation. The number of haptic points that can be presented at the same time is restricted to 4, according to the manufacturer. Thus, at every execution step, a set of haptic points are sequentially represented in a loop. Hence, the bigger the vertices/haptic-point array gets, the worse the representation works. To solve this problem, we introduced padding. Instead of drawing all the vertices in each execution step, we only represent a subset of them in stages. For example, the first one draws with all the vertices in an even position in the array and another draws with only the odd ones. Two issues has been observed on this procedure. First, the 3D model is only represented through its vertices, so no information was presented between them (there is no edge or face information). Second, as it has been stated, the smaller the number of represented vertices is, the more precise the representation is. In this first iteration, the system \"wasted\" painting steps by representing points that were not be perceived by the user due to their hand not being at the position to detect them. If the objective is to perform a volume-based representation, the more detail the representation offers, the more details the user may appreciate. In this case, hand information was introduced into the system using the Leap Motion device integrated on the Ultrahaptics and the generation process suffers certain alterations. In this case, the first step is to divide the 3D model into slices. To do so, we created a logical representation of the 3D shape and encoded it on a 3D matrix.