Project: Implementing Fitts' Law and Machine Learning for HCI Analysis

This project investigates the application of Fitts' Law in conjunction with machine learning to enhance human-computer interaction (HCI). The core focus is on predicting the speed and time a user takes to interact with a target on a computing device. By leveraging Fitts' Law, which considers target size and distance, the project aims to create predictive models for user movements. The integration of machine learning provides a systematic approach to recording and predicting outcomes based on user actions, such as navigating between targets on a screen. The project explores how these principles can inform user interface design, optimizing the ease and efficiency of movements. Factors like screen size and target characteristics are examined to understand their impact on user interaction speed and overall accuracy. The goal is to define and measure HCI, providing insights into the time taken for users to move between targets and how their speed influences these interactions. The project includes an implementation of a machine learning algorithm, incorporating factors like target size and screen dimensions to enhance accuracy in predicting human interaction with computer interfaces.

ABSTRACT
Fitt’s law is used in the field of computing in collaboration with machine learning which targets
improvements in human computer interaction. Predicative models that are used in the measure and
prediction of human speed while interacting with a computing device can be measured and the outcome
predicted accurately using the law. This project focuses on the use of fitts law and machine learning to
determine the speed and the amount of time a human interacting with a target can make.
Using the law, the amount of time taken to move from one target to another can be determined
by using the size of the target and the distance of the target from the pointer. Fitts’ law as a model can
be used to help designers come up with decisions to improve the designs of user interfaces. The
interface is designed to ease the movements between the target and the origin.
Machine learning incorporation into fitts’ law is used as a generic way to provide a series of steps to
predict and record the outcomes based on the type and the movements of the user from one point to
another.
For instance, if the user is navigating between one point on the screen to another point while
maintaining reference to the distances moved. Since the size of the targets is a constant, the amount of
time can therefore be determined using the law and incorporation of techniques in machine learning.
The main focus of this project is to define human computer interaction and the amount of time taken to
move from one target to another with respect to the speed moved by the user.
i

Table of Contents
ABSTRACT................................................................................................................................................i
CHAPTER 1..............................................................................................................................................1
INTRODUCTION............................................................................................................................1
PROJECT SCOPE............................................................................................................................1
MEASURE OF ACCURACY..........................................................................................................2
CHAPTER 2..............................................................................................................................................4
IMPLEMENTATION.......................................................................................................................4
ADJUSTMENT FOR ACCURACY................................................................................................5
CHAPTER 3..............................................................................................................................................7
RESULTS AND DISCUSSION.......................................................................................................7
OPERATION....................................................................................................................................8
ISOLATED TARGETS.....................................................................................................................8
CHAPTER 4............................................................................................................................................12
PYGAME ARCHITECTURE AND FEATURE............................................................................12
PYGAME FEATURES...................................................................................................................13
WORKING OF THE PROJECT....................................................................................................18
DIFFERENCE BETWEEN SMALL AND LARGE SCREEN.....................................................24
CHAPTER 5............................................................................................................................................27
OBSERVATION.............................................................................................................................27
CONCLUSION........................................................................................................................................28
REFERENCES.........................................................................................................................................29
APPENDIX 1...........................................................................................................................................31
APPENDIX 2...........................................................................................................................................32
APPENDIX 3...........................................................................................................................................33
APPENDIX 4...........................................................................................................................................34
APPENDIX 5...........................................................................................................................................35
APPENDIX 6...........................................................................................................................................36
APPENDIX 7...........................................................................................................................................37
ii

CHAPTER 1
INTRODUCTION
Machine learning is statistical method that is used in data analysis to automate the process of
building models. The models that are used for the analysis of the data are usually automated through
machine learning mechanisms. Machine learning is a built from artificial intelligence and is based on
the idea of data, patterns and decision making (Schmidt, 2000). To identify patterns, the machine
learning systems, learn the data and predict the best outcomes to enable aid in the process of decision
making without the need to involve human being. The process is usually faster if the models are given
a wide range of data to learn. The outcomes are based on the data learnt by the models.
Fitt’s algorithm is model based and is used to predict the outcome of movements made by
human being (MacKenzie, 2018). If a human makes a movement in a rapid motion, fitts law can be
used to predict the movements based on previous moves. Fitt’s law is commonly used in the field of
human computer interaction to provide as a guideline that is used in designing interfaces (Bi et al.,
2013). The way in which human beings interact with computer is based on movements. The speed with
which the user makes the motion can easily be determined using fitts law by making a record of the
previous movements.
The field of human computer interaction can be related to the operations of machine learning.
Machine learning involves training of models to enable determine and predict the outcomes of some
event. The models are provided with some set of data, the models analyze the data, and predicts the
outcome for some event. If the models are highly trained, the outcome contains high levels of accuracy.
PROJECT SCOPE
Human computer interaction and its communication with human agents is determined using
computation. The way in which the computer and the humans interact together can be measured and
determined using an algorithm. The best performance measure is carried out using fitt’s law which
provides ways in which the speed and movements can be traced to provide an efficient way of tracking
the performance of the users.
The project is based on machine learning to determine the level of competency of human being
while interacting with a computer screen (Hassan et al., 2019). The human is given a target in a
computer screen. The speed with which the human interacts with the computer is measured and the
1

accuracy is determined using an algorithm based machine learning program. The work flow for the
interaction can be quantified using fitts law which focuses on human interaction with a computer.
The project works on the principles used in fitts law to determine the amount of time and the
speed of a human interacting with a computer screen. Several factor are taken into account while using
the law. Such factors include the width and the screen size (Roig-Maimó et al., 2018). The size of the
screen affects the amount of time the user takes to navigate between the screen. The amount of time to
move from one point to another is greatly reduced if the screen is of a large size and increases with
reduction in the size of the screen (Shneiderman et al., 2016).
The algorithm implemented contains a specific target where the user aims, and the amount of
time taken for each of the respective move is recorded. Computer learning algorithms are modelled on
the basis that they must take in data to enhance the accuracy of prediction and the outcomes. If the
models are not able to learn and take into account the amount of data for learning, the model is likely to
be biased. The measurements for the time and the speed of the pointers are determined by an algorithm.
The algorithm is designed to record the performance in real time.
Some of the factors which affects the operation and the use of the algorithm effectively include
limitation to adjustments in the size and the width of the measuring instruments. For instance, if the
size of the screen in use cannot be adjusted, there is a limitation in used screens of different sizes.
MEASURE OF ACCURACY
The accuracy of time and speed are measured in terms of the interaction of the user with the
targets. If the user misses the target, the values for the time and the speed are not recorded. Accuracy is
a measure of the amount of time spent by the user when hitting a certain target. The best measure of
accuracy can be determined if the user hits the target with minimal time. The amount of time for hitting
the target can be reduced if the size of the screen is reduced and the targets made to rotate at the same
point.
The values of the time can then be analyzed to determine the average amount of time the user
spent hitting the target with different distances for the width and the difference in the speed. If the
speed for hitting the target is high, means that the amount of time taken by the user to hit the target is
reduced. The main aim of the project is to determine the amount of time and the speed of the user if the
user is provided with different targets.
2

If the targets are adjusted automatically, the amount of the time taken by the user to adapt to the
changes in the targets can also be determined. The use of fitt’s law is to define the interactions between
the computer and the human which constitutes human computer interaction. The interaction between
the computer and the humans as a field is measured using defined algorithms.
Some of the algorithms are provided with data as an input to enable them have the best
outcomes. If the models are accurate enough, the speed for the user interacting with the computer can
then be measured without the involvement of the user in the operation.
The advantages of using models to measure the amount of time and the speed used to hit the
target is to increase the level of accuracy. Time can be determined as a unit function, the timing
function takes the width and the size of the screen as parameters.
Mapping of the targets can also be an aim to improve the accuracy of the user. The targets can
be mapped in such a way that the distances from one target to another is equidistant such that the user
is able to navigate easily through the targets. Factor which determines the level of accuracy for the user
include the relative mapping of the targets to each other. The mapping improves the level of accuracy
with which the user is able to hit the target with minimal time.
3

CHAPTER 2
IMPLEMENTATION
Fitts’ law contains several factors of importance which are used to measure the degree of accuracy.
The factors include the following:
 The time taken to hit the target.
 The distance from the starting point to the center of the target.
 The width of the target.
Fitts law has the limitation that it does not provide prediction based on the performance of the
device that is used. The problem is that there is high rate for errors if the user is using a low performing
input device. The performance of the law can be best measured using high performing devices. The
target size and the screen of the device under test is a factor to be considered while testing the
performance of the law on different devices.
The project is an implementation of a machine learning algorithm that uses fitt’s law to determine a
measure of accuracy for an interaction between the user and a computing device. If the user is made to
hit the targets, then the amount of time taken to hit each of the given targets depends on the distance
from one target to another. If the targets are far away from each other, then the amount of time taken
increases with the distance moved from the target.
If the user travels longer distances while traversing through the screen, the speed of interaction
between the computer and the user is reduced (Yeo et al., 2015). To reduce the distance that the user
has to travel, a screen of proper size is recommended for use.
Incorporation of machine learning into the interaction between the computer and the humans plays a
great role in the improvement of the accuracy and the amount the prediction of the outcomes. The
principles that outline the way in which the prediction of the outcomes relates to the way in which the
models are assigned a set of data. For the models to have a greater level of accuracy then, they must
analyze the data provided. Machine learning plays a major role in the adoption and incorporation into
the fitts law. The mechanisms in which the data provided is laid out depends on the aspect that the
models use. If the amount of time taken to predict the outcomes is more, the speed with which the
models can determine the level of accuracy reduces.
The interaction between machine learning and human computer interaction depends on the
types of target (Amershi et al., 2014). Some of the targets requires some training using some kind of
4

models where the models are provided with a set of data. The data is used to determine the next cause
of action whereas some models do not require training and therefore the user is involved manually.
If the user is involved, there must be a target which are in motion to provide different targets to
ensure versatility in recording the values of the outcome.
The type of target involved depends on the user. Sometimes machine independent models are
used and given a certain target.
ADJUSTMENT FOR ACCURACY
An informative technique to improve the accuracy and varying values for the trials can be
determined by using different sets of predefined data. By adjusting the specified width of the target
device the spatial degree of accurate results can be improved (Roig-Maimó et al., 2018). The outcomes
of the models are as a result of different values for the adjustments of the widths for the devices. The
speed of the motion for the input devices varies with the width of the device and the time taken to make
a movement from one point to another within the device.
The throughput and the adjustments for the accuracy are dependent on the accuracy and the
speed of motion. The targets are adjusted at equals lengths and distances to ensure accuracy in the
speed and the timing function used to determine the amount of time taken to hit the target (Bi et al.,
2013). The timing function takes several parameters into account which include speed aimed at
predicting the outcomes effectively.
The adjustments in terms of the width and the size of the screen affect the speed of the of the
pointing device and the amount of time taken to hit the target. If the width is adjusted to a greater size,
then the amount time increases exponentially with the increase in the width.
Accuracy is a measure that the user never misses the target such that the target is successively
hit. Accuracy can be measured in terms of the amount of time taken to successively hit a target. If the
user is first enough to hit the target, the correspondence in the amount of time taken by the model to
analyze and predict the outcomes is equivalently lower.
OVERVIEW
The project is basically a client application that functions depending on the interaction of the
user with the device. The more the interaction between the user and the target, the higher the values in
the correspondence to the results.
5

Implementation of other projects which depend on the same principle of the user interacting
with the target. The more the time that the user interacts with the target, the more the accuracy of the
measured results. The accuracy increases with the improvement in the amount of records that the user
is able to make interaction with the target.
The main reason why I implemented this project was to involve the use of human beings in the
process of interacting with computer devices. If the interaction is not based on humans, then the aim of
the project does not correspond to the working and the functionalities of the application.
The main dependencies of the project include, the amount of time taken by the user and the
speed with which the user is able to make interaction with the target.
6

CHAPTER 3
RESULTS AND DISCUSSION
For a user interaction with a desktop the mouse has some higher performance based on the
specific interactions with the selected points. If a user is made to target different points on the screen,
with the time and the speed of the user being recorded for every movement. It is identified that the time
taken to move from a screen of smaller size to screen of larger size increases with the increase in the
size of the screen. If the width of the screen is adjusted the user takes more time to move from one
target to another.
The aim of fitt’s law is to describe the time taken to acquire a target using some movements
(Gillies et al., 2016). If the width of the target is measured along the path with which the motion is
taking place, the average amount of time taken can then be estimated by using the width and the time
taken to hit the target.
The time and other constants vary depending on the pointing device, input and the ratio of the
distance and the distance that the stylus or the cursor moves in the screen. To determine the amount of
time taken, an experiment is performed with the width and the size of the screen been varied for each of
the consecutive clicks of the cursor and the stylus.
Rapid movements constitute an increase in the speed and the accuracy which results to an
increase in the ratio of the distance to the width of the screen. This shows that if the distance from a
target is increased by some factor with some greater range on the accuracy, then it is observed that the
width of the screen is reduced which results to an increase in the product of time and the motion in any
of the given directions.
The index of performance can be based on some throughput. Throughput can be defined as the
number of times that the user is able to transmit the movements to a given target regardless of the size
of the screen. The best way to describe fitt’s law is to use a deterministic correlation algorithm which is
used to measure the motion at equals sections and at an equal duration of time.
The expansion of the size of the target is aimed at increasing the amount of time that the user
takes to hit the screen. Each of the sub movements are measured independently to increase the accuracy
with which the targets are hit at equal intervals (Card, 2018). The amount of time taken to hit the target
and the accuracy for hitting the targets can be improved by using adjustments for the values of input
fields for the size and the width. The width affects the speed and the time with which the user hits the
7

target (Cruz-Benito et al., 2016). An increase the size results to a decrease in the amount of time and
the speed of moving to the target.
Machine learning is an area that depends on the data set and the and the use of models to predict
and determine the mechanisms that need to be utilized to come up with results.
OPERATION
The user is made to click different targets at the same time. The targets are distant from each
other to ensure that the values of the output recorded are different. Once a hit is made, the user is
provided with a different target located at a different position from the original one (Hassan et al.,
2019.). The targets are marked with red to make them distinguishable from the rest of the environment.
The width of the screen can be adjusted equal intervals by inputting different values in the input
field. Change in the values in the input field changes the width of the screen. The size of the target can
also be changed in the input field provided. Once the values are committed in the input field, the values
changes effectively.
Once a user hits the target, the values of the time are recorded simultaneously for each of
successive hit on the target. The operation and the use of the models depends and relates to the fitts law.
The fitt law is used together with the principles in machine learning to provide outcomes in human and
the interactions between them.
ISOLATED TARGETS
If the targets are isolated the amount of time it takes to move one point to another depends on
the distance of the points. The main aim of expanding the targets is to increase the level of accuracy if
each of the respective movements for are recorded. If there is high demand for an increase in the
measure of accuracy for the input devices, then the movements are slower for each of the respective
movements (Silva et al., 2015). The targets do not need be distinct from each other as they the amount
of time and the speed of the movements for the user depends on the distance travelled by the user
before hitting the target.
If the targets are close enough, this affects the spontaneous movements of the user from one
target to another since, the user moves to the next target with a higher speed which affects the accuracy
of the measurements.
8

The targets are equidistant to each other to ensure that the user moves the same distance from
one point to another (Issa and Isaias, 2015). Distance is a measure of the amount of time, that the user
uses to move to different targets.
The measure of the inputs can be determined based on the following factors.
 Position
 Rate
Position
The accuracy of moving the pointer and hitting the target depends on the distance of the pointer
from the target. The larger the distance between the target and the pointer, the higher the amount of
time taken to hit the target. Time increases exponentially with an increase in the distance of the target
from the pointer. If the distance is reduced, the amount of time taken is also reduced. The position is
also a measure for the rate control i.e. the rate at which the pointer hits the target can be controlled by
adjusting the positions. The positions of the targets are adjusted at equals intervals to avoid overlap
and the time taken by the user to hit the target.
Rate
The rate of the pointer is controlled by the position which depends in the speed and the direction
in which the pointer moves in (Shneiderman et al., 2016). relative mapping is the rate at which the
position and the direction of the pointer can be controlled and mapped into a flexible display. Relative
mapping is meant to reduce the amount of time taken to hit the target.
Human computer interaction is the field concerned with how human beings interact with
computers (Shneiderman et al., 2016). Fitt’s law has been extensively being used in human computer
interaction to define and explain how humans interact with computers. Human computer interactions
aims to ensure that humans and computers interact efficiently with each other to provide a user system.
The process consists of computer, humans the interactions between them.
Usability in HCI is an aspect that is triggered to ensure that the interaction between the
computer and the user are done effectively and efficiently and satisfying to the user (Gillies et al.,
2016). HCI is more concerned with provision of an understanding how systems are incorporated into
computation and how the systems can be made more usable (Ren, 2016).
9

The project is based on human computer interaction which is used to determine the level of
competency of human being while interacting with a computer screen. The main aim of the project is to
determine the level of accuracy for the mouse movement during interaction with a computer screen
which is based on the fitt’s law case study which is based on computer interaction.
I simply created a project that can be used to measure the amount of time and the speed with
which the users can be able to move from one target to another. The targets are separated at equal
distances and therefore the amount of time for each of the movement and the amount of time taken by
the user to hit the target can be determined. If for instance the user is made to hit one target and the
time is set to zero, then the amount of time is calculated based on the difference between the amount of
time taken to hit the second target from the previous target. All the amounts of time are recorded in a
csv file which can be used for later reference to identify the approximate values.
The speed of the cursor movement from one target to another varies from one user to another.
The project uses fitt’s law as a measure of interaction between the user and the computer screen. Once
the user is able to transition from one target to another, then the amount of time can be well recorded
based on the inputs from the user.
The main concepts discussed in fitt’s law is the interaction of human and a computer. Based on the
concepts I came up with a program which can then be used to measure the amount of time and the
speed with which the humans use to interact with a computer.
The main idea of the program is that, when a user is provided with a target and the user is made
to hit the target with the targets separated at equal distances. Once a user is able to hit one target, the
next move is based on another target. If the user is able to transition between the targets, then the
responsiveness of the user with the interaction to the computer can be measured.
The responsiveness and the interaction can then be measured in terms of the speed and the
amount of time taken by the user. The factors of time and speed depends on the relative distance and
the adjustments of the targets. For instance, the difference between a smaller screen and a bigger
screen. The difference in the outputs between the types of the screens depends on the size and the width
of the computer.
The size of the screen can be adjusted based on the number of pixels that a certain screen can be
able to support. If the size of the screen is large enough, then the responsiveness of the user to the
screen is fast as compared to a smaller screen.
10

The main concepts of the project are based on machine learning and the use of computer
interaction based on fitt’s law. The defined classes include the prediction and the Algo classes which
inherits the main attributes and the methods from the object class. Each of the class has its own
methods and attributes which are defined and used to perform a set of actions.
The required modules for use with the program include:
 pygame – used for the graphics and implementation of the targets on the target screen. Pygame
is a python library which is used to draw and draw and display each of the visible targets to the
user.
 Time – used to determine the accuracy and the amount of time that the user has spent while
moving from one target to another. The time record is set to begin when the user hit one target
and the transition to another target.
 Math – this module is used for some of the calculations based on the time and the speed of the
user. For instance, calculating the distance from one target to another between the computer
screen.
 Random – this module is used to determine and return a random location for the next target.
Once a user hits one target, the next target is determined by a random function. The functions
returns the location as an index value which is based on the rand().
 Csv – this module is used to write the values of the time recorded for the user while
transitioning between one target to the next. Once a user hits one target, the value of the time is
recorded for the current target and updated each time the user moves to the next target. Once the
user hits the next target, the current value is recorded and written to a file using the csv module
in the following way: csv.DictWriter(self.record, fieldnames=self.fields). Each of the item and
the record in the csv file are separated by comma based values. Each of the value contains a
different heading.
11

CHAPTER 4
PYGAME ARCHITECTURE AND FEATURE
Pygame is a cross-platform software that's open-source and free, designed through the python
programming platform library for scripting multimedia applications such as games that are much more
efficient than the SDL library (Payne, 2019). Similar to the SDL, Pygame is very much portable and
has the capability of running on several different platforms as well as operating systems (Windows,
Mac, and Linux). Pygame comes with its computer graphics as well as sound libraries purposely to be
used by the python programming language. Pygame architecture is developed in such a way that it uses
the SDL (Simple DirectMedia Layer) library. The latter was to make sure real-time computer games are
developed without having to cope with the low-level capacity of the c programming and its
complementary derivatives. This feature was implemented with the assumption of majority of the
expensive functionalities of the most games are abstracted from game logic, this makes it suitable for
game developers to use high-level programming languages, like Python in developing them. Another
feature that makes pygame better than SDL is the fact that Pygame includes 2d sprite scene graph
management, camera, vector math, advanced FreeType font support, drawing filtering, transformations
as well as pixel array manipulation. Pygames applications are able to run on tablets and android phones
with the help of pygame subset (pgs4a)
Before we can start any form of programming related to pygame, you will need to install a
software or program called the Python interpreter to your computer. An interpreter is a program whose
responsibilities are to understand instructions that a programmer types out via the Python language. It's
impossible to run any program without a python interpreter, python interpreter is not a new thing it's
just that most programmers refer to as merely "PYTHON." a Python Interpreter can be easily
downloaded from the software's official websitehttp://www.python.org. The installation process of a
python interpreter can be different this is due to different operating systems. Before we proceed to
install the pygame program allow me to take you through the various installation process of the python
interpreter (Payne, 2019).
12

PYGAME FEATURES
Just like Python, the Pygame platform is free. However, the program doesn't come with Python.
To install the pygame software, you will have to download it first, which is more similar to installing
the python interpreter. On your computer web browser go to URL http://pygame.org. Go to the
download button or link and press it; on this stage, everything is similar regardless of the operating
system you are using. While downloading, however, it's required that you choose an operating system
of your user and ensure that the version of pygame you download matches the release of the python
interpreter you had installed earlier. It's highly recommended that you go for your pygame binary and
not the source. For those using windows, click on the download on the version that matches your
interpreter.
For Mac OS X users download the .dmg file or .zip for the version of Python that you
downloaded. For Linux, you are required to open the terminal and then run the following script "Sudo
apt-get install python-pygame." To ensure that the program has successfully been installed on Windows
write in the following on the interactive window;
13

If it has installed successfully, nothing should appear, but if not, then an error message should appear.
For those with Mac OS, you can start the IDLE by opening your finder and searching for
applications and clicking on python 3.2 then the IDLE pop-up icon. For Linux and Ubuntu, you are
required to open the terminal window and hunt for you idle version for instance "Idle 3." another
alternative is going to applications and and selecting programming then you IDLE version.
COMPARISON
Pygame is not so different from Python since it also comes with its own functions or modules
that are used for drawing graphics, dealing with mouse inputs as well as playing sounds this is similar
to python modules for math, time and random. don't just be an installation expert here are some basic
stuff about pygame
CLI vs. GUI
With python programs, the already inbuilt functions only interact with the text through the
input( ) and print ( ) functions. Meaning an application can display text on one's screen prompting
him/her to type in the text through the keyboard (Kelly, 2019). This type of commands is said to
have a command-line interface (CLI) such programs are limiting since they can never display colors,
graphics, or even handle mouse movements. With such technology, it is difficult to make any action
games since the user is required to press enter for any action to happen.
Pygame, on the other hand, has inbuilt functions that can display windows with colors as well
as images instead of the command line interface pygame uses graphic-based interface (GUI).
FUNCTIONALITY
Game States and Game Loops
"While True: #main game loop" is a while loop with the condition of vale True. Other terms this
means the loop never exits since its condition evaluates to False. A program execution only happens if a
loop statement has been executed for example "sys.exit." on the other hand, a game state is used to
describe a save the state a good example is when you pause a game, pausing a game means preventing
a game from any change. As you know, a game state only updates or affected by response events like
14

keyboard press or mouse clicks and in other times elapsing of a certain period. With the game loop in
place, the loop will be in a constant process of checking and checking for any response events. This
means within the loop keeps on looking on which events are being created as it takes the record; this
process in pygame is called through pygame.event.get ( ) function
The pygame.quit ( ) function and Quit Event
Every event objects comes with a member variable also referred to properties or attributes that
are responsible for telling which event an object represents. Pygame is built with a constant variable in
the pygame (Botvinik et al., 2019). Locals modules (Cogliati, 2018) "if event. Type ==
QUIT": this line checks if the said events object kind is equal to its constant (Quit). A sys.exit function
is only called when an Event object is said to be a quit event. A well-written program should always use
sys.exit when terminating a program (Kumari and Fancy, 2017). This should be an issue since
Python has its way of exiting programs regardless. However, the problem arises when there is a bug in
IDLE, which makes the program to hung.
Colors
With pygame there are only three colors, this is red, blue and green. For color yellow, red and
blue the software considers them to be primary paint color and it doesn't consider them since it only
uses light and never paints. Pygame uses a special technique of combining these three colors in coming
up with the rest of the colors (Kelly, 2019). It is important to note that this game platform represents
colors as tuples of three integers. The first value describes the amount of red in the shade. Integer 0
equals no amounts of the red inn the color in question while integer 255 symbolizes 255 maximum
amount of red in color in question (Payne, 2019). Pygame can draw a total of 16777216 since you
can use a combination of 0 to 255 this means 256 by 256 by 256. If you try and use an integer larger
than 255 you will be prompted with an error. For instance, one can create a tuple like (0, 0, 0) which
will be saved as a BLACK variable. This means there is no amount of color red, green, or blue,
implying that the resulting color is purely black. In pygame color, black is the absence or lack of any
other color.
Pygame is a python wrapper module used by the SDL library. The module contains functions
and libraries which can be used by the python programming environment for keyboard, mouse inputs
15

and interaction with a computer screen. The pygame library contains modules and libraries which can
be used with the python programming language. Different version of pygame have support for both
python 2 and python 3. Pygame module is built on top of a highly portable Simple DirectMedia layer
which is used for building multimedia applications. This enables the pygame module to be used for
building multimedia and graphical applications.
The operation of pygame depends on the installation of python. Python must be installed before
using the module. Python is cross platform, which means that the module can be used on any platform
that supports the use of the python programming. Different operating system requires different
installation procedures. The best way to install the module is using pip which is mostly used by python
for installation of other modules. Pip tools contains the latest version of the pygame libraries which are
required for use by the tool. Pygame is a module which is used for building media and graphic
applications.
The command for installing pygame using pip is: pip install pygame. If it not installed already,
all the package libraries required for the module to work are downloaded and installed. Successful
installation means that all the required modules were installed and the program can use be used.
For a system such as Linux, pygame can be installed using sudo apt-get install pygame using the
terminal. If nothing appears after the command, then pygame is already installed else all the packages
and the libraries required by the module are downloaded. Pygame is a top level package which is
divided into sub modules and provides other packages which can be used by other users. Some of the
most commonly used method for pygame include:
pygame.init()
It is used to initializes all the modules that have been imported for use by the module. All the
modules which have been imported in the program can be initialized manually using the init() method.
The module does not raise an Exception once it fails but returns a tuple containing the fails and the
success. To check if all the modules have been initialized, get_init() returns true is the pygame is
currently initialized.
To import pygame modules for use with a python program is an easy process. Some of the
modules in pygame are written in python while others are written in c. Most of the modules are
16

optional ie not required for import while other modules must be present for the program to function.
For instance, init must be imported from the pygame library for the other modules to function properly,
other modules which must be imported include the local modules which are required for initialization
by the modules. The modules must be present for the proper functioning of the module.
KEYWORDS
Import
This is the keyword which is used to import the pygame packages. To import all the available
modules into the pygame package the following line is used.
Import pygame
To be able to use constants and the functions into the global usage of the entire python script the
local modules can be imported using;
From pygame.locals import *
This imports all the required functions and all the constants which are required for use by the
entire python program. When using import pygame, all the modules are imported, which includes the
font module. The font module can also be imported using pygame.font. If during the import of the
pygame, the font module is not available, pygame.font which can also be imported can be set to contain
a None value. The font module can be checked and tested if it is available later in the program.
Before anything can be done using the pygame, all the modules needs to be initialized which is
done by calling init() call. Although not all the pygame modules are required to be initialized, for other
modules which require to be initialized is done automatically. In case of any errors available with the
initialization of the pygame module. The errors are handled silently and an exception is raised which is
used to return the message for the type of error.
Pygame contains a surface which is used for display basically an image which is available on
the computer screen and on which is made up of several pixels for a better visualization on the screen.
The pixels for a single image can be changed using blit() call function which can also be used to copy
pixel of one image into another image.
17

Pixels on the screen cannot be simply changes, what changes is the color index for the images
which are displayed on the screen.
WORKING OF THE PROJECT
I implemented a python project using the pygame module for visualization into the computer
screen. The project contains a class named algo which inherits all the methods and the functions from
object class. The Algo class acts as a child to the object class. The main class also contains methods
and functions which are used to assist in the implementation of the code. The choice of the functions
used in the class depends on the project objectives. The main objectives of the project is to create an
instance of a program which is used to determine the level of competency for a human interacting with
a computer screen.
This means that the program should implement a computer screen for which the user is
interacting with it. I chose to implement a simple graphical user interface which the users is used to
interact with. The display contains balls which are drawn and placed at distances to each other. The
balls are placed at equals distances with each other.
Pygame module is used for the implementation of the graphical user interface. The class
contains a constructor which is denoted by ___init__(). The constructor is used to initialize and set up
the main modules which are required for use by the class. All the variables, constants and the values
required for use in the program are initialized in the main constructor. The variables which are
initialized in the main constructor include color, position of the cursor, time, and the font size. The
position of the cursor is updated every time the cursor is moved. A key event is used to track the
changes that are made each time the cursor is moved and update the current position to the position in
the main constructor.
When an instance of the main of the main method is called, the object instance accepts several
arguments which must be provided as parameters. The parameters include: size, color, position of the
cursor and the interval for which the balls must be spaced. Self-keyword used entirely within the
program is used to identify the main attributes of the program within a context of itself. For instance,
declaring the font_size as self.font_size sets the font_size as a global instance which can then be called
and used entirely within the program. Each of the functions contains the special built in keyword self
which is used within the context of the program to call the instances of the variables and the functions
available in the program (McManus, 2018).
18

Time is a built in module for python which has been imported to capture the amount of time that
the client uses to interact with the computer system.
The function _event_update(self, _events) accepts an event type as an argument . the method is
used to listen for an event from the user. Such events include mouse move and clicking of the mouse.
Once the mouse is moved or clicked, the function is updated with the current event in real time. The
events can be a list which contains several events performed by the user. The method loops through all
the events, checking the type of the events performed. For instance, if the home key is pressed, the
program is able to check for the type of the event and update with the current position of the cursor.
The function event_update is defined as follows:
def _event_update(self, _events):
"""
update the events such as mouse movements between the targets
:param _events:
:return:
"""
# loop through the current events
for event in _events:
# check the type of the event
if event.type == pygame.KEYDOWN:
self.cursot_v = True
if not event.key in self.repeat:
self.repeat[event.key] = [0, event.unicode]
# check if backspace button is pressed
if event.key == pl.K_BACKSPACE:
self.input = self.input[:max(self.cursor_p - 1, 0)] + \
self.input[self.cursor_p:]
self.cursor_p = max(self.cursor_p - 1, 0)
elif event.key == pl.K_DELETE:
19

self.input = self.input[:self.cursor_p] + \
self.input[self.cursor_p + 1:]
# check if the event is return type
elif event.key == pl.K_RETURN:
return True
# check if the motion is on the rights
elif event.key == pl.K_RIGHT:
self.cursor_p = min(self.cursor_p + 1, len(self.input))
# check if the motion is on the left
elif event.key == pl.K_LEFT:
self.cursor_p = max(self.cursor_p - 1, 0)
# check if end key is pressed
elif event.key == pl.K_END:
self.cursor_p = len(self.input)
# home key
elif event.key == pl.K_HOME:
self.cursor_p = 0
# capture input from the user
else:
self.input = self.input[:self.cursor_p] + \
event.unicode + \
self.input[self.cursor_p:]
self.cursor_p += len(event.unicode)
# key up
elif event.type == pl.KEYUP:
if event.key in self.repeat:
del self.repeat[event.key]
# capture the key events repetitively
for key in self.repeat:
20

self.repeat[key][0] += self.timer.get_time()
if self.repeat[key][0] >= self.initial_interval:
self.repeat[key][0] = self.initial_interval - \
self.repeat_interval
# read the key event and update
event_key, event_unicode = key, self.repeat[key][1]
pygame.event.post(pygame.event.Event(pl.KEYDOWN, key=event_key,
unicode=event_unicode))
self._s = self.font_object.render(self.input, self.anl, self._text_c)
self.counter += self.timer.get_time()
# reset the counter with the current values for the movements
if self.counter >= self.ms:
self.counter %= self.ms
self.cursot_v = not self.cursot_v
# check the position of the cursor
if self.cursot_v:
cursor_y_pos = self.font_object.size(self.input[:self.cursor_p])[0]
if self.cursor_p > 0:
cursor_y_pos -= self.cursor_s.get_width()
self._s.blit(self.cursor_s, (cursor_y_pos, 0))
self.timer.tick()
return False
The function area is used to return the amount of area and the space that has been occupied by
the targets. The more the targets that appear on the screen, the more the area occupied by the targets.
def area(self):
"""
return the specific area for the input device
21

:return:
"""
return self._s
The method defined as text is used to return the input captured. The methods act as a listener for
some input and then return the type of input which has been captured.
The current position of the cursor is important in determining and calculating the amount of
time that the user spends in moving between the targets. The position method define is used to capture
and return the current position of the cursor.
def position(self):
"""
return the current position of the cursor
:return:
"""
return self.cursor_p
The method does not accept any arguments but acts as a listener for the cursor movement. Each
time the method is called, the current position of the cursor is returned. The position of the cursor is
used to identify the transition from one target to another.
The color of the screen and the targets is an important aspect which is used to distinguish
between the targets. For instance, the color of the target is set to be red and the background color of the
screen is set to be black. This is a feature which is used to distinguish between the environment. The
color function that have been defined is used to initialize the target with the color supplied. The method
usually accepts, a color as an argument and then sets the current color of the target to the define one. If
the color is not provided as an argument for the method, then the method usually returns the default
color.
def color(self, color):
"""
initialize the color , with the given color as a parameter
:param color:
"""
22

self._text_c = color
The variable text_color is defined in the main constructor. Each time the method is called with
the color provided as an argument, the methods, sets the current color of the target as the defined one.
Self is a keyword which is used in this context to set the value of the defined attribute within the class
with the value given. For instance, setting the value of the text_color to the given color provided as an
argument.
Besides the target and the background having defined colors, the cursor also has its own color
which can be set using the defined method cursor_color(). The method also accepts the color as an
argument, once the color is supplied as an argument, then the value of the cursor color is set as the
given one.
def _cursor_c(self, color):
"""
fill the cursor with the given color
:param color:
"""
self.cursor_s.fill(color)
The fill method is used to fill the cursor with the provided color. For instance, if the color
provided as an argument is red, then using the fill method, the color of the cursor is set to the defined
one. The argument for the cursor_color function can vary depending on the input color from the user.
The method starts by looping through the events that have been provided as a parameter. After each of
the steps is checked and looped through, I wrote a code to identify the type of each of the event which
have provided. The type of each of the event can be identified using the locals module which have
been imported using pygame.locals.
For instance to check if the event and the type of key produced by the user is a backspace,
calling K_BACKSPACE with the event.type returns true. If returns false, then the type of the event
which have been identified is not a backspace event. When the home key has been pressed which can
be identified by calling K_HOME, the position of the cursor is set to zero. The value is initialized to be
zero.
23

The motion of the mouse can be identified to be in the LEFT or in the RIGHT direction. If the
motion is in the right direction which can be identified by K_LEFT and for the right which can be
identified by K_RIGHT, the program checks the current position of the cursor and updates to the value
that is defined in the constructor (Sahni et al., 2018).
DIFFERENCE BETWEEN SMALL AND LARGE SCREEN
The python program developed is used to test and measure the level of competency of humans
interacting with a computer screen. The size of the screen is a factor which affects the measure of the
speed and the amount of time that the user spends on the screen. The size of the screen can be measure
in terms of the number of pixels covered by the screen in each dimension.
For each of the given screens, the user is provided with a moving target such that each time
there’s a different target at a different position. The change of position for the targets it to ensure that
the amount of time is taken as an approximate measure for each of the consecutive aim at the target. A
built-in module from python, time, is used as a measure of accuracy to measure the amount of time that
used to transit from one target to another.
The difference observed between a small screen and a large screen is due to the amount of time
and the speed of the user from one target to another. For a small screen, the amount of time spent by the
user to move from one target to another is less than the amount of time taken to move on a larger
screen. The amount of time spent by the user for each of the interaction with the target I recorded in a
csv file. An average of the amount of time spend by the user for each of the targets can then be
determined using the relative amounts of time recorded in the csv file.
Once a user clicks on a single target, the next click involves a different target which is
positioned at a different index from the previous target. The separation distance between the targets can
be adjusted. This results to an increase in the amount of time taken to move from one target to another
since the distance between the targets is more as compared to the original distance.
The following lines of code are used to check the targets and their index.
if self.p == 1:
if target_0 > math.ceil(self.targets / 2):
return target_0 - math.ceil(self.targets / 2)
else:
24

return math.ceil(self.targets / 2) + target_0
else:
while True:
rand = random.randint(1, self.targets + 1)
if rand != target_0:
break
return rand
The lines use a math function, uses the built-in module imported from python which is used to
calculate the distances of the targets based on their location. Math.ceil is used to return an approximate
amount of time taken between one target and the other.
The target is drawn using gfdraw() method which is provided by the python module.
pygame.gfxdraw.aacircle(self.source, 750 + int(math.cos(math.pi * 2 / self ), 400 +
int(math.sin(math.pi * 2 / self.targets * i) * self.width / 2), self._size, (100, 100, 100))
The program uses a loop and the method gfdraw() to draw all the targets that are found on the
screen. fitt’s law is an experiment which is based on human computer interaction. The program uses the
fitt’s law as a case study to determine the level of competency for the user.
Within the context of the prediction class, the method update_circle is used to update the targets
with the current values for the input.
def update_current_circle(self, target_0):
"""
this method is used to update the current target with new values for the input
:param target_0:
:return:
"""
25

# check the target and the record the speed for hitting the target
if self.p == 1:
if target_0 > math.ceil(self.targets / 2):
return target_0 - math.ceil(self.targets / 2)
else:
return math.ceil(self.targets / 2) + target_0
else:
while True:
rand = random.randint(1, self.targets + 1)
if rand != target_0:
break
return rand
The method accepts a target as a parameter and return a value which contains the index of the
current target. For instance, using the math.ceil method from the math module , the number targets can
be identified and the using the values of the target provided as an argument to check and return the
current index of the target. If the target is not provided, then the method returns a random value for the
targets.
The method first checks if there any targets which are provided and proceeds to check if the
number of targets provided as parameter match the targets. If the targets match, then the method returns
the current match index for the targets. If there is no match found for the targets, then the method
returns a random value which contains the index of the targets.
csv.DictWriter(self.record, fieldnames=self.fields)
csv module is used for writing the values of the time to an external file which can be used for a
reference for the amount of time that the user spends while interacting with the computer screen.
26

CHAPTER 5
OBSERVATION
The main observations for the project are based on the interaction of the user with the computer
target. Once the user is made to hits different target at different intervals, then the amount of time and
speed of the interaction can be measured. The observation varies from one input device to another due
to a variation in the size of the screen and the speed of the user. Different users have different
mechanisms of interacting with the targets.
The speed therefore varies for different users, which can be observed in the change of the
amount of time. For instance, if the speed of interacting with the targets is high, then the amount of
time taken to move from one target to another is low. The faster the user in moving from one target to
another the lower the amount of time recorded for transition between the targets.
Fitt’s law which is also used as as case study in the project can be used as a reference to
measure the accuracy of the user. The main concepts that are outlined in fitt’s law whose objective is to
determine the level of accuracy are laid out in the program.
The main observation made from the human interaction with a computer screen with moving targets
include the amount of time and speed.
It is observed that when the distance between the targets is reduced, the amount of time spent by
the user while moving from one target to another reduces with the distance. If the distance is reduced,
the amount of time reduces drastically due to an increase in the speed. This shows that an increase in
the size and the distance between the targets reduces the amount of time taken to hit the targets since
the speed of the user is low. The movement from one target to another with lower speed indicates that
the amount of time spent by the user to hit the target is higher as compared to the amount of time taken.
The distance of the screen size of the computer also determines the amount of time and the speed of the
user interacting with the targets. For instance, if the size of the screen is higher, this means that the
amount of time taken by the user to move from one target to another is reduced due to low speed while
traversing between each of the targets for the screen.
Starting with a smaller width, the amount of time reduces with reduces with increase in the
width. This implies that the speed reduces too. The positioning of the targets on the screen is based on
27

equal distances, this enables to improve the accuracy for each of the successive hit of the target. Once
the target has been hit, then a different target is set, which is placed at a different position index but
placed at an equal distance from the previous target. Each time the values for the time are recorded
once the user hits a target, the values are written to a file using the csv module.
self.outfile.writerow({'num': str(self._start), 'W': str(self._size), 'D': str(self.width),
'ID': str(math.log(self.width / self._size + 1)),
'time': str((time.time() - self._clock))})
The required arguments for writing the data into the file include the size of the screen, width of
the screen and the time taken to move from one target to another. The time recorded can be compared
with the screen and the width. This gives a comparative idea of the amount of time taken to hit the
targets for each of the screen size. Different screens have different widths, which implies that the
amount of time taken to hit the target will vary depending on the type and the size of the screen.
CONCLUSION
The project provided a description of machine learning and incorporation of fitts law into
computer interaction to predict the amount of time taken for the user to move from one point to another
within a computer screen. The proposed model for fitts law can be used to determine the best designs
for computer system and the interfaces (Cruz-Benito et al., 2016). Computing tasks are based on the
principles and the laws based on fitt. The desired output is delivered as a variable depending on the
speed and the time taken to move from one point to another in the computer screen.
An input screen with a small size, enables faster movement of pointers from one point to
another within the scree and therefore takes less time to navigate a pointer from one point to another
within the screen (Fails and Olsen, 2003). The amount of time taken therefore depends on the size of
the screen in use. The invention and the use of fitts law is a guideline to the research that affects
computer interaction for humans. The field of human computer interaction is aided by fitts laws. The
throughput increases with the increase in the speed of the user interacting with the computing device.
At the same time throughput is lower for devices with smaller sizes as compared to those screens which
have larger sizes.
28

The concepts and the use of machine learning in the operation of human computer interaction depends
on the types of model used and the interaction between the laws governing fitts and its incorporation
into the field of machine learning.
REFERENCES
Amershi, S., Cakmak, M., Knox, W.B. and Kulesza, T., 2014. Power to the people: The role of humans
in interactive machine learning.AI Magazine, 35(4), pp.105-120.
Bi, X., Li, Y. and Zhai, S., 2013, April. Fitts law: modeling finger touch with fitts' law. In Proceedings
of the SIGCHI Conference on Human Factors in Computing Systems (pp. 1363-1372). ACM.
Botvinik-Nezer, R., Bakkour, A., Salomon, T., Shohamy, D. and Schonberg, T., 2019. Memory for
Individual Items is Related to Non-Reinforced Preference Change. bioRxiv, p.621292.
Card, S.K., 2018.The psychology of human-computer interaction. Crc Press.
Cogliati, J., 2018. Non-Programmers Tutorial For Python 2 and 3. Lulu. com.
Cruz-Benito, J., Therón, R. and García-Peñalvo, F.J., 2016, July. Software architectures supporting
human-computer interaction analysis: A literature review. In International Conference on Learning and
Collaboration Technologies (pp. 125-136). Springer, Cham.
Fails, J.A. and Olsen Jr, D.R., 2003, January. Interactive machine learning. In Proceedings of the 8th
international conference on Intelligent user interfaces (pp. 39-45). ACM.
Gillies, M., Fiebrink, R., Tanaka, A., Garcia, J., Bevilacqua, F., Heloir, A., Nunnari, F., Mackay, W.,
Amershi, S., Lee, B. and d'Alessandro, N., 2016, May. Human-centred machine learning. In
Proceedings of the 2016 CHI Conference Extended Abstracts on Human Factors in Computing
Systems(pp. 3558-3565). ACM.
Hassan, M., Magee, J. and MacKenzie, I.S., 2019, July. A Fitts’ Law Evaluation of Hands-Free and
Hands-On Input on a Laptop Computer. In International Conference on Human-Computer Interaction
(pp. 234-249). Springer, Cham.
Issa, T. and Isaias, P., 2015. Usability and human computer interaction (HCI). In Sustainable design
(pp. 19-36). Springer, London.
Kelly, S., 2019. Introducing Object-Oriented Programming. In Python, PyGame, and Raspberry Pi
Game Development (pp. 153-170). Apress, Berkeley, CA.
Kelly, S., 2019. Designing Your Game. In Python, PyGame, and Raspberry Pi Game Development (pp.
99-105). Apress, Berkeley, CA.
29

Kelly, S., 2019. Game Project: Memory. In Python, PyGame, and Raspberry Pi Game Development
(pp. 323-339). Apress, Berkeley, CA.
Kumari, R. and Fancy, C., 2017, May. Analyzing the PyGameGUI modules available in python. In
2017 International Conference on IoT and Application (ICIOT) (pp. 1-6). IEEE.
MacKenzie, I.S., 2018. Fitts’ law.Handbook of human-computer interaction,1, pp.349-370.
McManus, S., 2018. Mission Python: Code a Space Adventure Game!. No Starch Press.
Payne, J.R., 2019. Python for Teenagers: Learn to Program Like a Superhero!. Apress.
Ren, X., 2016. Rethinking the Relationship between Humans and Computers.IEEE Computer, 49(8),
pp.104-108.
Roig-Maimó, M.F., MacKenzie, I.S., Manresa-Yee, C. and Varona, J., 2018. Head-tracking interfaces
on mobile devices: Evaluation using Fitts’ law and a new multi-directional corner task for small
displays.International Journal of Human-Computer Studies,112, pp.1-15.
Sahni, N., Srinivasan, K., Vala, K. and Malgaonkar, S., 2018. Study and Research on Raspberry PI 2
Model B Game Design and Development. In Information and Communication Technology for
Sustainable Development (pp. 475-483). Springer, Singapore.
Schmidt, A., 2000. Implicit human computer interaction through context.Personal technologies, 4(2-3),
pp.191-199.
Shneiderman, B., Plaisant, C., Cohen, M., Jacobs, S., Elmqvist, N. and Diakopoulos, N., 2016.
Designing the user interface: strategies for effective human-computer interaction. Pearson.
Silva, H.P.D., Fairclough, S., Holzinger, A., Jacob, R. and Tan, D., 2015. Introduction to the special
issue on physiological computing for human-computer interaction. ACM Transactions on Computer-
Human Interaction (TOCHI), 21(6), p.29.
Yeo, H.S., Lee, B.G. and Lim, H., 2015. Hand tracking and gesture recognition system for human-
computer interaction using low-cost hardware. Multimedia Tools and Applications, 74(8), pp.2687-
2715.
30

APPENDIX 1
The main idea of using a moving target is obtained from fitt’s law which talks about the client
interacting with a computer. The client must be able to interact with a moving target so that the main
idea of measuring human competency can be approximated depending on the different values obtained.
Different clients have different measure of speed, they vary depending on the amount of time
and the distance between the targets. This is mainly obtained from the main ideas of fitt’s law which is
used as a case study in this project
31

APPENDIX 2
Main run of the program
32

APPENDIX 3
Screen width 500 and target size 22
33

APPENDIX 4
Different target position
APPENDIX 5
34

Screen size 350 target 8
35

APPENDIX 6
Values recorded from different targets
36

APPENDIX 7
Excel file containing the values
37