A Software Library for Multiplatform Tangible Mobile Interaction
Francesco Strada and Andrea Bottino
Department of Control and Computer Engeneering, Politecnico di Torino, Torino, Italy
Tangible Interaction, Capacitive Displays, Passive Tokens, Multiplatform Mobile Computing.
In this paper we present ToMMI (TOkens for Multiplatform tangible Mobile Interaction), a software library
capable of supporting both tangible and multi-touch interaction on mobile devices. ToMMI exploits 3D printed
tokens that can be recognized and tracked on devices equipped with commercial capacitive displays. Results
shows that the computational core of ToMMI is lightweight and can extract token information in less than
a millisecond. Furthermore, the library has an intuitive interface, which facilitates its use, and it is based
on a portable framework that guarantees the deployment of any application based on it on a plethora of dif-
ferent smartphones and tablets. We also report that ToMMI code is available, open source, for the research
The introduction of multi-touch surfaces has rapidly
changed the way we access technology and digital in-
formation. Nowadays, we use touch to interact with
our smartphones, laptops, ATMs and smart TV sets.
Multi-touch interfaces (MTIs) are simple and intu-
itive to use, since they provide a direct and more nat-
ural interaction with on-screen contents. Another in-
teresting approach is that of Tangible User Interfaces
(TUIs), which enable interacting with digital informa-
tion through the manipulation of physical objects of
the real world (Ishii, 2008).
The integration of these two approaches offers a
seamless information representation and interaction
that spans both digital and physical worlds and has the
potential to improve the user experience, to enhance
learning and discovery activities in educational con-
texts and even to promote collaboration, information
sharing and the rise of social experiences (Yu et al.,
2011). These opportunities have been investigated
in several works, mainly exploiting interactive table-
tops. In order to support the implementation process
on these devices, several tools and SDKs have been
developed and shared with the research community
a et al., 2007; Reactivision, 2016; CCV, 2016).
Given the large diffusion of low-cost consumer mo-
bile devices, commercial MTI-TUI applications for
these platforms are starting to be available as well
(AppMATes, 2016; Tiggly, 2016). However, as op-
posed to interactive tabletops, there is actually a lack
of tools supporting the development in the mobile
area. In order to contribute to the problem, this paper
describes ToMMI (TOkens for Multiplatform tangible
Mobile Interaction), a robust and low-cost solution
that facilitate the implementation and multi-platform
deployment of MTI-TUI mobile applications.
As we introduced, the problem of using tangibles
has been initially tackled in the area of tabletop com-
puting, where tangibles are usually tracked by means
of computer vision algorithms that analyze images of
a camera placed underneath the interaction surface.
To simplify information extraction, tangibles are nor-
mally equipped with fiducial markers (Jord
a et al.,
With mobile devices, the computer vision ap-
proach is clearly unsuitable. However, since these
devices are equipped with capacitive screens, one
straightforward approach is developing tags capable
of emulating finger touches. This can be done ei-
ther using different conductive materials (passive to-
kens) or circuits (active tokens). Passive tokens are
usually characterized by a pattern of touch points on
their base that allow encoding data like ID, position
and orientation (Kratz et al., 2011; Chan et al., 2012).
Passive tokens can be easily and cheaply manufac-
tured but they require human contact to be sensed. On
the contrary, the fact that active markers are based on
different electronic circuits allows them to be sensed
without direct user touch but, at the same time, makes
them more expensive and technologically complex
(Yu et al., 2010; Yu et al., 2011). Moreover, they
Strada F. and Bottino A.
ToMMI - A Software Library for Multiplatform Tangible Mobile Interaction.
DOI: 10.5220/0006141401000107
In Proceedings of the 12th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications (VISIGRAPP 2017), pages 100-107
ISBN: 978-989-758-229-5
2017 by SCITEPRESS Science and Technology Publications, Lda. All rights reserved
often have a greater dimension compared to passive
markers (Voelker et al., 2013), thus occluding larger
parts of the display.
As an alternative, approaches based on magnetic
sensing have been proposed (Liang et al., 2014a;
Liang et al., 2014b; Patten and Ishii, 2007). These
tangibles are characterized by a case containing sev-
eral magnets, whose position is sensed by a Hall sen-
sor grid attached on the back of the display. Hence, a
clear disadvantage of this technology is that it requires
external hardware to track the tokens.
The approach we propose with ToMMI is based
on two elements: (i) the design of custom capaci-
tive passive markers, and (ii) the development of a
lightweight software library for identifying and track-
ing them. Similar to other works, our tokens are
characterized by unique patterns of conductive touch
points that encode position, orientation and ID. In
particular, the token design is the result of a com-
promise between two conflicting constraints. First,
since usual tablets screen require the smallest token
to avoid screen occlusion, we tried to minimize their
size while guaranteeing a reliable extraction of the
required information. Second, since most capaci-
tive screens guarantee a limited number of detectable
touches, we pointed at minimizing the number of con-
tact points per token while maximizing the number of
unique IDs. This last requirement is also vital to allow
an effective integration of MTI and TUI techniques.
The rest of the paper is organized as follows. In
Section 2, we will detail the characteristics of the
ToMMI tangibles and, in Section 3, of the software
library used to manage the MTI and TUI interaction.
Finally, in Section 4 we will discuss some real imple-
mentations based on ToMMI and, then, we draw the
We start describing the design of the ToMMI tangi-
bles. As we commented in the Introduction, we fol-
lowed an approach similar to previous works. Our
tangibles are capacitive passive tokens capable of
conveying the following information:
an identifier, allowing to discriminate between
different tokens;
the position in screen space of the token;
the token orientation.
This information is encoded into specific patterns of
touch points. The following questions were driving
the design of the tokens. First, given that the pat-
tern of touch points of the token should encode the
Figure 1: The capacitive tangible (c) consists in a set of
contact points (a) enclosed in a PLA shield (b).
required information in a robust and reliable man-
ner, which can be an appropriate layout that guaran-
tees these characteristics? Then, since current mobile
devices limit the number of simultaneous touches to
(around) ten, which is the minimal number of touch
points that (possibly) enables the contemporary use of
multiple tangibles placed on screen and (mandatorily)
leaves some touches available for MTI interaction?
Before detailing the design choices taken to an-
swer these questions, for the sake of clarity, we inform
the reader that in the following the tangibles will be
also referred as tokens and their “feet” (i.e. their con-
tact points) as markers.
2.1 Prototyping the Tangibles
For the construction of the tangibles we took advan-
tage of the recent availability of conductive graphene
filaments on 3D printers (GrapheneLab, 2016), which
were used to create the contact points, attached to a
common base and enclosed in a plastic PLA shield
(Figure 1).
The first analysis was related to define the mini-
mum marker size that allows its recognition on dif-
ferent devices and the minimal distance between two
markers that guarantees to recognize them as separate
touches. These tests were conducted on devices from
different manufacturers, with different characteristics
(i.e., both smartphones and tablets) and running dif-
ferent operative systems (iOS and Android).
As for the marker size, we printed several cylin-
ders with a varying diameter in the range [3,10] mm
with a step of 1 mm. As a result, we found a marker of
6 mm diameter can be reliably detected on all devices.
In order to identify the minimal distance between
two markers, having fixed their size to 6 mm, we cre-
ated several tokens with two markers, varying their
center to center distances in the range [8,15] mm with
again a step of 1 mm. Our experiments showed that
a distance of 12 mm (i.e., a 6 mm boundary distance
between the markers) is sufficient to reliably tell two
markers apart on all test devices.
ToMMI - A Software Library for Multiplatform Tangible Mobile Interaction
2.2 Marker Types and Token Layout
The solution we propose to address the design re-
quirements introduced at the beginning of Section 2
is using four markers per token.
Three of them (the reference markers) define an
orthogonal Cartesian reference system capable of pro-
viding position and orientation information. The co-
ordinates of these markers into the token reference
frame are, respectively, (0,0), (d,0) and (0,d), where
d is related to the physical size of the token.
The fourth one, the data marker, defines the tan-
gible ID through its quantized position, on a regular
grid of 4 mm, in the token reference frame (see Fig-
ure 2). However, not all position in this grid are valid.
First, the data marker should not be “too close” to the
reference markers, i.e. it cannot be placed inside a
respect zone of ray 9 mm centered on each reference
marker. Second, the data cannot be “too close” to the
point of coordinates (d,d), since a point in that posi-
tion would make the pattern symmetric and, thus, it
would be impossible to tell reference from data mark-
As a result, the minimal size that allows for a ro-
bust token identification is 30 mm. With this size, the
number of unique IDs that can be represented is 8,
and a larger set of distinct tokens can be obtained in-
creasing the token size (see Figure 2). The following
formulas relate the token size and the number of avail-
able IDs. Given an integer number n, a token with size
30+4n mm guarantees 8+12n+n
different IDs. For
instance, Figure 3 shows examples for n = 0 (8 IDs)
and n = 1 (21 IDs), while for n = 3 the token has size
42 mm and it provides 53 unique configurations.
As for the token data, the quantized grid coordi-
nates (i, j) of the data marker define the token ID, the
token position is the local (d/2,d/2) point in screen
coordinates, and the orientation is given by the angle
that the local x axis of the token forms with the global
x axis of the screen space. Finally, since recogniz-
ing a token requires four touch points, a maximum of
two tokens and two finger touches can be recognized
simultaneously on a standard tablet.
Figure 2: Size of the token elements, and varying number
of unique IDs as a function of the token dimension.
Figure 3: Marker types and properties.
The software part of ToMMI is responsible of com-
puting all the interaction information related to the
fingers and tokens placed on screen. The design and
implementation of the library were subjected to the
following constraints:
guarantee the portability on different mobile de-
vices and operative systems;
provide a simple and straightforward interface, in
order to facilitate the integration of ToMMI into
the application;
provide a robust and precise extraction of the in-
formation required;
minimize the computational load.
In the following subsections we will detail these
3.1 Portability
In order to tackle this issue, we implemented our
framework into Unity 3D, a cross-platform game en-
gine that supports a “write once deploy everywhere”
model. This means that an application based on Unity
can be developed on any device and then deployed,
with minimal effort, into different mobile platforms
(Android, iOS, Windows Phone and Tizen). This is
possible since the game engine scripting language is
built upon Mono (Mono, 2016), an Open Source and
cross-platform porting of the Microsoft .NET frame-
Using Unity for the development of mobile apps
should not be considered a limitation, since this
framework allows the integration of APIs and li-
braries written in native language and, thus, to access
any functionality required by the application.
HUCAPP 2017 - International Conference on Human Computer Interaction Theory and Applications
Figure 4: The ToMMI library outline.
3.2 Interface
The interface of ToMMI is pretty simple. The library
overrides the basic Input module of Unity, where the
main logic of the event system is managed, by intro-
ducing an InputManager module whose purpose is to
store both touches and tokens status and eventually
map them into events. Interaction data can then be
accessed in two ways.
A first option is to directly refer, at each iteration
of the update loop, to the properties of InputManager,
which provide:
the status of all touches during the last frame,
which includes position and touch state, i.e. one
of the following: began (a finger touched the
screen), moved (a finger moved on the screen),
stationary (a finger is touching the screen but
hasn’t moved) and ended (a finger was lifted from
the screen ending a touch);
the status of all tokens during the last frame, i.e.
an ID and a unique label (which allows using mul-
tiple instances of the same token at the same time),
position, orientation and token state, where the
possible token states are the same as the touch
As a second option, the InputManager module de-
fines the following three token events for which any
class can define a handler: (i) OnTokenPlaced, when
a new token is placed on the screen, (ii) OnToken-
Removed, when a token is removed from the screen,
and (iii) OnTokenMoved , when a token is moved or
3.3 Implementation Details
The design of the ToMMI library is outlined in Fig-
ure 4. Since one of the main objective was reducing
the computational load, we started by minimizing the
number of messages exchanged between the library
Then, since we experienced that the data of the
Unity input system might miss some touch ending
which, in turns, can result into an incorrect manage-
ment of the tangible interaction, we introduced an In-
putServer module. Its main purpose is to buffer the
filtered touches in the began, updated and ended states
and notify the upper layer of any change of these data.
The ClusterManager detects and updates touch
clusters according to the information offered by the
InputServer. The TokenManager module identifies
new clusters as valid tokens and refreshes the data of
tokens corresponding to updated cluster. These pieces
of information, together with the list of touches not
assigned to a token, are finally handled by the Input-
Summarizing, the life cycle of a token is the fol-
lowing. When placed on screen, the ClusterManager
create a cluster of its touch point. This cluster is sent
to the TokenManager for identification. When the to-
ken touch points are moved, the token position and
orientation are updated. Finally, when one or more
token touch points are marked as ended, the Token-
Manager flags the token as removed and rises the cor-
responding event.
3.3.1 Token Identification
In order to be identified as a valid token, the 4 points
in a cluster must satisfy the following properties: (i)
three of the points [V
], shall define two orthog-
onal vectors having a common vertex (V
) and length
equal to d, the marker axis length
, and (ii) the fourth
point, V
, shall be included into the oriented bounding
box of the first three points.
Clearly, due to noise in the input data, the verifi-
cation of these properties considers a suitable margin
of tolerance. However, this noise affects as well the
accuracy of all token data. While position and orien-
tation errors are less problematic, the noise affecting
the data marker can lead to an incorrect identification
of the token ID, which is a severe issue.
Thus, in order to reduce the noise and improve
the precision, we defined the following linear least
square regression problem. Consider the ideal to-
ken orthogonal reference system defined by the points
], where R
is placed in the origin and
|| = ||R
|| = d. In absence of noise,
the two reference systems [R
] and [V
are related by the following transformation:
] = M [R
M =
cos(θ) sin(θ) x
sin(θ) cos(θ) y
0 0 1
Pixel to metric conversion relies on the device DPI
ToMMI - A Software Library for Multiplatform Tangible Mobile Interaction
is a roto-translation matrix defined by a rotation θ and
a translation (x
). Due to noise, M cannot be ob-
tained directly, but it can be computed as the matrix
that minimizes the sum of squared residuals between
the model (R points) and the observation (V points):
||M R
This problem has the following closed-form solu-
tion. For each pair (V
) of points, equation (1) can
be expanded as:
= cos(θ) R
sin(θ) R
+ x
= sin(θ) R
+ cos(θ) R
+ y
and the whole set of equations can be summarized
in matrix form as: A x = b, where:
A =
1 0
0 1
1 0
0 1
1 0
0 1
,x =
,b =
Thus, the resulting solution of the minimization
problem in equation (2) is:
= (A
b) (3)
Once we have x
, we can update the values of
) and, consequently, the marker data (posi-
tion, orientation and its ID, which is obtained by pro-
jecting the data point V
on the regular grid defined
by (V
). The recognized token receives as well
a unique label that, paired with the token ID, allows
different instances of the same token class to be used
at the same time.
3.4 Computational Load
The entire chain of operations described must be exe-
cuted within one frame update and its overhead must
be minimized in order to provide a lag-free experience
to the user.
In order to obtain quantitative results, we per-
formed a series of test where we profiled the frame-
work executing both “normal” and challenging opera-
tions, i.e., placing more tokens and fingers at the same
time, adding and removing tokens at increasing fre-
quency, performing rapid finger and token movements
and so on. Tests were run on both a Nexus9 (2,3 GHz
dual-core) and an iPad3 (1 GHz dual-core). The dif-
ferences between the two devices were minimal if not
null. Thus, for the sake of brevity, in the following we
report only the numbers obtained with the Nexus9.
Results are summarized in Table 1, which reports
the execution time in ms of the various library mod-
ules. As for the ClusterManager, we highlight the fact
that updating a cluster might involve the creation of
novel clusters, a fact that justify its higher computa-
tional time. The last two rows of the table show the
total execution time required for identifying a novel
token placed on screen and for managing a token mo-
tion. Both numbers are lower than a ms, which we
think justify our previous assertion that ToMMI is a
lightweight library.
As final comment, we would like to provide an ex-
ample of our code optimization efforts. In our prelim-
inary tests, the most computationally intensive pro-
cess was the solution of the minimization problem
in equation 3, with an average execution time of 0.5
ms. To speed up this computation, we first computed
the symbolic expression of the result with Maxima
and eventually factorized its terms to minimize the
number of multiplications required, obtaining a 50x
speedup of the initial solution.
Table 1: Execution times.
Module Operation Time(ms)
InputServer input update check 0.05
ClusterManager cluster creation 0.4
cluster update 0.44
TokenManager token identification 0.03
noise reduction 0.01
token properties 0.05
Token Placed execution time 0.53
Token Moved execution time 0.54
In order to show in more details the capabilities of
the proposed approach, in the following we describe
the implementation of some applications based on
4.1 Tic-Tac-Toe
The first example is a tangible augmented version of
the classic Tic-tac-toe game. Tic-tac-toe is a pencil-
and-paper game for two players which take turns
marking a 3x3 grid with their own symbol (either a
“X”, cross, or a “O”, naught). The player who first
succeeds to place three symbols on a row, column
or diagonal wins the match. If all marks have been
placed without a winner, the game ends with a draw.
HUCAPP 2017 - International Conference on Human Computer Interaction Theory and Applications
(a) Tangible used as game piece
(b) The Tic-tac-toe interface
Figure 5: Tic-Tac-Toe.
Given the limit of two tangibles at the same time,
players use them as molds to place their mark on the
playing grid (Fig. 5(a)). When the game is finished,
the players scores are updated and the new game but-
ton is enabled to start a new game (Fig. 5(b)).
4.2 My Way Home
My Way Home (Bottino et al., 2016) is a game based
on interactive storytelling, a form of narrative where
the user is not bounded to a linear progressing story-
line. On the contrary, he can actively influence the
narrative evolution, either by determining the main
characters actions or by altering the environment in
which the story takes place.
My Way Home is the story of a boy who misses
the bus right after school and needs to find a way
back home. On his journey, he will face hurdles to
overcome and meet characters that can help him to
fulfill his objective. The story evolves as a series of
scenes. The player can use touches and tangibles to
make choices, to control the main character and to
exploit tools in achieving her/his goals. As an exam-
ple, the story features a scene where an old man asks
the player to help him find the car keys he lost in the
front yard and the player can use a tangible-controlled
“magnifying glass” as a helper tool (Fig. 6).
(a) Magnifying glass
(b) Torch
Figure 6: MyWay Home: examples of tangible used as tools
to progress in the story.
4.3 Colombo
Colombo is an example of a scenario where multiple
tokens can be used simultaneously on the same de-
vice. Colombo is a collaborative game for two play-
ers where the main objective is to navigate a sail-
boat along a river avoiding collisions with its banks.
Each player can contribute to the boat motion with a
blower, represented by a tangible playing piece. Di-
rection and intensity of the wind are related to the
relative position between the tangible and the boat
(Fig. 7(a)). When both player tokens are placed, the
resultant of the two corresponding forces is applied
to the boat (Fig. 7(b)). Thus, the game requires both
communication and coordination between players to
fulfill the objectives.
4.4 WaterOn!
WaterOn! (Diniz et al., 2016) is an educational se-
rious game focused on teaching water cycle contents
for 8-10 years old children. The game setting is aimed
at fostering collaboration and discussion among co-
located users. Each player interacts with the game
through a tablet, thus being free to move inside the
physical game environment. The tablet displays a
portion of the whole environment (Fig. 8(b)) and the
game features as well a projected screen (Fig. 8(a))
which shows (i) the overall game scenario, where
ToMMI - A Software Library for Multiplatform Tangible Mobile Interaction
(a) Wind force generated by a blower
(b) Multiple blowers
Figure 7: Controlling the boat movements in Colombo.
Figure 8: WaterOn!: (a) an image of the projected scenario;
(b) view on the tablet screen; (c) feedback of player posi-
tions (the coloured boxes) on the main screen.
players are acting as individuals, (ii) the game status,
which is aimed at offering a shared understanding of
what has been achieved and what has to be completed
yet, and (iii) a direct feedback of players’ position
(Fig. 8(c)).
The game is organized into levels, which intro-
duce the various instructional units defined (i.e., pre-
senting the three states of the water and the transi-
tions between them, describing the movement of wa-
ter within the water cycle and so on). Both MTI and
TUI can be used by the players to perform in-game
actions. For example, Fig. 8(b) shows an image of
the Melting level, where the villains have frozen vil-
lage houses and players have to melt them by placing
an “heat” token on the house. Multi-touch interac-
tion can be used for both navigating the environment
and freezing enemies for a short interval by tapping
on them.
Tests with volunteers aged between 8 and 10
showed that all our testers enjoyed the tangibles as in-
teraction tool without reporting neither specific prob-
lems in using them nor in combining MTI and TUI.
In this paper we have described ToMMI, an ap-
proach for simplifying the implementation and multi-
platform deployment of mobile applications that
exploit both multi-touch and tangible interaction.
ToMMI is based on custom 3D-printed passive ca-
pacitive markers and on a software library capable
of identifying and tracking them. This library is
lightweight, being able to retrieve the required data
(ID, position and orientation) in less than a millisec-
ond. It is also characterized by a simple interface,
which facilitate its integration, and is portable on dif-
ferent mobile platforms and operative systems. We
demonstrated its use through the description of sev-
eral applications based on it.
Despite the advantages of ToMMI, its main draw-
back remains the use of passive markers, which re-
quire direct user contact in order to be sensed. Thus,
as future work, we are planning to investigate the de-
velopment of (possibly simple) active markers.
We finally underline the fact that ToMMI is an
open source software that can be made available to
interested researchers upon request.
AppMATes (2016). Appmates, mobile application toys. Accessed: 2016-10-
Bottino, A., Martina, A., Strada, F., and Toosi, A. (2016).
Gaine a portable framework for the development
of edutainment applications based on multitouch and
tangible interaction. Entertainment Computing, 16:53
– 65.
CCV (2016). Community core vision.
nuigroup/ccv15. Accessed: 2016-10-06.
Chan, L., M
uller, S., Roudaut, A., and Baudisch, P. (2012).
Capstones and zebrawidgets: Sensing stacks of build-
HUCAPP 2017 - International Conference on Human Computer Interaction Theory and Applications
ing blocks, dials and sliders on capacitive touch
screens. In Proceedings of the SIGCHI Conference
on Human Factors in Computing Systems, CHI ’12,
pages 2189–2192, New York, NY, USA. ACM.
Diniz, A. d. S., Strada, F., and Bottino, A. (2016). De-
signing collaborative games for children education on
sustainable development. In 8th International Confer-
ence on Intelligent Technologies for Interactive Enter-
tainment, INTETAIN 2016.
GrapheneLab (2016). Conductive graphene filament, a con-
ductive 3d printing filament. Ac-
cessed: 2016-10-06.
Ishii, H. (2008). The tangible user interface and its evolu-
tion. Commun. ACM, 51(6):32–36.
a, S., Geiger, G., Alonso, M., and Kaltenbrunner, M.
(2007). The reactable: Exploring the synergy between
live music performance and tabletop tangible inter-
faces. In Proceedings of the 1st International Con-
ference on Tangible and Embedded Interaction, TEI
’07, pages 139–146, New York, NY, USA. ACM.
Kratz, S., Westermann, T., Rohs, M., and Essl, G. (2011).
Capwidgets: Tangile widgets versus multi-touch con-
trols on mobile devices. In CHI ’11 Extended Ab-
stracts on Human Factors in Computing Systems, CHI
EA ’11, pages 1351–1356, New York, NY, USA.
Liang, R.-H., Chan, L., Tseng, H.-Y., Kuo, H.-C., Huang,
D.-Y., Yang, D.-N., and Chen, B.-Y. (2014a). Gauss-
bricks: Magnetic building blocks for constructive tan-
gible interactions on portable displays. In CHI ’14
Extended Abstracts on Human Factors in Computing
Systems, CHI EA ’14, pages 587–590, New York, NY,
Liang, R.-H., Kuo, H.-C., Chan, L., Yang, D.-N., and Chen,
B.-Y. (2014b). Gaussstones: Shielded magnetic tangi-
bles for multi-token interactions on portable displays.
In Proceedings of the 27th Annual ACM Symposium
on User Interface Software and Technology, UIST
’14, pages 365–372, New York, NY, USA. ACM.
Mono (2016). Mono, cross platform, open source .net
framework. Accessed:
Patten, J. and Ishii, H. (2007). Mechanical constraints
as computational constraints in tabletop tangible in-
terfaces. In Proceedings of the SIGCHI Conference
on Human Factors in Computing Systems, CHI ’07,
pages 809–818, New York, NY, USA. ACM.
Reactivision (2016). Reactivision, a toolkit for tangible
multi-touch surfaces. http://reactivision.sourceforge.
net. Accessed: 2016-10-06.
Tiggly (2016). Tiggly, interactive toys and ipad learning
apps for childrens. Accessed:
Voelker, S., Nakajima, K., Thoresen, C., Itoh, Y., Overgard,
K. I., and Borchers, J. (2013). Pucs demo: Detecting
transparent, passive untouched capacitive widgets. In
Proceedings of the 2013 ACM International Confer-
ence on Interactive Tabletops and Surfaces, ITS ’13,
pages 325–328, New York, NY, USA. ACM.
Yu, N.-H., Chan, L.-W., Cheng, L.-P., Chen, M. Y., and
Hung, Y.-P. (2010). Enabling tangible interaction on
capacitive touch panels. In Adjunct Proceedings of
the 23Nd Annual ACM Symposium on User Interface
Software and Technology, UIST ’10, pages 457–458,
New York, NY, USA. ACM.
Yu, N.-H., Chan, L.-W., Lau, S. Y., Tsai, S.-S., Hsiao, I.-
C., Tsai, D.-J., Hsiao, F.-I., Cheng, L.-P., Chen, M.,
Huang, P., and Hung, Y.-P. (2011). Tuic: Enabling tan-
gible interaction on capacitive multi-touch displays.
In Proceedings of the SIGCHI Conference on Human
Factors in Computing Systems, CHI ’11, pages 2995–
3004, New York, NY, USA. ACM.
ToMMI - A Software Library for Multiplatform Tangible Mobile Interaction