synced with dev version. Mostly OCR related

app.py

@@ -22,6 +22,11 @@ import zipfile
 from matplotlib import font_manager
 import os
 
+try:
+    from create_interest_areas_from_image import recognize_text
+except Exception as e:
+    print(e)
+
 from multi_proc_funcs import (
     ALL_FIX_MEASURES,
     COLORS,
@@ -236,7 +241,7 @@ COLNAME_CANDIDATES_CUSTOM_CSV_FIX = {
     "trial_id_col_name_fix": ["trial_id", "trialid", "trial", "trial_num", "id"],
     "subject_col_name_fix": ["subject", "sub", "subid", "sub_id"],
     "time_start_col_name_fix": ["start", "start_time", "ts", "t_start", "starttime"],
-    "time_stop_col_name_fix": ["stop", "stop_time", "te", "t_end", "t_stop", "stoptime"],
+    "time_stop_col_name_fix": ["end","stop", "stop_time", "te", "t_end", "t_stop", "stoptime"],
 }
 COLNAME_CANDIDATES_CUSTOM_CSV_FIX_DEFAULT = {k: v[0] for k, v in COLNAME_CANDIDATES_CUSTOM_CSV_FIX.items()}
 
@@ -923,6 +928,8 @@ def make_trial_from_stimulus_df(
     stim_plot_df,
     filename,
     trial_id,
+    close_gaps_between_words:bool,
+    close_gaps_between_lines:bool,
 ):
     chars_list = []
     words_list = []
@@ -931,6 +938,12 @@ def make_trial_from_stimulus_df(
         chars_list.append(char_dict)
 
     words_list, chars_list = ut.add_words(chars_list)
+    if close_gaps_between_words:
+        words_list = ut.close_gaps_in_words_list(words_list)
+    if close_gaps_between_lines:
+        chars_list = ut.close_gaps_between_lines(chars_list,prefix='char') 
+        words_list = ut.close_gaps_between_lines(words_list,prefix='word') 
+
     letter_width_avg = np.mean([x["char_xmax"] - x["char_xmin"] for x in chars_list if x["char_xmax"] > x["char_xmin"]])
     line_heights = [x["char_ymax"] - x["char_ymin"] for x in chars_list]
     line_xcoords_all = [x["char_x_center"] for x in chars_list]
@@ -1034,12 +1047,15 @@ def get_fixations_file_trials_list(dffix, stimulus):
     for trial_id, subdf in stqdm(enum, desc="Creating trials"):
         if isinstance(stimulus, pd.DataFrame):
             stim_df = stimulus[stimulus.trial_id == subdf["trial_id"].iloc[0]]
+            if stim_df.empty:
+                st.session_state["logger"].warning(f"stim_df dataframe is empty because trial_id {trial_id} not in stimulus trial ids:\n{stimulus.trial_id.unique()}")
 
             stim_df = stim_df.dropna(axis=0, how="all")
             subdf = subdf.dropna(axis=0, how="all")
             stim_df = stim_df.dropna(axis=1, how="all")
             subdf = subdf.dropna(axis=1, how="all")
             if subdf.empty:
+                st.session_state["logger"].warning(f"Sub dataframe is empty for trial_id {trial_id}")
                 continue
             subdf = subdf.reset_index(drop=True).copy()
             stim_df = stim_df.reset_index(drop=True).copy()
@@ -1048,6 +1064,8 @@ def get_fixations_file_trials_list(dffix, stimulus):
                 stim_df,
                 st.session_state["single_csv_file_stim"].name,
                 trial_id,
+                close_gaps_between_words=st.session_state["close_gap_between_words_single_csv"],
+                close_gaps_between_lines=st.session_state["close_gap_between_lines_single_csv"],
             )
         else:
             if "trial_id" in stimulus.keys() and (
@@ -1072,20 +1090,25 @@ def get_fixations_file_trials_list(dffix, stimulus):
 
     return trials_by_ids, trial_keys
 
+def make_ints_float(df):
+    for col in df.columns:
+        if 'int' in str(df[col].dtype).lower():
+            df[col] = pd.to_numeric(df[col], downcast='float') 
+    return df
 
 def load_csv_delim_agnostic(file_path):
     try:
         df = pd.read_csv(file_path)
         if df.shape[1] > 1:
-            return df
+            return make_ints_float(df)
         else:
             dec_file = get_decoded_input_from_file(file_path)
             df = pd.read_csv(StringIO(dec_file.replace(";", ",").replace("\t", ",")))
-            return df
+            return make_ints_float(df)
     except Exception as e:
         dec_file = get_decoded_input_from_file(file_path)
         df = pd.read_csv(StringIO(dec_file.replace(";", ",").replace("\t", ",")))
-        return df
+        return make_ints_float(df)
 
 
 def find_col_name_suggestions(cols, candidates_dict):
@@ -1374,6 +1397,7 @@ def main():
             trial_choices_single_asc, trials_by_ids, lines, asc_file, trials_dict = ut.get_trials_list(
                 st.session_state["single_asc_file_asc"],
                 close_gap_between_words=st.session_state["close_gap_between_words_single_asc"],
+                close_gap_between_lines=st.session_state["close_gap_between_lines_single_asc"],
                 paragraph_trials_only=st.session_state["paragraph_trials_only_single_asc"],
                 ias_files=st.session_state["single_asc_file_ias_files"],
                 trial_start_keyword=trial_start_keyword,
@@ -1981,10 +2005,22 @@ def main():
             "Select .csv or .json file containing the stimulus data",
             accept_multiple_files=False,
             key="single_csv_file_stim_uploaded",
-            type={"json", "csv", "txt", "dat"},
-            help="Drag and drop or select a single .json, .csv, .txt or .dat file that you wish to process as the stimulus file for the uploaded fixation data. This can be left blank if you chose to use the examples.",
+            type={"json", "csv", "txt", "dat","jpeg","png"},
+            help="Drag and drop or select a single .json, .csv, .txt, .dat, jpeg or png file that you wish to process as the stimulus file for the uploaded fixation data. If an image is uploaded OCR will be attempted to extract the character bounding boxes. This can be left blank if you chose to use the examples.",
         )
 
+        st.checkbox(
+            label="Should spaces between words be included in word bounding box?",
+            value=get_default_val("close_gap_between_words_csv", True),
+            key="close_gap_between_words_single_csv",
+            help="If this is selected, each word bounding box will include half the spaces between adjacent words. If not, the word bounding boxes will simply be the combined bounding boxes of the letters making up the word.",  # TODO check if this affects analysis
+        )
+        st.checkbox(
+            label="Should spaces between lines be included in word and character bounding boxes?",
+            value=get_default_val("close_gap_between_lines_single_csv", True),
+            key="close_gap_between_lines_single_csv",
+            help="If this is selected, each word and char bounding box will include half the spaces between adjacent lines.",  # TODO check if this affects analysis
+        )
         use_example_or_uploaded_file_choice = st.radio(
             "Should the uploaded files be used or some example files?",
             index=1,
@@ -2024,6 +2060,11 @@ def main():
                 trial = json.loads(decoded_input)
                 st.session_state["stimdf_single_csv"] = trial
                 colnames_stim = list(st.session_state["stimdf_single_csv"].keys())
+            elif any([".png" in single_csv_stim_file.name, ".jpeg" in single_csv_stim_file.name]):
+                stimdf_single_csv = recognize_text(single_csv_stim_file)
+                stimdf_single_csv.to_csv(RESULTS_FOLDER / f"{single_csv_stim_file.name}_stimdf_single_from_OCR.csv")
+                st.session_state["stimdf_single_csv"] = stimdf_single_csv
+                colnames_stim = st.session_state["stimdf_single_csv"].columns
             else:
                 st.session_state["stimdf_single_csv"] = load_csv_delim_agnostic(single_csv_stim_file)
                 colnames_stim = st.session_state["stimdf_single_csv"].columns
@@ -2407,6 +2448,7 @@ def main():
                     use_corrected_fixations=True,
                     correction_algo=st.session_state["algo_choice_custom_eyekit"],
                     save_to_csv=True,
+                    measures_to_calculate = ALL_MEASURES_OWN
                 )
                 st.dataframe(own_word_measures, use_container_width=True, hide_index=True, height=200)
                 own_word_measures_csv = convert_df(own_word_measures)
@@ -3056,6 +3098,7 @@ def main():
                             use_corrected_fixations=True,
                             correction_algo=st.session_state["algo_choice_multi_asc_eyekit"],
                             save_to_csv=True,
+                            measures_to_calculate = ALL_MEASURES_OWN
                         )
                     if "sentence_measures_multi_asc" in st.session_state:
                         sent_measures_multi = st.session_state["sentence_measures_multi_asc"]
@@ -3219,6 +3262,12 @@ def show_file_parsing_settings(suffix: str):
         key=f"close_gap_between_words{suffix}",
         help="If this is selected, each word bounding box will include half the spaces between adjacent words. If not, the word bounding boxes will simply be the combined bounding boxes of the letters making up the word.",  # TODO check if this affects analysis
     )
+    st.checkbox(
+        label="Should spaces between lines be included in word and character bounding boxes?",
+        value=get_default_val(f"close_gap_between_lines{suffix}", True),
+        key=f"close_gap_between_lines{suffix}",
+        help="If this is selected, each word and char bounding box will include half the spaces between adjacent lines.",  # TODO check if this affects analysis
+    )
     st.markdown("### Trial filtering settings")
 
     st.checkbox(

create_interest_areas_from_image.py

@@ -0,0 +1,237 @@
+from PIL import Image, ImageDraw
+import pandas as pd
+import io
+import csv
+import os
+
+if os.environ.get('TESSDATA_PREFIX') is None and os.name == 'nt':
+    os.environ['TESSDATA_PREFIX'] = 'C:/Program Files/Tesseract-OCR/tessdata/'
+    tessdata_prefix = 'C:/Program Files/Tesseract-OCR/tessdata/'
+if os.environ.get('TESSDATA_PREFIX') is None and os.name != 'nt':
+    os.environ['TESSDATA_PREFIX'] = '/usr/share/tesseract-ocr/4.00/tessdata'
+    tessdata_prefix = '/usr/share/tesseract-ocr/4.00/tessdata'
+    
+import pytesseract
+if os.name == 'nt':
+    pytesseract.pytesseract.tesseract_cmd = r'c:/Program Files/Tesseract-OCR/tesseract.exe'
+else:
+    pytesseract.pytesseract.tesseract_cmd =r'/usr/bin/tesseract'
+
+def recognize_text(image_path, tesseract_config='--psm 6 -l spa'):
+    """
+    Performs OCR on an image and returns a DataFrame with character bounding boxes
+    and associated information.
+
+    Args:
+        image_path: Path to the image file.
+        tesseract_config: Configuration string for pytesseract (e.g., '--psm 6 -l spa').
+
+    Returns:
+        pandas.DataFrame: DataFrame containing character-level data (df_word_chars).
+    """
+    # if os.environ['TESSDATA_PREFIX'] is not None:
+    #     tesseract_config =  f'--tessdata-dir "{tessdata_prefix}"' + tesseract_config
+    image = Image.open(image_path).convert('RGB')
+    if hasattr(image_path,'name'):
+        im_name = image_path.name
+    else:
+        im_name = image_path
+    image_height = image.height
+
+    # Extract filename for trial_id
+    trial_id = os.path.splitext(os.path.basename(im_name))[0]
+
+    # Use pytesseract to extract data for words and characters
+    data_words = pytesseract.image_to_data(image, config=tesseract_config)
+    data_chars = pytesseract.image_to_boxes(image, config=tesseract_config)
+
+    df_words = pd.read_csv(io.StringIO(data_words), sep='\t', quoting=csv.QUOTE_NONE)
+    df_chars = pd.read_csv(io.StringIO(data_chars), sep=' ', header=None, names=['char', 'left', 'top', 'right', 'bottom', 'unknown'])
+
+    # Fix character coordinates
+    for index, row in df_chars.iterrows():
+        original_top = int(row['top'])
+        original_bottom = int(row['bottom'])
+        df_chars.at[index, 'top'] = image_height - original_bottom
+        df_chars.at[index, 'bottom'] = image_height - original_top
+
+    # Create DataFrame to store spaces
+    df_spaces = pd.DataFrame(columns=['level', 'page_num', 'block_num', 'par_num', 'line_num', 'word_num', 'left', 'top', 'width', 'height', 'conf', 'text'])
+
+    # Group words by line, block, and paragraph
+    grouped_lines = df_words.groupby(['block_num', 'par_num', 'line_num'])
+
+    for (block_num, par_num, line_num), line_words_df in grouped_lines:
+        sorted_words = line_words_df.sort_values(by='left')
+        previous_word = None
+        for index, current_word in sorted_words.iterrows():
+            if previous_word is not None:
+                space_left = int(previous_word['left']) + int(previous_word['width'])
+                space_width = int(current_word['left']) - space_left
+                if space_width > 0:
+                    space_top = int(previous_word['top'])
+                    space_height = int(previous_word['height'])
+                    space_data = {
+                        'level': 5,
+                        'page_num': int(current_word['page_num']),
+                        'block_num': int(current_word['block_num']),
+                        'par_num': int(current_word['par_num']),
+                        'line_num': int(current_word['line_num']),
+                        'word_num': int(previous_word['word_num']),
+                        'left': space_left,
+                        'top': space_top,
+                        'width': space_width,
+                        'height': space_height,
+                        'conf': 0,
+                        'text': ' '
+                    }
+                    df_spaces = pd.concat([df_spaces, pd.DataFrame(space_data, index=[0])], ignore_index=True)
+            previous_word = current_word
+
+    # Create DataFrame for characters within words (and spaces)
+    df_word_chars = pd.DataFrame(columns=['char', 'char_xmin', 'char_ymin', 'char_xmax', 'char_ymax',
+                                            'block', 'paragraph', 'line_number',
+                                            'word_nr', 'letter_nr', 'word',
+                                            'char_x_center', 'char_y_center', 'assigned_line', 'trial_id'])
+
+
+    for index_word, row_word in df_words.iterrows():
+        if isinstance(row_word['text'], str) and row_word['text'].strip() and row_word['level'] == 5:
+            word_left = int(row_word['left'])
+            word_top = int(row_word['top'])
+            word_width = int(row_word['width'])
+            word_height = int(row_word['height'])
+            word_right = word_left + word_width
+            word_bottom = word_top + word_height
+            word_text = row_word['text']
+
+            char_index_in_word = 0
+            relevant_chars = df_chars[
+                (df_chars['left'] >= word_left) & (df_chars['right'] <= word_right) &
+                (df_chars['top'] >= word_top) & (df_chars['bottom'] <= word_bottom)
+            ]
+            relevant_chars = relevant_chars.sort_values(by='left')
+            previous_char_right = word_left
+
+            for index_char, row_char in relevant_chars.iterrows():
+                char_text = row_char['char']
+                char_left = previous_char_right
+                char_right = int(row_char['right'])
+                char_right = min(char_right, word_right)
+                if char_left > char_right:
+                    char_right = int(row_char['right'])
+                char_top = word_top
+                char_bottom = word_bottom
+
+                char_data = {
+                    'char': char_text,
+                    'char_xmin': int(round(char_left)),  # Round and convert to int
+                    'char_ymin': int(round(char_top)),   # Round and convert to int
+                    'char_xmax': int(round(char_right)),  # Round and convert to int
+                    'char_ymax': int(round(char_bottom)), # Round and convert to int
+                    'block': int(row_word['block_num']),
+                    'paragraph': int(row_word['par_num']),
+                    'line_number': int(row_word['line_num']),
+                    'word_nr': int(row_word['word_num']),
+                    'letter_nr': int(char_index_in_word), #already an int
+                    'word': word_text,
+                    'char_x_center': int(round((char_left + char_right) / 2)),  # Round and convert
+                    'char_y_center': int(round((char_top + char_bottom) / 2)),  # Round and convert
+                    'assigned_line': None,
+                    'trial_id': trial_id
+                }
+                df_word_chars = pd.concat([df_word_chars, pd.DataFrame(char_data, index=[0])], ignore_index=True)
+                char_index_in_word += 1
+                previous_char_right = char_right
+
+            spaces_following_word = df_spaces[
+                (df_spaces['word_num'] == int(row_word['word_num'])) &
+                (df_spaces['line_num'] == int(row_word['line_num'])) &
+                (df_spaces['block_num'] == int(row_word['block_num'])) &
+                (df_spaces['par_num'] == int(row_word['par_num']))
+            ]
+
+            for index_space, row_space in spaces_following_word.iterrows():
+                space_data = {
+                    'char': ' ',
+                    'char_xmin': int(round(row_space['left'])),    # Round and convert
+                    'char_ymin': int(round(row_space['top'])),     # Round and convert
+                    'char_xmax': int(round(row_space['left'] + row_space['width'])),  # Round and convert
+                    'char_ymax': int(round(row_space['top'] + row_space['height'])), # Round and convert
+                    'block': int(row_space['block_num']),
+                    'paragraph': int(row_space['par_num']),
+                    'line_number': int(row_space['line_num']),
+                    'word_nr': int(row_space['word_num']),
+                    'letter_nr': int(char_index_in_word),  # Already int
+                    'word': word_text,
+                    'char_x_center': int(round((row_space['left'] + row_space['left'] + row_space['width']) / 2)), # Round
+                    'char_y_center': int(round((row_space['top'] + row_space['top'] + row_space['height']) / 2)), # Round
+                    'assigned_line': None,
+                    'trial_id': trial_id
+                }
+                df_word_chars = pd.concat([df_word_chars, pd.DataFrame(space_data, index=[0])], ignore_index=True)
+                char_index_in_word += 1
+
+    # Create 'assigned_line' column
+    df_word_chars['assigned_line'] = 0
+    line_counter = 1
+    for block_num in sorted(df_word_chars['block'].unique()):
+        for par_num in sorted(df_word_chars.loc[df_word_chars['block'] == block_num, 'paragraph'].unique()):
+            for line_num in sorted(df_word_chars.loc[(df_word_chars['block'] == block_num) & (df_word_chars['paragraph'] == par_num), 'line_number'].unique()):
+                line_mask = (df_word_chars['line_number'] == line_num) & (df_word_chars['paragraph'] == par_num) & (df_word_chars['block'] == block_num)
+                df_word_chars.loc[line_mask, 'assigned_line'] = line_counter
+                line_counter += 1
+
+    # Adjust Y_Start, Y_End, and char_y_center, converting to integers
+    for assigned_line in df_word_chars['assigned_line'].unique():
+        line_mask = (df_word_chars['assigned_line'] == assigned_line)
+        min_top = df_word_chars.loc[line_mask, 'char_ymin'].min()
+        max_bottom = df_word_chars.loc[line_mask, 'char_ymax'].max()
+        new_y_center = (min_top + max_bottom) / 2
+        df_word_chars.loc[line_mask, 'char_ymin'] = int(round(min_top))      # Round and convert
+        df_word_chars.loc[line_mask, 'char_ymax'] = int(round(max_bottom))     # Round and convert
+        df_word_chars.loc[line_mask, 'char_y_center'] = int(round(new_y_center)) # Round and convert
+
+    # Convert relevant columns to integers
+    int_columns = ['char_xmin', 'char_ymin', 'char_xmax', 'char_ymax', 'block', 'paragraph',
+                    'line_number', 'word_nr', 'letter_nr', 'char_x_center', 'char_y_center', 'assigned_line']
+    for col in int_columns:
+        df_word_chars[col] = df_word_chars[col].astype(int)
+
+    return df_word_chars
+
+
+def draw_char_boxes(image_path, df_word_chars, output_path='output_boxes_combined.png'):
+    """
+    Draws bounding boxes around characters on the image.
+
+    Args:
+        image_path: Path to the image file.
+        df_word_chars: DataFrame containing character bounding box data.
+        output_path: Path to save the image with bounding boxes.  Defaults to 'output_boxes_combined.png'.
+    """
+    image = Image.open(image_path).convert('RGB')
+    draw = ImageDraw.Draw(image)
+
+    # Draw bounding boxes for characters (purple)
+    for index, row in df_word_chars.iterrows():
+        left = int(row['char_xmin'])
+        top = int(row['char_ymin'])
+        right = int(row['char_xmax'])
+        bottom = int(row['char_ymax'])
+        draw.rectangle([(left, top), (right, bottom)], outline='purple', width=1)
+
+    # Display or save the image
+    image.save(output_path)
+
+
+# Example usage
+if __name__ == '__main__':
+    # image_path = 'testfiles/testim_ocr.png'
+    image_path = 'testfiles/newplot.png'
+    # Example with default tesseract config
+    df_chars = recognize_text(image_path)
+    draw_char_boxes(image_path, df_chars)
+    df_chars.to_csv('testim_ocr_df_word_chars_test.csv', index=False)
+    print("\nDataFrame of Characters within Words (df_word_chars) - Default Config:")
+    print(df_chars)

eyekit_measures.py

@@ -17,7 +17,6 @@ MEASURES_DICT = {
     "second_pass_duration": [],
     "initial_landing_position": [],
     "initial_landing_distance": [],
-    "landing_distances": [],
     "number_of_regressions_in": [],
 }
 

multi_proc_funcs.py

@@ -16,6 +16,7 @@ from matplotlib.font_manager import FontProperties
 from matplotlib.patches import Rectangle
 from tqdm.auto import tqdm
 import torch as t
+t.classes.__path__ = [] # https://discuss.streamlit.io/t/error-in-torch-with-streamlit/90908/3
 import plotly.express as px
 import copy
 
@@ -1992,8 +1993,12 @@ def add_popEye_cols_to_dffix(dffix, algo_choice, chars_df, trial, xcol, cols_to_
             ].reset_index()
             selected_stimmat.loc[:, "letword"] = selected_stimmat.groupby("in_word_number")["letternum"].rank()
             letters_on_line = selected_stimmat.shape[0]
-            out = dffix.loc[i, xcol] - selected_stimmat["char_x_center"]
-            min_idx = out.abs().idxmin()
+            if len(selected_stimmat["char_x_center"])>0:
+                out = dffix.loc[i, xcol] - selected_stimmat["char_x_center"]
+                min_idx = out.abs().idxmin()
+                # ic(selected_stimmat)
+            else:
+                min_idx = 0
             dffix.loc[i, f"letternum_{algo_choice}"] = selected_stimmat.loc[min_idx, "letternum"]
             dffix.loc[i, f"letter_{algo_choice}"] = selected_stimmat.loc[min_idx, "char"]
             dffix.loc[i, f"line_let_{algo_choice}"] = selected_stimmat.loc[min_idx, "letline"]

requirements.txt

@@ -22,4 +22,5 @@ pycairo
 eyekit
 stqdm
 jellyfish
-icecream
+icecream
+pytesseract

utils.py

@@ -1,6 +1,7 @@
 import pickle
 from io import StringIO
 import re
+from typing import Dict, List
 import zipfile
 import os
 import plotly.graph_objects as go
@@ -17,6 +18,8 @@ from tqdm.auto import tqdm
 import time
 import requests
 from icecream import ic
+import collections
+import statistics
 from matplotlib import font_manager
 from multi_proc_funcs import (
     COLORS,
@@ -99,13 +102,14 @@ def download_url(url, target_filename):
 
 
 def asc_to_trial_ids(
-    asc_file, close_gap_between_words, paragraph_trials_only, ias_files, trial_start_keyword, end_trial_at_keyword
+    asc_file, close_gap_between_words,close_gap_between_lines, paragraph_trials_only, ias_files, trial_start_keyword, end_trial_at_keyword
 ):
     asc_encoding = ["ISO-8859-15", "UTF-8"][0]
     trials_dict, lines = file_to_trials_and_lines(
         asc_file,
         asc_encoding,
         close_gap_between_words=close_gap_between_words,
+        close_gap_between_lines=close_gap_between_lines,
         paragraph_trials_only=paragraph_trials_only,
         uploaded_ias_files=ias_files,
         trial_start_keyword=trial_start_keyword,
@@ -122,7 +126,7 @@ def asc_to_trial_ids(
 
 
 def get_trials_list(
-    asc_file, close_gap_between_words, paragraph_trials_only, ias_files, trial_start_keyword, end_trial_at_keyword
+    asc_file, close_gap_between_words,close_gap_between_lines, paragraph_trials_only, ias_files, trial_start_keyword, end_trial_at_keyword
 ):
     if hasattr(asc_file, "name"):
         savename = pl.Path(asc_file.name).stem
@@ -132,6 +136,7 @@ def get_trials_list(
     trials_by_ids, lines, trials_dict = asc_to_trial_ids(
         asc_file,
         close_gap_between_words=close_gap_between_words,
+        close_gap_between_lines=close_gap_between_lines,
         paragraph_trials_only=paragraph_trials_only,
         ias_files=ias_files,
         trial_start_keyword=trial_start_keyword,
@@ -238,9 +243,9 @@ def add_words(chars_list):
             word_ymin = chars_list_reconstructed[word_start_idx]["char_ymin"]
             word_ymax = chars_list_reconstructed[word_start_idx]["char_ymax"]
             word_x_center = round((word_xmax - word_xmin) / 2 + word_xmin, ndigits=2)
-            word_y_center = round((word_ymax - word_ymin) / 2 + word_ymin, ndigits=2)
+            word_y_center = chars_list_reconstructed[word_start_idx]["char_y_center"]
             word_length = len(word)
-            assigned_line = chars_list_reconstructed[word_start_idx]["assigned_line"]
+            assigned_line = int(chars_list_reconstructed[word_start_idx]["assigned_line"])
             word_dict = dict(
                 word_number=len(words_list),
                 word=word,
@@ -473,6 +478,7 @@ def asc_lines_to_trials_by_trail_id(
     paragraph_trials_only=True,
     filename: str = "",
     close_gap_between_words=True,
+    close_gap_between_lines=True,
     ias_files=[],
     start_trial_at_keyword="START",
     end_trial_at_keyword="END",
@@ -884,21 +890,189 @@ def asc_lines_to_trials_by_trail_id(
             words_list = words_list_from_func
 
             if close_gap_between_words:  # TODO this may need to change the "in_word" col for the chars_df
-                for widx in range(1, len(words_list)):
-                    if words_list[widx]["assigned_line"] == words_list[widx - 1]["assigned_line"]:
-                        word_sep_half_width = (words_list[widx]["word_xmin"] - words_list[widx - 1]["word_xmax"]) / 2
-                        words_list[widx - 1]["word_xmax"] = words_list[widx - 1]["word_xmax"] + word_sep_half_width
-                        words_list[widx]["word_xmin"] = words_list[widx]["word_xmin"] - word_sep_half_width
+                words_list = close_gaps_in_words_list(words_list)
             else:
                 chars_df = pd.DataFrame(chars_list_reconstructed)
                 chars_df.loc[
                     chars_df["char"] == " ", ["in_word", "in_word_number", "num_letters_from_start_of_word"]
                 ] = pd.NA
                 chars_list_reconstructed = chars_df.to_dict("records")
+            if close_gap_between_lines:
+                chars_list_reconstructed = close_gaps_between_lines(chars_list_reconstructed,prefix='char')
+                words_list = close_gaps_between_lines(words_list,prefix='word')
             trials_dict[trial_idx]["words_list"] = words_list
             trials_dict[trial_idx]["chars_list"] = chars_list_reconstructed
     return trials_dict
 
+def close_gaps_between_lines(data, prefix):
+    """
+    Adjusts word_ymin and word_ymax for lines in a list of dictionaries based on average y-centers.
+
+    Args:
+        data: A list of dictionaries, where each dictionary must have
+            'assigned_line', 'word_ymin', and 'word_ymax' keys.
+
+    Returns:
+        A new list of dictionaries with adjusted 'word_ymin' and 'word_ymax' values.
+        Returns an empty list if the input is empty.
+        Returns the original list if there's only one unique line number.
+    """
+    if not data:
+        return []
+
+    # --- Step 1: Calculate ycenter and group by assigned_line ---
+    line_centers = collections.defaultdict(list)
+    # Keep track of original min/max for single line case plotting
+    original_coords = collections.defaultdict(
+        lambda: {f"{prefix}_ymin": float("inf"), f"{prefix}_ymax": float("-inf")}
+    )
+
+    for item in data:
+        if f"{prefix}_ymin" in item and f"{prefix}_ymax" in item:
+            ycenter = (item[f"{prefix}_ymin"] + item[f"{prefix}_ymax"]) / 2
+            line_num = item["assigned_line"]
+            line_centers[line_num].append(ycenter)
+            # Track overall min/max for original data per line
+            original_coords[line_num][f"{prefix}_ymin"] = min(
+                original_coords[line_num][f"{prefix}_ymin"], item[f"{prefix}_ymin"]
+            )
+            original_coords[line_num][f"{prefix}_ymax"] = max(
+                original_coords[line_num][f"{prefix}_ymax"], item[f"{prefix}_ymax"]
+            )
+
+    # --- Step 2: Calculate average ycenter for each assigned_line ---
+    avg_centers = {}
+    for line_num, centers in line_centers.items():
+        if centers:  # Avoid division by zero if a assigned_line had no valid entries
+            avg_centers[line_num] = statistics.mean(centers)
+
+    # Handle case with 0 or 1 unique line numbers - no adjustments needed/possible
+    if len(avg_centers) <= 1:
+        print(
+            "Only one unique line number found or no valid lines. No adjustments made."
+        )
+        # Return a deep copy to avoid modifying the original list if needed,
+        # or just return the original list. Let's return a copy for safety.
+        return data
+
+    # --- Step 3: Sort line numbers based on average ycenter ---
+    # Creates a list of tuples: (assigned_line, avg_ycenter) sorted by avg_ycenter
+    sorted_lines = sorted(avg_centers.items(), key=lambda item: item[1])
+    # Extract sorted line numbers and their average centers
+    sorted_line_nums = [item[0] for item in sorted_lines]
+    sorted_avg_centers = [item[1] for item in sorted_lines]
+
+    # --- Step 4: Calculate boundaries ---
+    num_lines = len(sorted_avg_centers)
+    boundaries = {}  # Store boundaries between line i and line i+1
+
+    # Calculate boundaries between adjacent lines
+    for i in range(num_lines - 1):
+        midpoint = (sorted_avg_centers[i] + sorted_avg_centers[i + 1]) / 2
+        boundaries[i] = midpoint
+
+    # --- Step 5: Determine new word_ymin and word_ymax for each assigned_line ---
+    new_coords = {}  # Stores {assigned_line: {'word_ymin': new_ymin, 'word_ymax': new_ymax}}
+
+    # Handle the first line
+    first_line_num = sorted_line_nums[0]
+    # Estimate boundary before the first line by extrapolating
+    # Use max(0, ...) to prevent negative word_ymin if lines are very close to 0
+    # Ensure extrapolation doesn't create negative boundary if first line is near 0
+    extrapolated_start_boundary = max(
+        0, sorted_avg_centers[0] - (sorted_avg_centers[1] - sorted_avg_centers[0]) / 2
+    )
+    # The new word_ymin should start 1 pixel *after* the rounded boundary
+    # The boundary itself is the dividing line.
+    new_ymin_first = round(extrapolated_start_boundary) + 1
+    new_ymax_first = round(boundaries[0])
+    # Ensure word_ymin is not greater than word_ymax, adjust if necessary
+    if new_ymin_first > new_ymax_first:
+        print(
+            f"Warning: Calculated word_ymin ({new_ymin_first}) > word_ymax ({new_ymax_first}) for first line ({first_line_num}). Adjusting word_ymin."
+        )
+        new_ymin_first = new_ymax_first  # Set word_ymin = word_ymax, resulting in a height of 0
+    new_coords[first_line_num] = {f"{prefix}_ymin": new_ymin_first, f"{prefix}_ymax": new_ymax_first}
+
+    # Handle intermediate lines
+    for i in range(1, num_lines - 1):
+        line_num = sorted_line_nums[i]
+        # word_ymin starts 1 pixel after the previous boundary
+        new_ymin = round(boundaries[i - 1]) + 1
+        # word_ymax is at the current boundary
+        new_ymax = round(boundaries[i])
+        # Ensure word_ymin is not greater than word_ymax
+        if new_ymin > new_ymax:
+            print(
+                f"Warning: Calculated word_ymin ({new_ymin}) > word_ymax ({new_ymax}) for intermediate line ({line_num}). Adjusting word_ymin."
+            )
+            new_ymin = new_ymax  # Adjust word_ymin to be equal to word_ymax
+        new_coords[line_num] = {f"{prefix}_ymin": new_ymin, f"{prefix}_ymax": new_ymax}
+
+    # Handle the last line
+    last_line_num = sorted_line_nums[-1]
+    # Estimate boundary after the last line by extrapolating
+    extrapolated_end_boundary = (
+        sorted_avg_centers[-1] + (sorted_avg_centers[-1] - sorted_avg_centers[-2]) / 2
+    )
+    # word_ymin starts 1 pixel after the previous boundary
+    new_ymin_last = round(boundaries[num_lines - 2]) + 1
+    # word_ymax is at the extrapolated end boundary
+    new_ymax_last = round(extrapolated_end_boundary)
+    # Ensure word_ymin is not greater than word_ymax
+    if new_ymin_last > new_ymax_last:
+        print(
+            f"Warning: Calculated word_ymin ({new_ymin_last}) > word_ymax ({new_ymax_last}) for last line ({last_line_num}). Adjusting word_ymax."
+        )
+        new_ymax_last = new_ymin_last  # Adjust word_ymax to be equal to word_ymin
+    new_coords[last_line_num] = {f"{prefix}_ymin": new_ymin_last, f"{prefix}_ymax": new_ymax_last}
+
+    # --- Step 6: Update the original data structure ---
+    # Create a new list to store results, preserving other keys
+    adjusted_data = []
+    for item in data:
+        new_item = (
+            item.copy()
+        )  # Create a copy to avoid modifying original dicts directly if they are reused
+        line_num = new_item.get("assigned_line")
+        if line_num in new_coords:
+            new_item[f"{prefix}_ymin"] = new_coords[line_num][f"{prefix}_ymin"]
+            new_item[f"{prefix}_ymax"] = new_coords[line_num][f"{prefix}_ymax"]
+        adjusted_data.append(new_item)
+
+    return adjusted_data
+
+def close_gaps_in_words_list(words_list:List[Dict]):
+    """
+    Adjusts the positions of words in a list to close gaps between consecutive words
+    that belong to the same assigned line. The function modifies the input list in place.
+
+    Args:
+        words_list (list of dict): A list of dictionaries where each dictionary represents
+            a word with the following keys:
+            - "assigned_line" (int): The line number to which the word is assigned.
+            - "word_xmin" (float): The minimum x-coordinate of the word's bounding box.
+            - "word_xmax" (float): The maximum x-coordinate of the word's bounding box.
+
+    Behavior:
+        - For each pair of consecutive words in the list that belong to the same line
+          (i.e., have the same "assigned_line"), the function calculates the gap between
+          their bounding boxes.
+        - The gap is split equally between the two words, and their "word_xmin" and
+          "word_xmax" values are adjusted accordingly to close the gap.
+
+    Note:
+        - The input list is modified in place, and no value is returned.
+        - It is assumed that the input list is sorted by "assigned_line" and the x-coordinates
+          of the words.
+
+    """
+    for widx in range(1, len(words_list)):
+        if words_list[widx]["assigned_line"] == words_list[widx - 1]["assigned_line"]:
+            word_sep_half_width = (words_list[widx]["word_xmin"] - words_list[widx - 1]["word_xmax"]) / 2
+            words_list[widx - 1]["word_xmax"] = words_list[widx - 1]["word_xmax"] + word_sep_half_width
+            words_list[widx]["word_xmin"] = words_list[widx]["word_xmin"] - word_sep_half_width
+    return words_list
 
 def get_lines_from_file(uploaded_file, asc_encoding="ISO-8859-15"):
     if isinstance(uploaded_file, str) or isinstance(uploaded_file, pl.Path):
@@ -915,6 +1089,7 @@ def file_to_trials_and_lines(
     uploaded_file,
     asc_encoding: str = "ISO-8859-15",
     close_gap_between_words=True,
+    close_gap_between_lines=True,
     paragraph_trials_only=True,
     uploaded_ias_files=[],
     trial_start_keyword="START",
@@ -926,6 +1101,7 @@ def file_to_trials_and_lines(
         paragraph_trials_only,
         uploaded_file,
         close_gap_between_words=close_gap_between_words,
+        close_gap_between_lines=close_gap_between_lines,
         ias_files=uploaded_ias_files,
         start_trial_at_keyword=trial_start_keyword,
         end_trial_at_keyword=end_trial_at_keyword,
@@ -1007,7 +1183,7 @@ def plotly_plot_with_image(
 
     if lines_in_plot == "Both":
         uncorrected_plot_mode = "markers+lines+text"
-        corrected_plot_mode = "markers+lines+text"
+        corrected_plot_mode = "markers+text"
 
     fig = go.Figure()
     fig.add_trace(