代写Homework 2: NASA TLX Form代做留学生Python程序

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:

python main.py

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.