Preparing Excel file and addressing image data

User asked for an Excel file to be created from a photo. Following the instructions, I need to start by preparing the file creation immediately. Once that's done, I can work on reading the image content—perhaps with OCR as a last resort—though my vision can process it directly too, if possible.

Extracting data from the image

I can see the image in the prompt and it seems to be a table with columns like "Longitude," "S.SRC," "SOG/kn," "COG/°T," "HDG/°T," and "CORR/°T." The longitudes listed include values like 45.381W and 43.750W, though some digits are cropped. I'll need to capture all visible rows to recreate the table accurately.

Deciding how to read the image data accurately

I’m thinking I should open the image using Python, and maybe crop or enlarge it for clarity. Using OCR could help with accuracy, but it’s resource-heavy, and I think I could manually read the image data by zooming in before resorting to such tools. Let’s explore this approach!

Preparing route info and table extraction

OCR might not be the best option here, plus I may not have the necessary library installed. Instead, I can manually read the image and create the Excel table, including both the main table and the "Route Info" panel. I'll add a separate section for key-value pairs from the panel and the overlay status. Let's check the image closely first!

Opening image and preparing extraction

I’ll open the image using Python, potentially zooming or cropping it to better view and extract the necessary data. I can use the container tool to view the image in the output, which will assist in analyzing the details further. Let’s start with the required artifact preparation before proceeding.

from PIL import Image, ImageEnhance img_path="/mnt/data/IMG_20260303_200800.jpg" img=Image.open(img_path) img.size

Cropping and inspecting image

I’ll start by cropping around the table to make it easier to read. Afterward, I can enlarge the cropped area and use OCR to extract the text. Since the user can't see the Python tool outputs, I’ll save the crop and use the container tool to display it for visual confirmation and analysis.

from PIL import Image img=Image.open("/mnt/data/IMG_20260303_200800.jpg")

crop main table area roughly

crop=img.crop((0,250,3200,2150)) # x0,y0,x1,y1 crop_path="/mnt/data/crop_table.png" crop.save(crop_path) crop.size

Fixing crop to capture full longitude

It looks like some longitude values are cut off, like "33.141W," which actually appears as "3.141W" due to cropping. I need to adjust the crop so that I can include the full longitude values. I'll recrop more to the left to capture these missing details, keeping in mind the window border.

Verifying cropped leftmost digits

It seems that the leftmost digits of the longitude values might be missing due to cropping. Starting at x0=0 likely cut off part of the image. To be sure, I should check the original image to see if there's more data on the left. I'll open the full image and verify.### Confirming missing digits in leftmost column

It looks like the "Longitude" header is cut off, and some digits might be missing from the left side of the table. However, I can only transcribe what's visible in the photo. For rows where digits are missing, I'll record them as shown, like "3.141W." I'll zoom in on the left to check.

crop leftmost column for better view

left_crop=img.crop((0,250,750,2150)) left_path="/mnt/data/crop_left.png" left_crop.save(left_path)

Verifying visible longitude data

After cropping, I can now clearly see the leftmost longitude values. They include "45.381W," "43.750W," and others. Some rows have a partially cut first digit, like "37.427W" or "29.741W." The last row shows "...99W," possibly "0.999W." I’ll crop further to confirm the bottom rows.

bottom_crop=img.crop((0,1600,3200,2252)) bottom_path="/mnt/data/crop_bottom.png" bottom_crop.save(bottom_path) bottom_crop.size

Checking bottom rows for full longitude

The bottom crop starts around the "13.827W" row and shows various rows of data. The last row, showing "...99W," seems cut off, potentially displaying "0.999W." I can't see the full longitude because of the crop. I’ll crop the bottom left further to confirm the complete longitude.

left_bottom=img.crop((0,1500,800,2252)) lb_path="/mnt/data/crop_left_bottom.png" left_bottom.save(lb_path)

Analyzing column headers and values

In the crop, longitudes range from 15.403W to 0.999W. The headers show "S.SRC" as "FILT" and values for SOG (13.8, 14.0), COG (324.6), HDG (323.4), and CORR/°T (mostly N/A). There's a blank value in the CORR/°T column for the first row.

Checking for "N/A" and empty cells

There seems to be some uncertainty about the first row's far-right column — possibly blank due to an offset or window border. Under the CORR/°T column, I see "N/A" starting from the second row. I’ll zoom in on the top-right to verify this more clearly.

right_top=img.crop((2600,250,4000,1100)) rt_path="/mnt/data/crop_right_top.png" right_top.save(rt_path)

Transcribing rows and trying OCR

I see that the CORR/°T column is filled with "N/A" for all rows—no blanks. Now, I need to extract SOG, COG, and HDG values. I could manually transcribe each row, but to avoid errors, I might try OCR using Python and pytesseract. Let me first check if pytesseract is installed.

import pytesseract, sys, numpy as np, pandas as pd, re, math, os, textwrap

Testing OCR with pytesseract

It looks like pytesseract was imported successfully, so it's likely installed. However, it might require the tesseract binary, which may or may not be set up. I'll test the OCR on a small crop with a few rows that contain numbers to check if it's working as expected.

from PIL import ImageOps, ImageEnhance sample=img.crop((600,300,3200,900)) # includes SOG etc

preprocess: grayscale, increase contrast, resize

g=ImageOps.grayscale(sample) g=ImageEnhance.Contrast(g).enhance(2.5) g=g.resize((g.size[0]*2,g.size[1]*2)) tmp="/mnt/data/ocr_sample.png" g.save(tmp) print(g.size)

Running OCR on preprocessed image

The preprocessed image looks good, so now I'll run pytesseract on this sample to check how well it performs with the data. This will help me determine if it's capturing the text correctly from the image.

import pytesseract, pandas as pd, re text = pytesseract.image_to_string(g, config="--psm 6") print(text[:1000])

Refining OCR for accuracy

The OCR quality isn’t great, possibly due to gridlines or formatting issues. I could try refining it by removing lines or whitelisting specific characters, but manually transcribing seems easier since it's just 20 rows. I'll crop the image to focus on the necessary columns and attempt OCR on each one separately. First, I'll start with the SOG/kn column.

import numpy as np from PIL import ImageFilter

define crop regions relative to full image for each column

We'll locate approximate x positions by observation.

Let's test SOG column: around x 900-1250 (in full image)

sog_crop = img.crop((880, 270, 1280, 2150)) g = ImageOps.grayscale(sog_crop) g = g.resize((g.size[0]*3, g.size[1]*3)) g = ImageEnhance.Contrast(g).enhance(3)

binarize

arr = np.array(g) thr = 170 bin_img = Image.fromarray((arr>thr).astype(np.uint8)*255) bin_img = bin_img.filter(ImageFilter.MedianFilter(size=3)) sog_path="/mnt/data/sog_bin.png" bin_img.save(sog_path)

Running OCR on thresholded image

The thresholded image for the SOG looks good, although it also includes some parts of the COG on the right. That should be fine for now. I’ll proceed with running OCR on this cropped image and apply a whitelist for digits and dots to improve the accuracy of the results.

text = pytesseract.image_to_string(bin_img, config="--psm 6 -c tessedit_char_whitelist=0123456789.") print(text[:500])

Adjusting crop for SOG column

OCR results are still messy due to extra digits from the right side. To fix this, I need to crop the image more precisely, focusing on the SOG column and excluding the boundary lines. I'll adjust the x-range, narrowing it to 880-1110. Hopefully, this will isolate just the SOG data.

sog_only=img.crop((840, 300, 1100, 2150)) g=ImageOps.grayscale(sog_only).resize((sog_only.size[0]*4, sog_only.size[1]*4)) g=ImageEnhance.Contrast(g).enhance(3) arr=np.array(g) thr=170 bin_img=Image.fromarray((arr>thr).astype(np.uint8)*255) bin_img=bin_img.filter(ImageFilter.MedianFilter(size=3)) sog_only_path="/mnt/data/sog_only.png" bin_img.save(sog_only_path)

Running OCR after crop adjustment

Now that I've adjusted the crop to focus on the SOG column, OCR should be easier and more accurate. Time to run the process and see if the changes help eliminate any unwanted data from the right side of the image. Let’s proceed!

text = pytesseract.image_to_string(bin_img, config="--psm 6 -c tessedit_char_whitelist=0123456789.") print(text)

Adjusting crop to fix missing digits

It looks like OCR is interpreting some values incorrectly, like reading 3.6 instead of 13.6, probably because I cropped too narrowly on the left side. The leading "1" appears to be cut off. I'll extend the crop slightly to the left to capture those missing digits. Let’s fix that!

sog_only=img.crop((780, 300, 1100, 2150)) # include more left g=ImageOps.grayscale(sog_only).resize((sog_only.size[0]*4, sog_only.size[1]*4)) g=ImageEnhance.Contrast(g).enhance(3) arr=np.array(g) thr=170 bin_img2=Image.fromarray((arr>thr).astype(np.uint8)*255).filter(ImageFilter.MedianFilter(size=3)) path="/mnt/data/sog_only2.png" bin_img2.save(path)

OCR attempt with all digits visible

Great, now that all the numbers are showing correctly with the leading "1," I’ll go ahead and run the OCR. This should help avoid any errors with missing digits. Let's see if it picks up everything accurately now. Fingers crossed!

text = pytesseract.image_to_string(bin_img2, config="--psm 6 -c tessedit_char_whitelist=0123456789.") print(text)

Manual transcription over OCR for accuracy

There are still small errors, like 13.87 showing as 13.8, and one missing row, but this can be adjusted through rounding or a manual check. OCR also missed the last row, possibly due to the crop. Instead of relying on OCR, it might be easier to manually transcribe the SOG, COG, and HDG values from the image, using zoomed segments for accuracy.

Using OCR with manual corrections for accuracy

I'll use OCR to extract each column separately, ensuring we capture all lines. We'll cross-check the results against the existing list of longitudes. While we could try computer vision for row detection, manual correction might be more reliable due to the small data set. With an improved OCR configuration, we can refine the results as needed.

Transcribing rows manually from enlarged crop table

Instead of using Tesseract to detect row separation through bounding boxes, I'll manually transcribe the rows by reading directly from an enlarged crop of the full table. I'll increase the contrast and resolution, enlarge it by 2x for better readability, and go through each row sequentially to verify the numbers.

from PIL import ImageOps, ImageEnhance table=img.crop((0,250,3100,2200)) g=ImageEnhance.Contrast(ImageOps.grayscale(table)).enhance(2) g=g.resize((g.size[0]*2, g.size[1]*2)) path="/mnt/data/table_zoom.png" g.save(path) g.size

Adjusting crop to capture bottom row

The zoomed image is clear enough for manual transcription, except the bottom row is partially cut. I’ll create another crop to include the last row, including the 0.999W value. The previous crop didn’t include the bottom rows, so I’ll increase the crop’s y-coordinate to capture everything correctly.

table2=img.crop((0,250,3100,2252)) g=ImageEnhance.Contrast(ImageOps.grayscale(table2)).enhance(2) g=g.resize((g.size[0]*2, g.size[1]*2)) path="/mnt/data/table_zoom2.png" g.save(path)

Confirming bottom row details with new crop

I’ve now included the last row, but the longitude is cropped to “999W” instead of showing “0.999W”. From the left crop, we know it’s “0.999W.” The bottom row shows “COG 325.1” and possibly “HDG 323.0.” I need to confirm these details with a separate crop that includes the bottom row across all columns.

last_rows=img.crop((0,1850,3100,2252)) g=ImageEnhance.Contrast(ImageOps.grayscale(last_rows)).enhance(2) g=g.resize((g.size[0]*3, g.size[1]*3)) path="/mnt/data/last_rows_zoom.png" g.save(path)

Transcribing and confirming 20 rows

The last 5 rows are clear with values like “longitude 0.999W, SOG 13.6, COG 325.1, HDG 323.0.” Now focusing on the first row: I see that the CORR column is blank at the top but actually has "N/A" starting from row 1. It looks like "N/A" applies to all 20 rows.

Transcribing remaining rows

I’ve now transcribed rows 2 through 19, with entries like:

• Row2: 43.750W, SOG 14.0, COG 325.7, HDG 324.0, CORR N/A
• Row3: 41.004W, SOG 14.0, COG 325.2, HDG 324.3, CORR N/A ... and so on.

All entries seem to follow the same format, with the CORR value consistently showing "N/A." Need to finish row 19 completely.

Verifying rows 12-15

I need to validate the data for rows 12 through 15, including checking the COG and HDG values. Specifically, the 18.865W row shows a COG of 326.7, and the 15.403W row shows SOG 13.6 and COG 326.7. I’ll create a crop around rows 12-15 to double-check these.

mid=img.crop((0,1150,3100,1700)) g=ImageEnhance.Contrast(ImageOps.grayscale(mid)).enhance(2) g=g.resize((g.size[0]*3, g.size[1]*3)) path="/mnt/data/mid_zoom.png" g.save(path)

Verifying mid crop data consistency

I’m checking the mid crop for consistency. Row data for longitudes like 21.998W, 20.477W, 18.865W, and 15.403W seems correct. For example, the 21.998W row shows SOG 13.7, COG 327.2, and HDG 325.6, and the 15.403W row shows SOG 13.6, COG 326.7. Some rows seem misaligned, so I’ll check again.

Sorting out HDG values and row alignment

I'm checking the HDG values. Row 5 for 13.827W has HDG 323.5, not 323.8, and row 6 for 11.930W has HDG 323.8. This means I possibly reversed the HDG for 13.827W and 11.930W earlier. I'll create a crop around these rows to verify HDG digits and adjust.

sub=img.crop((1500,1350,2400,1750)) # around HDG numbers g=ImageEnhance.Contrast(ImageOps.grayscale(sub)).enhance(2.5) g=g.resize((g.size[0]*4, g.size[1]*4)) path="/mnt/data/hdg_13827_11930.png" g.save(path)

Clarifying HDG sequence and rows

The HDG values align with specific longitudes. For example, 20.477W has HDG 325.8, 18.865W has HDG 325.1, and 15.403W also has HDG 325.1. It seems the crop is missing the 15.403W row, but I've clarified the sequence. The missing HDG value matches mid_zoom for 15.403W.

Investigating the crop range and missing row

It seems that the crop might have excluded the 18.865W row, which could explain the missing HDG 325.1. The current range includes four rows: 20.477W, 15.403W, 13.827W, and 11.930W. I'll test by cropping around y 1250-1500 to confirm whether 18.865W is missing.

sub=img.crop((1200,1180,2400,1500)) # includes COG/HDG rows 18.865,15.403 g=ImageEnhance.Contrast(ImageOps.grayscale(sub)).enhance(2.5) g=g.resize((g.size[0]*4, g.size[1]*4)) path="/mnt/data/cog_hdg_18865_15403.png" g.save(path)

Focusing on 18.865W row for clarity

The crop seems to show COG 326.7 and HDG 325.1 for rows 25.442W, 21.998W, and 20.477W, but the HDG for the 18.865W row might not be fully visible due to cropping. I'll crop specifically around y 1300-1380 to focus on the 18.865W row and recheck the data.

determine y positions for 18.865 row: around 1300? We'll brute by cropping region.

row_18865 = img.crop((1100,1285,2400,1395)) g=ImageEnhance.Contrast(ImageOps.grayscale(row_18865)).enhance(2.5).resize((13003,1103)) path="/mnt/data/row_18865.png" g.save(path)

Confirming HDG and COG for rows

The crop was misaligned, but mid_zoom image clearly shows row 18.865W with HDG 325.8 and COG 326.7. So 18.865W has HDG 325.8, not 325.1. For rows 15.403W, 13.827W, and 11.930W, the HDG values seem to be 325.1, 323.5, and 323.8, respectively. The 930W row at the bottom likely also has HDG 323.8.

Verifying HDG and COG for rows

I’m confirming HDG and COG data for several rows now, starting with 45.381W through 29.741W. The values for these rows match up with the full table I referenced earlier. For row 29.741W, I’ve confirmed that it has HDG 324.8, following the previous row (33.141W) with HDG 325.2.

Verifying HDG for rows 18.865W and 20.477W

I’m checking the HDG values again for rows 20.477W and 18.865W. The mid-zoom image shows that the 20.477W row does indeed have HDG 325.8, while the 18.865W row likely has HDG 325.1. It’s a bit tricky, but it seems that these HDG values line up as expected.

Verifying HDG and COG values in mid_zoom

It looks like the HDG value that we are discussing changes across rows. The mid_zoom image shows that row 0.477W has a value of HDG 325.6. The subsequent rows show HDG 325.8, 325.1, and 323.5. Additionally, the row labeled 15.403 corresponds to COG 326.7. This confirms the correct HDG and COG values for these rows.

Confirming COG and HDG values across rows

The row sequence for COG starts with 326.2 and ends with 324.7 from top to bottom: 326.2, 327.2, 326.7, 326.7, 325.3, 324.7, and 324.7. For HDG, I can map 325.1 through 323.8 from top to bottom as well. Meanwhile, row 15.403 should have HDG 325.1, not 323.5.

Verifying HDG for row 18.865 and cropping region

In mid_zoom, row 18.865 likely corresponds to HDG 325.8, but there’s some ambiguity. Row 15.403 is already confirmed as 325.1. Since the HDG for 18.865 isn't in the earlier crop, I’m going to crop around it at y positions between 1320-1450 to capture the correct data.

crop around estimated y for 18.865 row

region=img.crop((1400,1270,2200,1470)) # includes HDG column and maybe S.SRC g=ImageEnhance.Contrast(ImageOps.grayscale(region)).enhance(2.5) g=g.resize((g.size[0]*5, g.size[1]*5)) path="/mnt/data/hdg_row18865_region.png" g.save(path)

Adjusting crop to include 18.865 row HDG

The current region shows HDG 325.6 and 325.8, matching rows 21.998 (HDG 325.6) and 20.477 (HDG 325.8). However, it doesn’t include row 18.865. I’ll shift the crop down slightly to make sure that row is captured correctly.

region=img.crop((1400,1390,2200,1590)) g=ImageEnhance.Contrast(ImageOps.grayscale(region)).enhance(2.5) g=g.resize((g.size[0]*5, g.size[1]*5)) path="/mnt/data/hdg_row18865_region2.png" g.save(path)

Confirming HDG values for 18.865 and 15.403 rows

The values are looking good with HDG 325.8 for 20.477W and HDG 325.1 for 18.865W, which aligns perfectly with the previous assumption. Now, since 18.865W already has HDG 325.1, I’m considering whether the 15.403W row could also have HDG 325.1. Hmm, let's check further.

region=img.crop((1400,1480,2200,1680)) g=ImageEnhance.Contrast(ImageOps.grayscale(region)).enhance(2.5) g=g.resize((g.size[0]*5, g.size[1]*5)) path="/mnt/data/hdg_row15403_region.png" g.save(path)

Reevaluating HDG assignment for 15.403W and 13.827W

The HDG 325.1 for 18.865W fits, but then there's the inconsistency with HDG 323.5 being right below. The confusion comes from possibly mis-assigned longitudes for rows. I originally thought the 15.403W row had HDG 325.1, but now it seems it might be 323.5. I'll check again closely in zoom2.

region=img.crop((0,1380,3100,1560)) # include longitude and HDG for 18.865 and 15.403 g=ImageEnhance.Contrast(ImageOps.grayscale(region)).enhance(2.2) g=g.resize((g.size[0]*4, g.size[1]*4)) path="/mnt/data/rows_18865_15403_full.png" g.save(path)

Refining crop for better clarity

The current crop is messy, possibly due to tilt or contrast issues causing aliasing. The HDG is unclear, with partial cropping making it tricky to read. I think the best approach now is to return to the clearer mid_zoom crop, focusing on row .403W for more accurate details. I'll crop around it between y 1425 and 1505 for better visibility.

row_15403 = img.crop((0,1415,3100,1515)) g=ImageEnhance.Contrast(ImageOps.grayscale(row_15403)).enhance(2.3) g=g.resize((g.size[0]*4, g.size[1]*4)) path="/mnt/data/row_15403_full.png" g.save(path)

Adjusting crop for clearer row boundary

The crop didn’t work as planned, the height was too small and led to overlapping lines. I need to adjust the y-range. Given that each row height is approximately 95, I'll try cropping between y 1460-1540. I'll narrow it further, focusing on HDG with a refined range of 1480-1560.

row = img.crop((1200,1460,2400,1560)) g=ImageEnhance.Contrast(ImageOps.grayscale(row)).enhance(2.4) g=g.resize((g.size[0]*6, g.size[1]*6)) path="/mnt/data/row_test.png" g.save(path)

Re-evaluating row assignments for HDG values

The crop seems to include row 20.477, showing HDG 325.1 and another value—possibly 325.x. Given the complexity, I'll focus on the clearer data from the earlier mid_zoom crop. It suggests that row 15.403 aligns with HDG 325.1, but this conflicts with the expected value for row 13.827. The crop issue could be missing certain rows.

Confirming HDG for 15.403 using OCR

To confirm the HDG for 15.403, I'll refer to table_zoom2 where the row visible as .403W shows HDG 325.1. Another idea is to use OCR on the HDG column and map values to longitudes. I’ll crop the relevant part around x 2000-2400, preprocess it, and use OCR to extract the values.

from PIL import ImageFilter, ImageOps import numpy as np, re hdg_crop = img.crop((2020, 300, 2520, 2150)) # approximate g=ImageOps.grayscale(hdg_crop).resize((hdg_crop.size[0]*4, hdg_crop.size[1]*4)) g=ImageEnhance.Contrast(g).enhance(3) arr=np.array(g)

adaptive threshold maybe: use simple threshold

thr=170 bin_img = Image.fromarray((arr>thr).astype(np.uint8)*255) bin_img=bin_img.filter(ImageFilter.MedianFilter(size=3)) path="/mnt/data/hdg_col.png" bin_img.save(path)

Listing HDG values and adjusting crop

The image clearly shows the HDG values in order, listed as: 323.4, 324.0, 324.3, 325.3, 324.7, 325.2, 324.8, 325.1, 325.1, 325.6, 325.8, 325.1, 323.5, 323.8, 323.5, 325.2, 324.9, 324.0.

It seems the last row (323.0) might be missing, likely due to the crop ending at y 2150. I’ll adjust the crop to y 2252 to include this missing row.

hdg_crop = img.crop((2020, 300, 2520, 2252)) g=ImageOps.grayscale(hdg_crop).resize((hdg_crop.size[0]*4, hdg_crop.size[1]*4)) g=ImageEnhance.Contrast(g).enhance(3) arr=np.array(g) thr=170 bin_img = Image.fromarray((arr>thr).astype(np.uint8)*255).filter(ImageFilter.MedianFilter(size=3)) path="/mnt/data/hdg_col2.png" bin_img.save(path)

Confirming row mapping for HDG values

Now that I’ve included the last row (323.0), the HDG list in order is:

1. 323.4, 2. 324.0, 3. 324.3, ..., 20. 323.0

With this, I can map the HDG values to the corresponding rows and longitudes in order, which helps simplify the data. We can use this mapping for further steps, like extracting COG values from the COG column.

cog_crop = img.crop((1250, 300, 1750, 2252)) # includes COG/°T values; might include S.SRC g=ImageOps.grayscale(cog_crop).resize((cog_crop.size[0]*4, cog_crop.size[1]*4)) g=ImageEnhance.Contrast(g).enhance(3) arr=np.array(g) thr=170 bin_img = Image.fromarray((arr>thr).astype(np.uint8)*255).filter(ImageFilter.MedianFilter(size=3)) path="/mnt/data/cog_col.png" bin_img.save(path)

Adjusting crop to include full COG values

The current crop truncates leading digits for many COG values, like 26.4 should be 326.4. To fix this, I need to adjust the crop to include more space on the left, showing the full three digits. I'll increase the x0 value to 1120 for a better crop.

cog_crop = img.crop((1050, 300, 1700, 2252)) g=ImageOps.grayscale(cog_crop).resize((cog_crop.size[0]*4, cog_crop.size[1]*4)) g=ImageEnhance.Contrast(g).enhance(3) arr=np.array(g) thr=170 bin_img = Image.fromarray((arr>thr).astype(np.uint8)*255).filter(ImageFilter.MedianFilter(size=3)) path="/mnt/data/cog_col2.png" bin_img.save(path)

Handling the tool time limit and user's file request

It looks like the tool time limit was reached, which means I can't call any more tools right now. The user asked for an Excel file and a download link, but since I can't generate it due to the limit, I'll need to be honest. I can explain the situation, but I can’t promise a file later. Maybe I could offer partial CSV content as a workaround.

Finding an alternative solution for file delivery

Since I can't create a file now, I could offer CSV data as text instead. I’ll compile the table values into CSV format with headers for the user to copy and save as a file. I can’t provide a full Excel file or a link, but this should help, and I'll be transparent.

Compiling data for CSV

I have all the necessary values: HDG, COG, and SOG. I can now create the CSV with the following columns: Longitude, S.SRC_1, SOG_kn, COG_degT, S.SRC_2, HDG_degT, S.SRC_3, and CORR_degT. The data for S.SRC_1 and S.SRC_2 will come from FILT, while S.SRC_3 will be from GYRO1. There are 20 rows.

Summarizing route info panel contents

The "Route Info" panel shows partial details: "Route: BO" (maybe "B0"?), "Plan Speed," "Plan Course," "Course to St" (likely "Course to Steer"), and "XTD LIM: 370." We can only list visible labels for now: "Overlay / NA," "TT/AIS," and the associated buttons like "TT" and "OFF."

Creating CSV with route info

I’ll clarify that I can't generate an Excel file, but I can provide the user with two CSVs. One for the "LOG" with 20 rows, in markdown table and CSV formats, and another holding the "Route Info" fields, leaving blank values where necessary. I'll include the route info as key-value pairs like "Route; BO," "XTD LIM; 370," and "Overlay; NA."

Thought for 27m 19s