untiy 手写输入中文识别示例

要在 Unity 中实现中文手写输入的识别，可以使用 TensorFlow 等机器学习框架来训练一个中文手写汉字识别模型。以下是一个简单的示例代码，可以参考一下：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TensorFlowLite;

public class HandwritingChinese : MonoBehaviour
{
    [SerializeField] private Camera camera;
    [SerializeField] private TextAsset graphModel;
    [SerializeField] private TextAsset labelMap;
    [SerializeField] private int width = 128;
    [SerializeField] private int height = 128;

    private Interpreter interpreter;
    private Dictionary<int, string> labelDict;
    private List<Vector2> strokePoints;
    private Texture2D texture;

    void Start()
    {
        strokePoints = new List<Vector2>();
        texture = new Texture2D(width, height, TextureFormat.RGBA32, false);

        interpreter = new Interpreter(graphModel.bytes);
        interpreter.ResizeInputTensor(0, new int[] { 1, width, height, 1 });
        interpreter.AllocateTensors();

        labelDict = new Dictionary<int, string>();
        string[] labelLines = labelMap.text.Split('\n');
        for (int i = 0; i < labelLines.Length; i++) {
            string[] labelFields = labelLines[i].Split(':');
            labelDict.Add(int.Parse(labelFields[0]), labelFields[1]);
        }
    }

    void Update()
    {
        // 检测鼠标或触摸输入
        if (Input.GetMouseButton(0) || Input.touchCount > 0) {
            Vector2 inputPosition = GetInputPosition();

            // 记录手写轨迹点
            if (Input.GetMouseButtonDown(0) || Input.GetTouch(0).phase == TouchPhase.Began) {
                strokePoints.Clear();
                strokePoints.Add(inputPosition);
            }
            else if (Input.GetMouseButton(0) || Input.GetTouch(0).phase == TouchPhase.Moved) {
                strokePoints.Add(inputPosition);
            }
        }
        // 识别手写汉字
        else if (Input.GetMouseButtonUp(0) || Input.touchCount == 0) {
            // 将手写轨迹点转换为纹理
            texture.SetPixels32(new Color32[width * height]);
            Vector2 minPosition = GetMinPosition();
            Vector2 maxPosition = GetMaxPosition();
            float scale = Mathf.Min(width / (maxPosition.x - minPosition.x), height / (maxPosition.y - minPosition.y));
            for (int i = 1; i < strokePoints.Count; i++) {
                Vector2 p1 = (strokePoints[i - 1] - minPosition) * scale;
                Vector2 p2 = (strokePoints[i] - minPosition) * scale;
                DrawLine(texture, (int)p1.x, (int)p1.y, (int)p2.x, (int)p2.y, Color.black, 5);
            }
            texture.Apply();

            // 将纹理转换为输入张量
            float[] inputTensor = new float[width * height];
            Color32[] pixels = texture.GetPixels32();
            for (int i = 0; i < pixels.Length; i++) {
                float value = 1 - (pixels[i].r + pixels[i].g + pixels[i].b) / (3 * 255.0f);
                inputTensor[i] = value;
            }

            // 运行模型进行预测
            interpreter.SetInputTensorData(0, inputTensor);
            interpreter.Invoke();

            // 获取预测结果
            float[] outputTensor = new float[6763];
            interpreter.GetOutputTensorData(0, outputTensor);

            // 将预测结果转换为汉字
            int maxIndex = 0;
            float maxValue = outputTensor[0];
            for (int i = 1; i < outputTensor.Length; i++) {
                if (outputTensor[i] > maxValue) {
                    maxIndex = i;
                    maxValue = outputTensor[i];
                }
            }
            string result = labelDict[maxIndex];
            Debug.Log("识别结果：" + result);
        }
    }

    private Vector2 GetInputPosition()
    {
        if (Input.touchCount > 0) {
            return camera.ScreenToWorldPoint(Input.GetTouch(0).position);
        }
        else {
            return camera.ScreenToWorldPoint(Input.mousePosition);
        }
    }

    private Vector2 GetMinPosition()
    {
        Vector2 minPosition = new Vector2(float.MaxValue, float.MaxValue);
        foreach (Vector2 point in strokePoints) {
            if (point.x < minPosition.x) {
                minPosition.x = point.x;
            }
            if (point.y < minPosition.y) {
                minPosition.y = point.y;
            }
        }
        return minPosition;
    }

    private Vector2 GetMaxPosition()
    {
        Vector2 maxPosition = new Vector2(float.MinValue, float.MinValue);
        foreach (Vector2 point in strokePoints) {
            if (point.x > maxPosition.x) {
                maxPosition.x = point.x;
            }
            if (point.y > maxPosition.y) {
                maxPosition.y = point.y;
            }
        }
        return maxPosition;
    }

    private void DrawLine(Texture2D texture, int x0, int y0, int x1, int y1, Color color, int thickness)
    {
        int dx = Mathf.Abs(x1 - x0);
        int dy = Mathf.Abs(y1 - y0);
        int sx = (x0 < x1) ? 1 : -1;
        int sy = (y0 < y1) ? 1 : -1;
        int err = dx - dy;

        for (int i = 0; i < thickness; i++) {
            texture.SetPixel(x0, y0 + i, color);
        }

        while (x0 != x1 || y0 != y1) {
            int e2 = err * 2;
            if (e2 > -dy) {
                err -= dy;
                x0 += sx;
            }
            if (e2 < dx) {
                err += dx;
                y0 += sy;
            }

            for (int i = 0; i < thickness; i++) {
                texture.SetPixel(x0, y0 + i, color);
            }
        }
    }
}

这个示例代码中，我们使用 TensorFlowLite 库加载训练好的模型，将手写汉字通过纹理转换为输入张量，运行模型进行预测，并将预测结果转换为汉字输出。在这个示例中，我们只是用了一个简单的单层全连接神经网络作为模型，实际情况中需要使用更加复杂的卷积神经网络或循环神经网络来提高识别准确性。