ai.muna.muna 0.0.45 → 0.0.47

package/Unity/Converters/Rect.cs

@@ -0,0 +1,230 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using System.Runtime.Serialization;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Converters;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Box format.
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum BoxFormat : int {
+        /// <summary>
+        /// Boxes are represented via corners: x1, y1 being top left and x2, y2 being bottom right.
+        /// </summary>
+        [EnumMember(Value = @"xyxy")]
+        XYXY = 1,
+        /// <summary>
+        /// Boxes are represented via corner, width and height: x1, y2 being top left.
+        /// </summary>
+        [EnumMember(Value = @"xywh")]
+        XYWH = 2,
+        /// <summary>
+        /// Boxes are represented via center, width, and height.
+        /// </summary>
+        [EnumMember(Value = @"cxcywh")]
+        CxCyWH = 3,
+        /// <summary>
+        /// Boxes are represented via corners:
+        /// - x1, y1 being top left
+        /// - x2, y2 top right
+        /// - x3, y3 bottom right
+        /// - x4, y4 bottom left
+        /// </summary>
+        [EnumMember(Value = @"xyxyxyxy")]
+        XYXYXYXY = 4,
+    }
+
+    /// <summary>
+    /// Convert an object field to a `Rect`.
+    /// </summary>
+    public sealed class ObjectToRectConverter : JsonConverter<Rect> {
+
+        private readonly BoxFormat format;
+        private readonly string[] fieldNames;
+
+        /// <summary>
+        /// Create a converter with the provided box format.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        public ObjectToRectConverter(BoxFormat format): this(
+            format,
+            GetReferenceFieldNames(format)
+        ) { }
+
+        /// <summary>
+        /// Create a converter with the provided box format and corresponding field names.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        /// <param name="fieldNames">Field names that correspond to the chosen format.</param>
+        public ObjectToRectConverter(BoxFormat format, string[] fieldNames) {
+            this.format = format;
+            this.fieldNames = fieldNames;
+        }
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Rect value,
+            JsonSerializer serializer
+        ) {
+            var values = GetRectValues(value, format);
+            var obj = new JObject();
+            for (var i = 0; i < fieldNames.Length; ++i)
+                obj[fieldNames[i]] = values[i];
+            obj.WriteTo(writer);
+        }
+
+        public override Rect ReadJson(
+            JsonReader reader,
+            Type type,
+            Rect existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var obj = JObject.Load(reader);
+            return format switch {
+                BoxFormat.XYXY => Rect.MinMaxRect(
+                    xmin: GetFieldValue(obj, fieldNames[0]),
+                    ymin: GetFieldValue(obj, fieldNames[1]),
+                    xmax: GetFieldValue(obj, fieldNames[2]),
+                    ymax: GetFieldValue(obj, fieldNames[3])
+                ),
+                BoxFormat.XYWH => new Rect(
+                    x: GetFieldValue(obj, fieldNames[0]),
+                    y: GetFieldValue(obj, fieldNames[1]),
+                    width: GetFieldValue(obj, fieldNames[2]),
+                    height: GetFieldValue(obj, fieldNames[3])
+                ),
+                BoxFormat.CxCyWH => GetCenterRect(obj),
+                BoxFormat.XYXYXYXY => Rect.MinMaxRect(
+                    xmin: GetFieldValue(obj, fieldNames[0]),  // left
+                    ymin: GetFieldValue(obj, fieldNames[1]),  // top
+                    xmax: GetFieldValue(obj, fieldNames[4]),  // right
+                    ymax: GetFieldValue(obj, fieldNames[5])   // bottom
+                ),
+                _ => throw new JsonSerializationException($"Failed to read `Rect` from JSON object because of unsupported format: {format}")
+            };
+        }
+
+        private Rect GetCenterRect(JObject obj) {
+            var cx = GetFieldValue(obj, fieldNames[0]);
+            var cy = GetFieldValue(obj, fieldNames[1]);
+            var w = GetFieldValue(obj, fieldNames[2]);
+            var h = GetFieldValue(obj, fieldNames[3]);
+            var center = new Vector2(cx, cy);
+            var size = new Vector2(w, h);
+            return new Rect(center - 0.5f * size, size);
+        }
+
+        private float GetFieldValue(
+            JObject obj,
+            string name
+        ) {
+            if (!obj.TryGetValue(name, StringComparison.InvariantCulture, out var value))
+                throw new JsonSerializationException($"Missing '{name}' field for {format} box.");
+            return (float)value;
+        }
+
+        internal static float[] GetRectValues(
+            in Rect rect,
+            BoxFormat format
+        ) => format switch {
+            BoxFormat.XYXY      => new[] { rect.xMin, rect.yMin, rect.xMax, rect.yMax },
+            BoxFormat.XYWH      => new[] { rect.xMin, rect.yMin, rect.width, rect.height },
+            BoxFormat.CxCyWH    => new[] { rect.center.x, rect.center.y, rect.width, rect.height },
+            BoxFormat.XYXYXYXY  => new[] {
+                rect.xMin, rect.yMin, // top-left
+                rect.xMax, rect.yMin, // top-right
+                rect.xMax, rect.yMax, // bottom-right
+                rect.xMin, rect.yMax  // bottom-left
+            },
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+
+        private static string[] GetReferenceFieldNames(BoxFormat format) => format switch {
+            BoxFormat.XYXY      => new[] { @"x_min", @"y_min", @"x_max", @"y_max" },
+            BoxFormat.XYWH      => new[] { @"x", @"y", @"width", @"height" },
+            BoxFormat.CxCyWH    => new[] { @"x_center", @"y_center", @"width", @"height" },
+            BoxFormat.XYXYXYXY  => new[] { @"x1", @"y1", @"x2", @"y2", @"x3", @"y3", @"x4", @"y4" },
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+
+    /// <summary>
+    /// Convert an array field to a `Rect`.
+    /// The array MUST contain numbers, and have the required count depending on the box format.
+    /// </summary>
+    public sealed class ArrayToRectConverter : JsonConverter<Rect> {
+
+        private readonly BoxFormat format;
+
+        /// <summary>
+        /// Create a converter for the provided box format.
+        /// </summary>
+        /// <param name="format">Box format to parse.</param>
+        public ArrayToRectConverter(BoxFormat format) => this.format = format;
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Rect value,
+            JsonSerializer serializer
+        ) {
+            var values = ObjectToRectConverter.GetRectValues(value, format);
+            var arr = new JArray(values);
+            arr.WriteTo(writer);
+        }
+
+        public override Rect ReadJson(
+            JsonReader reader,
+            Type type,
+            Rect existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            var expected = ExpectedCount(format);
+            if (arr.Count != expected)
+                throw new JsonSerializationException($"Expected {expected} numbers for {format} box but got {arr.Count}.");
+            var data = arr.ToObject<float[]>()!;
+            return format switch {
+                BoxFormat.XYXY => Rect.MinMaxRect(
+                    xmin: data[0],
+                    ymin: data[1],
+                    xmax: data[2],
+                    ymax: data[3]
+                ),
+                BoxFormat.XYWH => new Rect(
+                    x: data[0],
+                    y: data[1],
+                    width: data[2],
+                    height: data[3]
+                ),
+                BoxFormat.CxCyWH => new Rect(
+                    x: data[0] - 0.5f * data[2],
+                    y: data[1] * 0.5f - data[3],
+                    width: data[2],
+                    height: data[3]
+                ),
+                _ => throw new JsonSerializationException($"Failed to read `Rect` from JSON array because of unsupported format: {format}")
+            };
+        }
+
+        private static int ExpectedCount(BoxFormat format) => format switch {
+            BoxFormat.XYXY      => 4,
+            BoxFormat.XYWH      => 4,
+            BoxFormat.CxCyWH    => 4,
+            BoxFormat.XYXYXYXY  => 8,
+            _                   => throw new ArgumentOutOfRangeException(nameof(format))
+        };
+    }
+}

package/Unity/Converters/Rect.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d6cd7cc66eca9496f9387c790eec7a1a

package/Unity/Converters/Vector2.cs

@@ -0,0 +1,44 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Vector2`.
+    /// The array MUST contain exactly two numbers.
+    /// </summary>
+    public sealed class ArrayToVector2Converter : JsonConverter<Vector2> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector2 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y };
+            obj.WriteTo(writer);
+        }
+
+        public override Vector2 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector2 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector2(
+                x: (float)arr[0],
+                y: (float)arr[1]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector2.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: aae870c26c0ca457094e039514a8a134

package/Unity/Converters/Vector3.cs

@@ -0,0 +1,45 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Vector3`.
+    /// The array MUST contain exactly three numbers.
+    /// </summary>
+    public sealed class ArrayToVector3Converter : JsonConverter<Vector3> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector3 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y, value.z };
+            obj.WriteTo(writer);
+        }
+
+        public override Vector3 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector3 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector3(
+                x: (float)arr[0],
+                y: (float)arr[1], 
+                z: (float)arr[2]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector3.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fc6fa1f08b7e14d6595566ba018a5f18

package/Unity/Converters/Vector4.cs

@@ -0,0 +1,46 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Converters {
+
+    using System;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Newtonsoft.Json.Linq;
+
+    /// <summary>
+    /// Convert an array field to a `Vector4`.
+    /// The array MUST contain exactly four numbers.
+    /// </summary>
+    public sealed class ArrayToVector4Converter : JsonConverter<Vector4> {
+
+        public override void WriteJson(
+            JsonWriter writer,
+            Vector4 value,
+            JsonSerializer serializer
+        ) {
+            var obj = new JArray { value.x, value.y, value.z, value.w };
+            obj.WriteTo(writer);
+        }
+
+        public override Vector4 ReadJson(
+            JsonReader reader,
+            Type type,
+            Vector4 existing,
+            bool hasExisting,
+            JsonSerializer s
+        ) {
+            var arr = JArray.Load(reader);
+            return new Vector4(
+                x: (float)arr[0],
+                y: (float)arr[1],
+                z: (float)arr[2],
+                w: (float)arr[3]
+            );
+        }
+    }
+}

package/Unity/Converters/Vector4.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b9fecd773c668496b812e7d861c7d669

package/Unity/Converters.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 110a01a39990b4ebf95762b66a191ec2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Unity/Internal/MunaSettings.cs

@@ -27,7 +27,7 @@ namespace Muna.Internal {
         /// Predictor cache.
         /// </summary>
         [field: SerializeField, HideInInspector]
-        public List<CachedPrediction> cache { get; internal set; } = new();
+        public List<PredictionCache.CachedPrediction> cache { get; internal set; } = new();
 
         /// <summary>
         /// Settings instance for this project.

package/Unity/Internal/PredictionCache.cs

@@ -0,0 +1,160 @@
+/* 
+*   Muna
+*   Copyright © 2025 NatML Inc. All rights reserved.
+*/
+
+#nullable enable
+
+namespace Muna.Internal {
+
+    using System;
+    using System.IO;
+    using System.Security.Cryptography;
+    using System.Text;
+    using UnityEngine;
+    using Newtonsoft.Json;
+    using Services;
+
+    internal static class PredictionCache {
+
+        #region --Types--
+        /// <summary>
+        /// Cached prediction.
+        /// </summary>
+        [Preserve, Serializable]
+        internal class CachedPrediction : Prediction {
+            public string? clientId;
+            public string? configurationId;
+
+            [Preserve]
+            public CachedPrediction() { }
+        }
+        #endregion
+
+
+        #region --Client API--
+        /// <summary>
+        /// Add a prediction to the cache.
+        /// </summary>
+        public static void Add(CachedPrediction prediction) {
+            var path = GetCachedPath(prediction);
+            var json = JsonConvert.SerializeObject(prediction, Formatting.Indented);
+            File.WriteAllText(path, json);
+        }
+
+        /// <summary>
+        /// Get a prediction from the cache.
+        /// </summary>
+        public static bool Get(
+            string tag,
+            string clientId,
+            string configurationId,
+            PredictionResource[]? embeddedResources,
+            out CachedPrediction? prediction
+        ) {
+            prediction = null;
+            // Check filesystem
+            var path = GetCachedPath(tag, clientId, configurationId);
+            if (!File.Exists(path))
+                return false;
+            // Load prediction
+            var json = File.ReadAllText(path);
+            var result = JsonConvert.DeserializeObject<CachedPrediction>(json)!;
+            // Check that resources are valid
+            if (!ResourcesAreValid(result.resources!, embeddedResources)) {
+                File.Delete(path);
+                return false;
+            }
+            // Pass
+            prediction = result;
+            return true;
+        }
+
+        /// <summary>
+        /// Remove a prediction from the cache.
+        /// </summary>
+        /// <param name="prediction"></param>
+        public static void Remove(CachedPrediction prediction) {
+            var path = GetCachedPath(prediction);
+            if (File.Exists(path))
+                File.Delete(path);
+        }
+
+        /// <summary>
+        /// Create a cached prediction from a prediction.
+        /// </summary>
+        public static CachedPrediction AsCached(
+            this Prediction prediction,
+            string? clientId = null,
+            string? configurationId = null
+        ) => new() {
+            id = prediction.id,
+            tag = prediction.tag,
+            created = prediction.created,
+            results = prediction.results,
+            latency = prediction.latency,
+            error = prediction.error,
+            logs = prediction.logs,
+            resources = prediction.resources,
+            configuration = prediction.configuration,
+            clientId = clientId,
+            configurationId = configurationId
+        };
+        #endregion
+
+
+        #region --Operations--
+        private static string CacheRoot => Application.isEditor ?
+            Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), @".fxn") :
+            Path.Combine(Application.persistentDataPath, @"fxn");
+        internal static string ResourceCachePath => Path.Combine(CacheRoot, @"cache");
+        internal static string PredictorCachePath => Path.Combine(CacheRoot, @"predictors");
+
+        private static string GetCachedPath(CachedPrediction prediction) => GetCachedPath(
+            tag: prediction.tag,
+            clientId: prediction.clientId!,
+            configurationId: prediction.configurationId!
+        );
+
+        private static string GetCachedPath(
+            string tag,
+            string clientId,
+            string configurationId
+        ) {
+            if (!Directory.Exists(PredictorCachePath))
+                Directory.CreateDirectory(PredictorCachePath);
+            using var sha256 = new SHA256Managed();
+            var identifier = $"{tag}::{clientId}::{configurationId}";
+            var identifierData = Encoding.UTF8.GetBytes(identifier);
+            var hashData = sha256.ComputeHash(identifierData);
+            var hash = BitConverter.ToString(hashData).Replace("-", "").ToLower();
+            var path = Path.Combine(PredictorCachePath, $"{hash}.json");
+            return path;
+        }
+
+        private static bool ResourcesAreValid(
+            PredictionResource[] cachedResources,
+            PredictionResource[]? embeddedResources
+        ) {
+            if (embeddedResources != null && cachedResources.Length != embeddedResources.Length)
+                return false;
+            for (var idx = 0; idx < cachedResources.Length; ++idx) {
+                var cachedResource = cachedResources[idx];
+                var cachedPath = new Uri(cachedResource.url).LocalPath;
+                var embeddedPath = embeddedResources != null ?
+                    PredictionService.GetResourcePath(embeddedResources[idx], ResourceCachePath) :
+                    null;
+
+                Application.SetStackTraceLogType(LogType.Log, StackTraceLogType.None);
+                Debug.Log($"Cached path: {cachedPath} Embedded path: {embeddedPath}");
+
+                if (!File.Exists(cachedPath))
+                    return false;
+                if (embeddedPath != null && cachedPath != embeddedPath)
+                    return false;
+            }
+            return true;
+        }
+        #endregion
+    }
+}

package/Unity/Internal/PredictionCache.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: d4e0b513297bf4d95935d63a7764c9ba