Unity Editor Window Tool

2024-10-19 22:40 UTC gpt-4o-canmore Open in ChatGPT ↗

this script might be able to become an Editor Window tool. try it

using System; using System.Diagnostics; using System.IO; using System.Text; using System.Threading.Tasks; using UnchartedLimbo.Core.Utilities.DataStructures; using UnityEngine; using UnityEngine.Events; using UnityEngine.Serialization; using Debug = UnityEngine.Debug;

#if UNITY_EDITOR using UnityEditor; #endif

namespace UnchartedLimbo.Core.Utilities.DataExport { public class DataExporter2 : MonoBehaviour { public AnimationClipList clipList; [FormerlySerializedAs(“holder”)] public MocapData_LiteHolder mocapDataContainer;

    [Header("Export Settings")]
    [Tooltip("In frames")] public int window_length;
    [Tooltip("In frames")] public int window_overlap;

    [Header("CSV Settings")]
    public string filename;
    public string full_name;

    private string path;
    private string label_path;
    private string t_data;

    private int window_step; // how many frames we move forward to get to next window
    private int window_start_index; // the current index to start the window from
    private int window_id; // current window index
    private int window_end;
    private int prev_seq_id;
    private int new_seq_id;
    private int frame_counter;

    public UnityEvent OnFinished;
    public Stopwatch masterStopwatch;

    private async void Start()
    {
        masterStopwatch = new Stopwatch();
        full_name = $"{filename}_{DateTime.Today:yyyy-MM-dd}_W{window_length}_O{window_overlap}";
        await WriteDataAsync();

        #if UNITY_EDITOR
        AssetDatabase.Refresh();
        #endif
    }

    public async Task WriteDataAsync()
    {
        masterStopwatch.Restart();

        // Create export Path
        path = Path.Combine(Application.streamingAssetsPath, full_name + ".csv");
        label_path = Path.Combine(Application.streamingAssetsPath, full_name + "_labels.csv");

        var (data,labels) = await BuildFileContent(mocapDataContainer.mocapData);

        await WriteToFileAsync(path, data);
        await WriteToFileAsync(label_path, labels);

        masterStopwatch.Stop();
        Debug.Log($">>> DURATION OF RUN: {masterStopwatch.Elapsed.TotalSeconds} seconds");
    }

    private async Task<(string, string)> BuildFileContent(MocapData_Lite mocap)
    {
        Debug.Log(new string('-', 80));
        Debug.Log("Writing Data as Text -------");
        Debug.Log(new string('-', 80));

        var sw = new Stopwatch();
        sw.Start();

        var headers = mocap.data_header; // Headers: ONLY ONE OCCURENCE
        var data = mocap.data; // Data: PER FRAME OCCURENCE
        var sequenceLengths = mocap.framesPerSequence;

        // 0 -- CREATE MAIN STRINGBUILDERs ---------
        var data_string = new StringBuilder(); // for data
        var label_string = new StringBuilder(); // for data labels
        var header_string = new StringBuilder();

        // 1 -- WRITE HEADERS ---------------------
        header_string.Append("Sequence_ID,");

        for (var i = 0; i < headers.Length; i++)
        {
            if (i == 0)
            {
                header_string.Append(headers[i] + "_Xpos,");
                header_string.Append(headers[i] + "_Ypos,");
                header_string.Append(headers[i] + "_Zpos,");
                header_string.Append(headers[i] + "_Xrot,");
                header_string.Append(headers[i] + "_Yrot,");
                header_string.Append(headers[i] + "_Zrot,");
            }
            else
            {
                header_string.Append(headers[i] + "_Xdir,");
                header_string.Append(headers[i] + "_Ydir,");
                header_string.Append(headers[i] + "_Zdir,");
            }
        }

        data_string.AppendLine(header_string.ToString());

        label_string.AppendLine("Sequence_ID,Labels");

        window_start_index = 0;
        var step = window_length - window_overlap;
        Debug.Log($"The step is {step} frames");

        await Task.Run(async () =>
        {
            window_id = 0;
            frame_counter = 0;

            // Iterate sequences
            for (var j = 0; j < mocap.sequenceCount; j++)
            {
                var seq_length = sequenceLengths[j];

                Debug.Log($">>> SEQUENCE {j} - {seq_length} FRAMES");

                var window_index = 0;

                while (window_index < seq_length - window_length)
                {
                    var i = window_index;

                    // Grabbing values by full window length
                    for (i = window_index; i < window_index + window_length; i++)
                    {
                        var index = window_start_index + i;

                        var d = data[index];
                        data_string.AppendLine($"{window_id},{d}");
                        label_string.AppendLine($"{window_id},{clipList.labels[d.label_id]}");
                        frame_counter++;

                        Debug.Log($"-------- {i} | WID: {window_id} | WI: {window_index}");

                        await Task.Yield();
                    }

                    // Moving by Step
                    window_index += step;

                    window_id++;
                }

                window_start_index += seq_length;
            }
        });

        Debug.Log($">>> finished writing string data after {sw.Elapsed.TotalSeconds} -----");
        sw.Stop();

        return (data_string.ToString(), label_string.ToString());
    }

    private async Task WriteToFileAsync(string filePath, string content)
    {
        Debug.Log($">>> Saving {frame_counter} frames to: {path}");

        await using var streamWriter = new StreamWriter(filePath, false);
        await streamWriter.WriteAsync(content);
    }
}

}