Timeseries CSV Parsing Unity

2025-04-02 11:07 UTC o3-mini-high Open in ChatGPT ↗

You

I want to parse a timeseries csv in C# Unity. I want to be able to select a specific column, get a list of the dates and find min-max date and min-max value of the column i select. it must run interactively in runtime (load data once, select column in realtime)

ChatGPT

Below is an example of how you might approach this in Unity using C#. In this example, you:

• Load your CSV data once at runtime (via a TextAsset)
• Parse the header row and data rows
• Provide a method (that you can hook up to a UI dropdown) to select a column by index
• Extract the date values (assuming the date is in the first column) and numeric values from your chosen column
• Compute and log the minimum and maximum dates as well as the minimum and maximum numeric values

You can attach this script to a GameObject in your scene and assign your CSV file (as a TextAsset) via the Inspector.

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI; // Only needed if you plan to use UI elements like Dropdown

public class TimeseriesCSVParser : MonoBehaviour
{
    // Assign your CSV file (as a TextAsset) in the inspector.
    public TextAsset csvFile;

    // If using a UI dropdown for column selection, assign it in the Inspector.
    public Dropdown columnDropdown;

    // Store headers and data rows.
    private string[] headers;
    private List<string[]> dataRows = new List<string[]>();

    void Start()
    {
        if (csvFile != null)
        {
            ParseCSV();
            SetupDropdown();
        }
        else
        {
            Debug.LogError("CSV file not assigned!");
        }
    }

    // Parse the CSV file into headers and data rows.
    private void ParseCSV()
    {
        // Split by newlines (adjust for your CSV if needed)
        string[] lines = csvFile.text.Split(new[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);

        if (lines.Length > 0)
        {
            // First row as header
            headers = lines[0].Split(',');

            // Load each data row (starting from line 1)
            for (int i = 1; i < lines.Length; i++)
            {
                // Split each row by commas (you might need to adjust if your CSV contains quoted commas)
                string[] row = lines[i].Split(',');
                dataRows.Add(row);
            }
        }
    }

    // Populate a UI Dropdown with the header names (except the date column if you wish).
    private void SetupDropdown()
    {
        if (columnDropdown != null && headers != null)
        {
            // Clear existing options
            columnDropdown.ClearOptions();

            // Create list of options. If the first column is date, you might start at index 1.
            List<string> options = new List<string>();
            for (int i = 1; i < headers.Length; i++)
            {
                options.Add(headers[i]);
            }
            columnDropdown.AddOptions(options);

            // Optionally, add a listener to trigger analysis when selection changes.
            columnDropdown.onValueChanged.AddListener(delegate { AnalyzeSelectedColumn(); });
        }
    }

    // Call this method when you want to analyze the currently selected column.
    public void AnalyzeSelectedColumn()
    {
        // Adjust index: if your first column (index 0) is the date column, add 1.
        int selectedColumn = columnDropdown != null ? columnDropdown.value + 1 : 1;
        AnalyzeColumn(selectedColumn);
    }

    // Analyze the data for the given column index.
    private void AnalyzeColumn(int columnIndex)
    {
        List<DateTime> dates = new List<DateTime>();
        List<float> values = new List<float>();

        // Loop through each data row.
        foreach (var row in dataRows)
        {
            // Ensure the row has enough columns.
            if (row.Length > columnIndex && row.Length > 0)
            {
                // Parse the date from the first column.
                if (DateTime.TryParse(row[0].Trim(), out DateTime date))
                {
                    dates.Add(date);
                }
                else
                {
                    Debug.LogWarning("Unable to parse date: " + row[0]);
                }

                // Parse the numeric value from the selected column.
                if (float.TryParse(row[columnIndex].Trim(), out float value))
                {
                    values.Add(value);
                }
                else
                {
                    Debug.LogWarning("Unable to parse value in column " + headers[columnIndex] + ": " + row[columnIndex]);
                }
            }
        }

        if (dates.Count > 0 && values.Count > 0)
        {
            // Compute min and max dates.
            DateTime minDate = dates[0], maxDate = dates[0];
            foreach (var d in dates)
            {
                if (d < minDate)
                    minDate = d;
                if (d > maxDate)
                    maxDate = d;
            }

            // Compute min and max values.
            float minValue = values[0], maxValue = values[0];
            foreach (var v in values)
            {
                if (v < minValue)
                    minValue = v;
                if (v > maxValue)
                    maxValue = v;
            }

            Debug.Log("Analyzing Column: " + headers[columnIndex]);
            Debug.Log("Min Date: " + minDate.ToString());
            Debug.Log("Max Date: " + maxDate.ToString());
            Debug.Log("Min Value: " + minValue);
            Debug.Log("Max Value: " + maxValue);
        }
        else
        {
            Debug.LogWarning("Insufficient valid data for analysis in the selected column.");
        }
    }
}

How It Works

1. CSV Loading and Parsing:
   The ParseCSV() method splits the CSV file into lines and then splits the header and each data row by commas. This gives you a header array and a list of data rows.

2. Interactive Column Selection:
   If you are using a UI dropdown, the SetupDropdown() method populates the dropdown with column names (skipping the first column if that’s your date column). When the dropdown value changes, it calls AnalyzeSelectedColumn(), which in turn calls AnalyzeColumn() with the appropriate index.

3. Data Analysis:
   The AnalyzeColumn() method loops through all data rows, parsing the date from the first column and the numeric value from the selected column. It then computes and logs the minimum and maximum dates and values.

Customization

• Date Format:
  If your dates are in a specific format, consider using DateTime.ParseExact().

• CSV Format:
  If your CSV might include commas within quoted strings or uses a different delimiter, you may need a more robust CSV parser.

• UI Integration:
  You can further expand the UI integration (for example, showing results in UI text fields instead of the console).

This setup allows you to load your CSV data once at startup and then interactively select which column to analyze at runtime.

You

Editor script that populates an inspector dropdown with the columns

ChatGPT

Below is an example of how you can create a custom editor script that reads the CSV header row and populates an inspector dropdown with the column names. You’ll need two scripts:

1. Runtime Script (TimeseriesCSVParser.cs)
   This script holds your CSV file (a TextAsset) and an integer field for the selected column index. In a real project you might include additional logic (like parsing the CSV at runtime), but for the purpose of populating the dropdown we only need these fields.

using UnityEngine;

public class TimeseriesCSVParser : MonoBehaviour
{
    // Assign your CSV file via the inspector.
    public TextAsset csvFile;

    // This field will be set via the custom inspector.
    public int selectedColumnIndex = 0;

    // You could add your CSV parsing and analysis methods here...
}

2. Custom Editor Script (TimeseriesCSVParserEditor.cs)
   Place this script in a folder named “Editor” within your project. This editor script customizes the inspector to read the CSV header and display it as a dropdown. When the CSV file is assigned and contains a header row, the dropdown will list each column name.

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(TimeseriesCSVParser))]
public class TimeseriesCSVParserEditor : Editor
{
    public override void OnInspectorGUI()
    {
        // Update the serialized object representation
        serializedObject.Update();

        // Draw the default inspector (shows the csvFile field and others)
        DrawDefaultInspector();

        TimeseriesCSVParser myScript = (TimeseriesCSVParser)target;

        // Only proceed if a CSV file is assigned
        if (myScript.csvFile != null)
        {
            string csvText = myScript.csvFile.text;
            // Split into lines (handling different newline types)
            string[] lines = csvText.Split(new[] { "\r\n", "\n" }, System.StringSplitOptions.RemoveEmptyEntries);

            if (lines.Length > 0)
            {
                // Assume the first line is the header row
                string[] headers = lines[0].Split(',');

                // Display a dropdown with the header names
                int newSelectedIndex = EditorGUILayout.Popup("Select Column", myScript.selectedColumnIndex, headers);

                // If the selection has changed, update the script's field and mark it dirty
                if (newSelectedIndex != myScript.selectedColumnIndex)
                {
                    myScript.selectedColumnIndex = newSelectedIndex;
                    EditorUtility.SetDirty(myScript);
                }
            }
            else
            {
                EditorGUILayout.HelpBox("CSV file is empty or has no header row.", MessageType.Warning);
            }
        }
        else
        {
            EditorGUILayout.HelpBox("Please assign a CSV file.", MessageType.Warning);
        }

        // Apply any changes to the serialized object
        serializedObject.ApplyModifiedProperties();
    }
}

How It Works

• Runtime Script:
  The TimeseriesCSVParser script simply holds a reference to the CSV file and a field for the selected column index. You can later use the selectedColumnIndex to drive your runtime CSV parsing logic.

• Custom Editor Script:
  In the custom editor script, we use DrawDefaultInspector() to show the standard inspector fields. Then, if a CSV file is assigned, we split the file’s text into lines and extract the header row (first line). Finally, we display a dropdown (EditorGUILayout.Popup) populated with the header strings. When a new column is selected, we update the selectedColumnIndex and mark the object as dirty so the change is saved.

This setup allows you to interactively select which column to use in your CSV parsing at edit time.

You

some of my columns hav ethe ”/” character. make sure that the dropdown doesnt treat those as sub-entries, but displays them whole

ChatGPT

Below is a modified version of the custom editor script that uses a GUIContent array for the popup options. Using GUIContent ensures that any ”/” characters in your header strings are treated as literal text rather than as delimiters for submenus.

Place this script in your “Editor” folder:

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(TimeseriesCSVParser))]
public class TimeseriesCSVParserEditor : Editor
{
    public override void OnInspectorGUI()
    {
        // Update the serialized object representation
        serializedObject.Update();

        // Draw default inspector fields (shows csvFile and others)
        DrawDefaultInspector();

        TimeseriesCSVParser myScript = (TimeseriesCSVParser)target;

        // Only proceed if a CSV file is assigned
        if (myScript.csvFile != null)
        {
            string csvText = myScript.csvFile.text;
            // Split the CSV text into lines (handling various newline formats)
            string[] lines = csvText.Split(new[] { "\r\n", "\n" }, System.StringSplitOptions.RemoveEmptyEntries);

            if (lines.Length > 0)
            {
                // Assume the first line is the header row
                string[] headers = lines[0].Split(',');

                // Create a GUIContent array to ensure "/" is not treated as a separator
                GUIContent[] options = new GUIContent[headers.Length];
                for (int i = 0; i < headers.Length; i++)
                {
                    options[i] = new GUIContent(headers[i]);
                }

                // Display a dropdown with the header names using the GUIContent array
                int newSelectedIndex = EditorGUILayout.Popup(new GUIContent("Select Column"), myScript.selectedColumnIndex, options);

                // If the selection changes, update the field and mark the object as dirty.
                if (newSelectedIndex != myScript.selectedColumnIndex)
                {
                    myScript.selectedColumnIndex = newSelectedIndex;
                    EditorUtility.SetDirty(myScript);
                }
            }
            else
            {
                EditorGUILayout.HelpBox("CSV file is empty or has no header row.", MessageType.Warning);
            }
        }
        else
        {
            EditorGUILayout.HelpBox("Please assign a CSV file.", MessageType.Warning);
        }

        // Apply any changes to the serialized object.
        serializedObject.ApplyModifiedProperties();
    }
}

How It Works

• GUIContent Array:
  Instead of passing a simple string array to EditorGUILayout.Popup, the script creates a GUIContent array for each header. This ensures that any ”/” characters in your headers are rendered as part of the string and are not interpreted as delimiters for submenus.

• Dropdown Behavior:
  The popup now shows the full column names exactly as they appear in your CSV header row, regardless of the presence of any special characters.

With this setup, your inspector dropdown will display each column name as a whole string, even if it contains the ”/” character.

You

How to create a streamreader from a TextAsset asset ?

ChatGPT

A TextAsset already holds your text data, so if you simply need to read it line-by-line, you can use a StringReader. However, if you specifically need a StreamReader (for example, to mimic file stream behavior), you can create a MemoryStream from the TextAsset’s bytes and pass that to the StreamReader.

Option 1: Using StringReader

using UnityEngine;
using System.IO;

public class TextAssetReaderExample : MonoBehaviour
{
    public TextAsset textAsset;

    void Start()
    {
        if (textAsset != null)
        {
            using (var reader = new StringReader(textAsset.text))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    Debug.Log(line);
                }
            }
        }
    }
}

Option 2: Using StreamReader with MemoryStream

using UnityEngine;
using System.IO;

public class TextAssetStreamReaderExample : MonoBehaviour
{
    public TextAsset textAsset;

    void Start()
    {
        if (textAsset != null)
        {
            using (var memoryStream = new MemoryStream(textAsset.bytes))
            using (var streamReader = new StreamReader(memoryStream))
            {
                string line;
                while ((line = streamReader.ReadLine()) != null)
                {
                    Debug.Log(line);
                }
            }
        }
    }
}

Both methods allow you to read your CSV (or any text data) at runtime. Choose the one that best fits your needs.