Translog Post-Editing Process Visual Report
An interactive analytical dashboard tracing the MT to PE process as logged by Translog-ii

Session Time

1681.88s

MT → PE Change Rate

24.62%

Corrections

52

Initial Delay

493.58s

Source Length

2821

MT Length

796

PE Length

934

Total Events

574

Reading Speed and Edit Intensity Trends

Reading: cursor movement settings
Editing: included actions
How is Reading Speed Score calculated?
The code computes per-step score using section indices, then time-averages into each window.
Exact equations (from implementation):
  section = floor(max(0,cursor) / granularity)
  distFromStart = currSection - startSection
  elapsed = (currTime - startTime) / 1000
  baseScore = distFromStart / elapsed
  overlap = max(0, min(right, maxReachedSection) - left + 1)
  penalty = revisitPenaltyWeight * (overlap / elapsed)
  stepScore = baseScore - penalty
where left=min(prevSection,currSection) and right=max(prevSection,currSection).

How variables are determined (concrete)
Suppose cursor events (chars) are: 12 → 64 → 230 → 160.
If granularity=25, section mapping is:
  12→0, 64→2, 230→9, 160→6.
Then:
  startSection = 0 (from first cursor=12),
  for last step 230→160: prevSection=9, currSection=6.
Running maximum by step: 0 → 2 → 9, so before processing step 9→6, maxReachedSection=9.
After processing that step, it remains max(9,6)=9.

How Section granularity changes these values
Using the same cursor sequence 12 → 64 → 230 → 160:
• If granularity=25: sections are 0,2,9,6.
• If granularity=50: sections are 0,1,4,3.
So startSection, prevSection, currSection, and maxReachedSection are all derived from the same cursor path but at different section resolution.

Numeric Example
Suppose: startSection=0, current step moves prevSection=9 → currSection=6, and maxReachedSection=12.
Then left=6, right=9, so:
  overlap = min(9,12)-6+1 = 4 sections.
If currTime-startTime=20s, then:
  distFromStart = 6-0 = 6, baseScore = 6/20 = 0.3000.
With revisitPenaltyWeight=1.5:
  penalty = 1.5*(4/20)=0.3000, so stepScore = 0.3000-0.3000=0.0000.
With revisitPenaltyWeight=2.0 (same step):
  penalty = 2.0*(4/20)=0.4000, so stepScore = 0.3000-0.4000=-0.1000.
Final trend point is the step-score time average in that window, then multiplied by 60 for display.
For Editing Intensity Heat, Translog-II may log wrong cursor positions for key:ime. Keep key:ime unchecked unless you explicitly want to include that noise.
Time-based Trend shows Reading Speed Score and Edit Intensity by session time windows.
Reading Speed Score = start→target elapsed-time speed on cursor sections (IME ignored), with revisit penalties for re-covered ranges.
Reading Rule = base score uses start→current elapsed time, then subtracts revisit penalties on overlapped visited ranges.
Edit Intensity = (sum of selected editing actions) ÷ minutes per window.
Normalize Reading Scale rescales reading line magnitude to the same y-range as Edit Intensity for visual comparability.
Window = 10 seconds per point. Adjust granularity/penalty or editing actions then click Re-draw Graph.

Position-based Reading Speed and Edit Intensity Trends

Reading: cursor movement settings (position-based)
Position-based Trend shows Reading Speed Score and Edit Intensity along text positions (character sections).
X axis is character index position; each point summarizes one section controlled by Section granularity.
Use case compare where in the text reading/editing burden concentrates, independent of timeline order.

Action Types Summary

ActionCountPercentage
key:navi:[right]12121.08%
mouse:down11920.73%
mouse:up11520.03%
key:ime6711.67%
key:delete529.06%
key:insert529.06%
key:navi:[left]468.01%
system:start10.17%
system:stop10.17%

Interactive Heat Map Overlay

MT Text Heat Overlay

Reading Speed Heat

·C线###M. B.··#"libra pondo"lblb#119302#£19031923·#·西#£仿

Data Export

Browser download restrictions may block bulk exports. Please export no more than 8 CSV files at once.
Quick Apply Examples:
Pivot Table Help
1) Select one or more datasets in the checklist (for example cursor_timeline, segment_detail_vicinity, time_trend).
2) Click Refresh Pivot Fields so the Row/Column/Value fields reflect currently selected data.
3) Choose Row field as your grouping key, optionally choose a Column field for cross-tab, then set Value field + Aggregation.
4) Click Build Pivot Table to generate the matrix; click Generate Pivot Graph for an interactive chart; click Export Pivot CSV for the current pivot result.

Pivot control meanings
Row field: primary grouping key (x-axis categories). Example: window_index.
Column field: secondary grouping key (creates multi-series columns). Example: vicinity_adaptive.
Value field: numeric/text field to aggregate. Example: duration_ms.
Aggregation: how grouped values are combined.
  – count: number of rows in the group. Example: 12 rows → result 12.
  – sum: arithmetic sum of numeric values. Example: 2.5, 1.0, 3.5 → 7.0.
  – avg: mean of numeric values. Example: (2.5+1.0+3.5)/3 = 2.3333.
  – min: smallest numeric value in the group. Example: min(2.5,1.0,3.5)=1.0.
  – max: largest numeric value in the group. Example: max(2.5,1.0,3.5)=3.5.
  Note: for non-numeric values, count is safest and most interpretable.
Chart type: visualization style for pivot result. Use line for ordered series and bar for category comparison.

Field meanings (intuitive + examples)
dataset: source dataset name of each row. Example: cursor_timeline, segment_detail_vicinity.
window_index: nth cursor timeline window. Example: 1, 2, 3... used for chronological grouping.
minute_in_session: time bucket in minutes since start. Example: 4.5 means around minute 4:30.
text_position_char_index: character-index location in text. Example: 500 means around character 500 region.
reading_speed_score: model score of reading progression speed (higher = faster progression).
edit_intensity: editing activity density in the bucket/section.
segment_type/type: diff opcode category. Common values: replace, insert, delete.
duration_ms: estimated duration in milliseconds. Example: 3200 = ~3.2 seconds.
vicinity_before/vicinity_after: context chars used for duration estimation in popup logic.
vicinity_adaptive: 1 = adaptive vicinity enabled, 0 = fixed vicinity.
forward_chars/backward_chars: cursor movement magnitude in each timeline window.
pause_seconds: accumulated gap time where gap_ms >= pause_threshold_ms.
focus_loss_count: number of blur/out-of-focus events in that window.
duration_seconds: duration in seconds (window or segment, depending on dataset).
forward_rate_cps/backward_rate_cps: forward/backward chars per second in a timeline window.
net_cursor_delta: end cursor minus start cursor for a timeline window.
pause_ratio_pct: pause time ÷ total duration × 100 (percentage).
pause_per_100_chars: pause seconds normalized by segment span size.
active_edit_seconds: duration_seconds − pause_seconds for segment-level rows.
events_in_range: number of activity events inside segment vicinity/time span.
chars_per_sec: span or progress normalized by duration (speed-like productivity field).
segment_end_cursor: segment end anchor cursor (= anchor + span).
segment_mt_text/segment_pe_text: segment text snapshot for MT and PE.
segment_raw_xml: raw event XML lines linked to this segment (CSV export enrichment when Row=segment_id).
pause_threshold_ms: user-selected long-gap threshold used in pause calculations.
pause_source: pause computation source (segment raw events or vicinity activity fallback).
action (heat arrays): action category key that contributes to heat values.
value (heat arrays/char maps/events): numeric heat contribution or event payload text, depending on dataset.

pause_seconds vs duration_seconds (exact)
duration_seconds is total segment/window span duration.
pause_seconds is accumulated long-gap time inside that span, where each gap satisfies gap_ms >= pause_threshold_ms.
pause_threshold_ms is user-configurable via Pause long-gap threshold (ms) slider in Data Export.
• For segment-level pause metrics, gaps are computed from that segment's raw_xml event times (not broad vicinity activity fallback when raw exists).
• Formula: pause_ratio_pct = (pause_seconds / duration_seconds) × 100.
• Example: if duration_seconds=23 and pause_seconds=7, then pause_ratio_pct=30.43%; active editing time is 23-7=16s.

Recommended usage examples
Revert Timeline — Dataset: cursor_timeline
  Row = window_index, Column = (none), Value = backward_chars, Agg = sum
  Goal: visualize where revert-heavy windows appear.
Time Edit Intensity — Dataset: time_trend
  Row = minute_in_session, Column = (none), Value = edit_intensity, Agg = avg
  Goal: inspect temporal editing workload profile.
Event Distribution — Dataset: replay_events
  Row = event_type, Column = tag, Value = time_ms, Agg = count
  Goal: compare distribution of event categories.
Heat by Action — Dataset: mt_heat_map or pe_heat_map
  Row = action, Column = (none), Value = value, Agg = sum
  Goal: compare total action contribution to heat values.
Segment Type Counts — Dataset: segment_meta
  Row = type, Column = (none), Value = id, Agg = count
  Goal: compare distribution of edit operation types.

Scatter: Pause vs Revert — Dataset: cursor_timeline
  Row = pause_seconds, Column = (none), Value = backward_chars, Agg = avg, Chart = scatter
  Goal: inspect whether higher pauses correlate with stronger reverts.
Scatter: Span vs Duration — Dataset: segment_detail_vicinity
  Row = span_len, Column = (none), Value = duration_ms, Agg = avg, Chart = scatter
  Goal: inspect relation between segment span size and editing duration.
Forward Timeline — Dataset: cursor_timeline
  Row = window_index, Value = forward_chars, Agg = sum.
  Goal: identify windows with strongest forward drafting progress.
Pause Timeline — Dataset: cursor_timeline
  Row = window_index, Value = pause_seconds, Agg = sum.
  Goal: locate concentration of hesitation and planning time.
Focus Loss Timeline — Dataset: cursor_timeline
  Row = window_index, Value = focus_loss_count, Agg = sum.
  Goal: locate likely distraction-heavy windows.
Segment Duration by Type — Dataset: segment_meta
  Row = type, Value = duration_ms, Agg = avg.
  Goal: compare which edit operation types are slower on average.
Segment Pause Ratio — Dataset: segment_detail_vicinity
  Row = segment_id, Value = pause_ratio_pct, Agg = avg, Chart = bar.
  Goal: compare pause burden per segment. Formula: pause_ratio_pct = (pause_seconds / duration_seconds) × 100.
  Example: duration=23s, pause=7s → pause_ratio_pct = (7/23)×100 = 30.43%.
Adaptive Duration Compare — Dataset: segment_detail_vicinity
  Row = segment_type, Column = vicinity_adaptive, Value = duration_ms, Agg = avg.
  Goal: quantify sensitivity of duration estimates to adaptive vicinity mode.
MT vs PE Action Heat — Datasets: mt_heat_map + pe_heat_map
  Row = action, Column = dataset, Value = value, Agg = sum.
  Goal: compare action concentration patterns between MT and PE text spaces.
Scatter: Pause vs Focus Loss — Dataset: cursor_timeline
  Row = pause_seconds, Value = focus_loss_count, Agg = avg, Chart = scatter.
  Goal: inspect whether longer pauses co-occur with attention switches.
Scatter: Time vs Cursor — Dataset: replay_events
  Row = time_ms, Value = cursor, Agg = avg, Chart = scatter.
  Goal: inspect trajectory shape of cursor growth over session time.
Progress Time Curve — Dataset: paragraph_markers
  Row = paragraph_index, Value = elapsed_sec, Agg = max.
  Goal: inspect pace differences between early and late document progression.
Scatter: Char X vs Y — Dataset: target_char_map
  Row = x, Value = y, Agg = avg, Chart = scatter.
  Goal: inspect spatial layout structure and wrapping geometry of target text.
Adaptive vicinity reactivity
The dataset segment_detail_vicinity is reactive to Vicinity Before, Vicinity After, and Adaptive toggle in the Full Compiled Text panel.
When these settings change, pivot fields/results/charts are refreshed automatically.
(Build Pivot Table to view result)

Full Compiled Text with Colored Change Tags (MT → PE)

Vicinity Before/After define how much context is included on each side of the selected changed section when estimating duration.
Example: section = cursor 520–532, before=15, after=35 → events from 505 to 567 are considered.
Adaptive mode keeps your current slider values as preferred caps, then clamps them to nearest neighboring changes (start→previous change, end→next change) to avoid crossing unrelated edits.
View range 0% to 100%
Cursor movement timeline summarizes the editor path by time windows. Each window shows forward movement, backward movement, pauses and focus-loss events.
Example: from Time=1203, Cursor=0 to Time=117687, Cursor=48, net movement is forward from 0 to 48 over that elapsed period.
Cursor-path movement ignores IME events because IME cursor entries are often noisy in Translog logs.


·Ezra PoundC 线###Tironian Notes M. B. ParkesPause and EffectDaniel Berkeley UpdikePrinting TypesM. B.··.MB .aPkrse #"libra pondo"lblb

#1ITA1Murray code19302ITA2#£19031923

·#·Hugh KennerThe Mechanic Muse西#£仿

Help: Parameter and Metric Definitions

Session Time
Project end time − project start time; fallback: last event time − first event time.
MT → PE Change Rate
Levenshtein distance(TargetTextUTF8, FinalTextUTF8) ÷ length(TargetTextUTF8) × 100.
Corrections
Count of Key events with Type in {delete, edit}.
Initial Delay
Time from session start to first meaningful Key action: insert/delete/edit/IME input.
Reading Speed Score
From first valid cursor section to current section, speed is based on elapsed time to reach that section; IME ignored; revisited ranges are penalized by user setting.
Edit Intensity
Selected editing actions per time window.
Heat Overlay
Reading heat projects movement-based reading score to section ranges on selected text (MT or PE); editing heat uses selected editing actions only.
Changed Section Hover
Displays estimated edit time range from matched nearby edit events and raw XML snippets.