Homework 2:NASA TLX Form
In this assignment,you willimplement theNASA TLX Workload Assessment
(https:/humansystems.arc.nasa.gov/groups/tlx) as an interactive Kivy application in Python 3.10.x.
"The Official NASA Task Load Index(TLX)is a subjective workload assessment tool which allows users to perform subjective workload asessments on operator(s)working with various human-machine interface systems.Originally developed as a paper and pencil questionnaire by NASA Ames Research Center's (ARC)Sandra Hart in the 1980s,NASA TLXhas become the gold standard for measuring subjective workload across a wide range of applications. "
Video of Application:
This demo video shows some task customization,such as the title at the top of the screen.This implementation exclusively used a game controller instead of a mouse.
Be aware that your assignment will have slightly different functionality than what is shown in this video.
Interactive Web Demo:
https://www.keithv.com/software/nasatlx/(https://www.keithv.com/software/nasatlx1)
(https://www.keithv.com/software/nasatlx/)
Note that this web demo has a few problems:
·It is backwards in that numerical scale ratings are measured before scale weights are determined.
● The middle of the scales should be marked. ·Zero should be a valid scale rating.
Your Implementation:
Your implementation will differ slightly from the examples above,so pay attention to the requirements. Display/Device Independent Rendering
You must use the kivy_config_helper to support simulation of different display densities.Your app should scale appropriately in your layout,fonts,and graphics.You should test at different settings to confirm your app scales correctly.You do not need to support dynamic window resizing,and dynamic resizing can be disabled.
Basic App Layout and Control
Use the Kivy ScreenManager to implement the multiple screens.The window should be 800×600.
The bottom of each screen will have a next-screen and a previous-screen button with appropriate text, except the first screen (next only)and the final screen that displays the results (no next or prev).The next-screen button must be disabled (or not present)until valid selections are made.
All screens of the app should preserve state and the view should be appropriately initialized with its last state if revisited.
Keyboard Control with Focus (GRAD SECTION ONLY REQUIREMENT)
You must support both mouse and keyboard control interaction.For keyboard control,you will use a focus interaction pattern.Tabbing changes focus sequentially between on-screen widgets,with wraparound loop back to the first widget.Focus must be visually indicated and focus order should be reasonable (e.g.left/right,top/down).It is acceptable if mouse interaction affects keyboard focus.Use Return/Enter for executing the previous-screen and next-screen buttons.
Scale Weight Phase
The scale weight phase (pairwise comparisons of factors)must be randomized each run of the
application,including the order within the pairs (e.g.Performance or Effort vs.Effort or Performance). Randomization should only happen once for each run of the app.Revisiting a previous screen should not cause new random ordering.See below for randomization help.
Initially,neither of the two choices are highlighted.However,if clicked,the option will be visually indicated to confirm the choice.
Once a selection is made,the next-screen button should become enabled and available to select.A mouse click initiates an immediate transition to the next screen.
FOR GRAD KEYBOARD CONTROLAND FOCUS REQUIREMENT:The Tab key should switch between on-screen widgets.For pairwise comparisons of scale dimensions,pressing Spacebar or Return/Enter will select the dimension.Visual indication of which widget has focus should be distinct from which is
selected as the choice.You might consider a box.For the next-screen/previous-screen buttons of the ScreenManager,focus,must be visually indicated.Return/Enter will advance to the next screen.
Scale Value Phase
Use the Kivy Canvas drawing capabilities to create a custom,reusable widget type for the numerical
scale widget,which you will reuse per scale.The scale should have marks every 5 units out of a total of 100.Be sure that the midpoint of the scale is marked with a slightly taller line.The participant's numerical scale selection should be depicted as a colored bar that extends from left to right underneath the scale marks (see video above).Note that zero is a valid selection.All scales should start without a score.A left click on the scale will update the colored bar and the associated internally stored score.A left click drag will result in the colored bar following the mouse cursor until release.Once a scale has been set to any value,the scale should be considered visitedfor the purpose of determining if all scales have been
assigned a score(and therefore determining if the next-screen button is enabled).Scores between [0, 100]are considered valid so be sure to support 0.Scale values may snap to increments of 5(e.g.0,5, 10,..)similar to the paper version of the assessment.Or you may use a value of 1.You should also
provide some visual indication that scales have been visited,evenif set to a value of zero.
Your numerical scale widget must be a standalone widget class,which is instantiated multiple times to represent the different dimensions.
Note:Flip the Performance Scale to go left to right from Failure to Perfect (as opposed to the NASA
website description).GT Researchers have found that study participants routinely get confused as all the other factor scales go from Low to High.This change has been determined to be acceptable and is
generally recommended.
FOR GRAD KEYBOARD CONTROLAND FOCUS REQUIREMENT:The keyboard should work with the dimension scale value screen.Tab between interactive scales.Use the Left/Right arrow keys to move the scale value in increments of either 5 or 1.There should be a visual indication of which scale has
focus on the screen,such as a box.
Results Screen
The results screen should show the Rating,Tally,and Weight for each factor and the Overall workload
assessment score.Refer to the NASATLX documentation for how to compute the weights and score (it's easy).You can decide how to format the results,so long is all the information is present and organized reasonably.
Grading
Basic App(10%)
● Resolution
·Screen navigation via kivy ScreenManager
·previous-screen and next-screen buttons
o next-screen disabled or not shown until all user inputs made
o no previous-screen on first screen ·GRAD ONLY:Supports keyboard
o Keyboard-focused previous-screen and next-screen buttons visualized
o Reasonable focus order (e.g.previous-screen,then next-screen)
Scale Weight Phase (30%)
● Randomized
o Pairings randomized
o Pairs randomized
Supports mouse
o Mouse picks choice
·No default selection (user must interact to choose)
·next-screen only enabled if current screen data entry is complete ·GRAD ONLY:Supports keyboard
o Keyboard-focused widget visualized
o Reasonable focus order
Scale Value Phase (50%)
·Custom scale widget
o Custom drawing of scale marks
o Rendering of value bar
·No default selections (user must interact)
·Visual indication that a scale has been set (including a value of O)
● Mouse control
o Left click value bar position set
o Continuous value bar position set via left-click drag
·next-screen only enabled if current screen data entry is complete ·GRAD ONLY:Keyboard control
o Visualize focus
o Interact with value bar via arrow keys
o Reasonable focus order (e.g.top-down for each scale)
Results Screen (5%)
·Results rendered to screen:
o Tally,Weight,and Rating for each dimension(e.g.Mental Demand:3;0.20;20/100)
o Workload Score (e.g.Workload Score:60.51) ·Correct values computed
Polish/Aesthetics (5%)
o Exceeding basic level of readability and function.Attention to detail such as padding,alignment, highlighting,visual grouping,focus,etc.
Display/Device Independent Rendering (up to 10%reduction of grade if not fully implemented)
·Integrate kivy_config_tool and support various display densities through simulation ·Simulation should be turned off in your submitted code
·All layout,widgets,fonts,should scale appropriately for the given display density setting (real or simulated)
·10 point reduction to grade for failure to support display density
Submission (up to 10%reduction of grade if out of compliance)
·Submit all required files in a Zip archive
·readme.txt or readme.md (see below for specific requirements)
Submission
First,please clean your project of any unneeded files.Submit your source and data files in a zip file
named LAST_FIRST_HW2.zip. The entry point of your program must be named main.py.For grading,
the TA will run:
Your main.py should have the kivy_config_helper code at the top of the file,initially with simulation turned off.Expect that the TA willevaluate your code with different simulation settings.
Include a readme.txt or readme.md with:
● Full name
● Email
·GT SSO account name
·Detail anything that doesn't work or you didn't complete
·Detail anything that the grader should look for in cases you decided how to implement something that didn't have specific requirements (e.g.how focus is indicated)
·Any build requirements outside of kivy
Helpful Python Code
Here is a demonstration of n_choose_2 along with shuffling (randomizing).This is helpful for the scale weight phase of the assessment.Note that workload dimension comparisons should also randomize the ordering within each pair (e.g."Performance or Effort"vs."Effort or Performance").
flavor combos.pV(https://gatech.instructure.com/courses/409430/files/52859429?wrap=1)↓ (https://gatech.instructure.com/courses/409430/files/52859429/download?download_frd=1)
Also see the following Canvas page for demonstration of custom rendered Widget (clock widget),Screen Manager,and focus demonstration: Kivy Course Resources
(https://qatech.instructure.com/courses/409430/pages/kivy-course-resources?wrap=1)
TIP: The Kivy ScreenManager triggers the on_enter()event for a screen before the on_kv_post()
method is called.Therefore,if you need to perform. actions that depend on the screen being fully
initialized (such as setting widget focus),you should defer these actions until on_kv_post()has been executed.