MREdustryXR/Assets/FrameWork/ProjectManager/Scripts/Project/XunJian/进入任务/GameUtility.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using OpenCVForUnity.CoreModule;
using OpenCVForUnity.ImgcodecsModule;
using OpenCVForUnity.ImgprocModule;
using OpenCVForUnity.UnityUtils;
using UnityEditor;
using System.Text;
using System.Web;
using System;
using System.IO;
using System.Linq;

/// <summary>
/// 游戏工具类
/// Game Utility Tools
/// </summary>
public class GameUtility
{
    /// <summary>
    /// Find Deep child with name
    /// </summary>
    public static Transform FindDeepChild(GameObject _target, string _childName)
    {
        Transform resultTrs = null;
        resultTrs = _target.transform.Find(_childName);
        if (resultTrs == null)
        {
            foreach (Transform trs in _target.transform)
            {
                resultTrs = GameUtility.FindDeepChild(trs.gameObject, _childName);
                if (resultTrs != null)
                    return resultTrs;
            }
        }
        return resultTrs;
    }

    /// <summary>
    /// Find component in Target Child
    /// </summary>
    public static T FindDeepChild<T>(GameObject _target, string _childName) where T : Component
    {
        Transform resultTrs = GameUtility.FindDeepChild(_target, _childName);
        if (resultTrs != null)
            return resultTrs.gameObject.GetComponent<T>();
        return (T)((object)null);
    }

    /// <summary>
    /// 添加子节点
    /// Add child to target
    /// </summary>
    public static void AddChildToTarget(Transform target, Transform child)
    {
        //child.parent = target;
        child.SetParent(target, false);
        child.localScale = Vector3.one;
        child.localPosition = Vector3.zero;
        child.localEulerAngles = Vector3.zero;

        ChangeChildLayer(child, target.gameObject.layer);
    }

    /// <summary>
    /// 修改子节点Layer
    /// Change child layer
    /// </summary>
    public static void ChangeChildLayer(Transform t, int layer)
    {
        t.gameObject.layer = layer;
        for (int i = 0; i < t.childCount; ++i)
        {
            Transform child = t.GetChild(i);
            child.gameObject.layer = layer;
            ChangeChildLayer(child, layer);
        }
    }


    /// 删除下面所有子物体
    public static void DeleteAllGo(Transform go)
    {
        List<GameObject> DeleteList = new List<GameObject>();
        for (int i = 0; i < go.childCount; i++)
        {
            DeleteList.Add(go.GetChild(i).gameObject);
        }
        for (int i = 0; i < DeleteList.Count; i++)
        {
            GameObject.DestroyImmediate(DeleteList[i],true);
        }
    }
    // 删除下面单个物体
    public static void DeleteSingleGo(Transform go, int index)
    {
        for (int i = 0; i < go.childCount; i++)
        {
            if (i == index)
                GameObject.Destroy(go.GetChild(i).gameObject);
        }
    }
    private static  Texture2D _tex;
    /// <summary>
    /// OpenCV生成图片缩略图
    /// </summary>
    /// <param name="path">文件路径</param>
    /// <param name="zoom">缩放值</param>
    /// <returns></returns>
    public static Mat zoomMatByOpenCV(string path, double zoom)
    {
        //Debug.Log("  zoomMatByOpenCV   path  : "+path);
        Mat mat = filePathToMat(path);
        //Debug.Log(mat.cols());
        //Debug.Log(mat.rows());
        //压缩图片
        Size size = new Size(mat.cols() * zoom, mat.rows() * zoom);
        Mat zoomMat = new Mat(size, CvType.CV_8UC4);
        Imgproc.resize(mat, zoomMat, size);
        ////BGR 转RGB
        Mat imgRGBMat = new Mat(zoomMat.cols(), zoomMat.rows(), CvType.CV_8UC4);
        Imgproc.cvtColor(zoomMat, imgRGBMat, Imgproc.COLOR_BGR2RGB);
        zoomMat.release();
        mat.release();
        return imgRGBMat;
        //return mat;
    }
    public event Action RefreshEvent;
    /// <summary>
    /// OpenCV生成图片缩略图
    /// </summary>
    /// <param name="path">文件路径</param>
    /// <param name="zoom">缩放值</param>
    /// <returns></returns>
    public static Mat zoomByteByOpenCV(string path, double zoom,bool isZD=false,bool issuolve=false)
    {

        MatOfByte matbytes = filePathToMatByte(path);
        Mat mat = Imgcodecs.imdecode(matbytes, -1);
        if (isZD)
        {

            zoom = 1;
            float sint = 2048f;
            if(issuolve)
            {
                sint = 256f;
            }
            if (mat.cols() > sint)
            {
                zoom = (float)(sint / mat.cols());
            }
            if (mat.rows() * zoom > sint)
            {
                zoom = (float)(sint / (float)(mat.rows() * zoom));
            }
        }
        //Debug.Log(mat.cols());
        //Debug.Log(mat.rows());
        //压缩图片
        Size size = new Size(mat.cols() * zoom, mat.rows() * zoom);
        Mat zoomMat = new Mat(size, CvType.CV_8UC4);
        Imgproc.resize(mat, zoomMat, size);
        ////BGR 转RGB
        Mat imgRGBMat = new Mat(zoomMat.cols(), zoomMat.rows(), CvType.CV_8UC4);
        Imgproc.cvtColor(zoomMat, imgRGBMat, Imgproc.COLOR_BGR2RGB);
        //RefreshEvent?.Invoke();
        zoomMat.release();
        mat.release();
        matbytes.release();
        return imgRGBMat;
        //return mat;
    }

    /// <summary>
    /// OpenCV生成图片缩略图
    /// </summary>
    /// <param name="">二进制</param>
    /// <param name="zoom">缩放值</param>
    /// <returns></returns>
    public static Mat zoomByteByOpenCV(byte[] bytedata, double zoom)
    {
        MatOfByte matbytes = new MatOfByte(bytedata);
        if (matbytes.nativeObj == IntPtr.Zero)
        {
            return null;
        }
        Mat mat = Imgcodecs.imdecode(matbytes, -1);
        //mat.
        //Debug.Log(mat.cols());
        //Debug.Log(mat.rows());
        //压缩图片
        Size size = new Size(mat.cols() * zoom, mat.rows() * zoom);
        Mat zoomMat = new Mat(size, CvType.CV_8UC4);
        Imgproc.resize(mat, zoomMat, size);
        ////BGR 转RGB
        Mat imgRGBMat = new Mat(zoomMat.cols(), zoomMat.rows(), CvType.CV_8UC4);
        Imgproc.cvtColor(zoomMat, imgRGBMat, Imgproc.COLOR_BGR2RGB);
        zoomMat.release();
        mat.release();
        matbytes.release();
        //RefreshEvent?.Invoke();
        return imgRGBMat;
        //return mat;
    }


    /// <summary>
    /// 为了放入子线程 不能使用Time
    /// </summary>
    /// <param name="matbytes"></param>
    /// <param name="zoom"></param>
    /// <returns></returns>
    public static  Mat zoomMatOfByteByOpenCV(MatOfByte matbytes, double zoom)
    {
        Mat mat = Imgcodecs.imdecode(matbytes, -1);


        zoom = 1;
        float sint = 256f;
        if (mat.cols() > sint)
        {
            zoom = (float)(sint / mat.cols());
        }
        if (mat.rows() * zoom > sint)
        {
            zoom = (float)(sint / (float)(mat.rows() * zoom));
        }


        //Debug.Log(mat.cols());
        //Debug.Log(mat.rows());
        //压缩图片
        Size size = new Size(mat.cols() * zoom, mat.rows() * zoom);
        Mat zoomMat = new Mat(size, CvType.CV_8UC4);
        Imgproc.resize(mat, zoomMat, size);
        ////BGR 转RGB
        Mat imgRGBMat = new Mat(zoomMat.cols(), zoomMat.rows(), CvType.CV_8UC4);
        Imgproc.cvtColor(zoomMat, imgRGBMat, Imgproc.COLOR_BGR2RGB);
        zoomMat.release();
        mat.release();
        matbytes.release();
        return imgRGBMat;
    }

    /// <summary>
    /// 通过文件地址拿到图片矩阵
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    public static Mat filePathToMat(string path)
    {
        
        //Imgcodecs.imdecode
        return Imgcodecs.imread(path);
    }

    public static MatOfByte filePathToMatByte(string path)
    {
        MatOfByte matOfByte = new MatOfByte(LoadSpriteByIOByte(path));
        //Imgcodecs.imdecode
        return matOfByte;
    }
    /// <summary>
    /// 矩阵转Texture
    /// </summary>
    /// <param name="path"></param>
    /// <param name="zoom"></param>
    /// <returns></returns>
    public static Texture2D TextureByMat(Mat imgRGBMat)
    {
        //Debug.Log(imgRGBMat.cols());
        //Debug.Log(imgRGBMat.rows());
        _tex = new Texture2D(imgRGBMat.cols(), imgRGBMat.rows(), TextureFormat.RGB24, false);
        Utils.fastMatToTexture2D(imgRGBMat, _tex);
        return _tex;
    }

    /// <summary>
    /// 缩略图
    /// </summary>
    /// <param name="source"></param>
    /// <param name="newWidth"></param>
    /// <param name="newHeight"></param>
    /// <returns></returns>
    public static Texture2D Resize(Texture2D source, int newWidth, int newHeight)
    {
        source.filterMode = FilterMode.Point;
        RenderTexture rt = RenderTexture.GetTemporary(newWidth, newHeight);
        rt.filterMode = FilterMode.Point;
        RenderTexture.active = rt;
        Graphics.Blit(source, rt);
        var nTex = new Texture2D(newWidth, newHeight);
        nTex.ReadPixels(new UnityEngine.Rect(0, 0, newWidth, newHeight), 0, 0);
        nTex.Apply();
        RenderTexture.active = null;
        return nTex;
    }

    /// <summary>
    /// IO方式加载本地图片
    /// </summary>
    /// <param name="fileurl"></param>
    /// <returns>Texture2D</returns>
    public Texture2D LoadSpriteByIO(string fileurl)
    {
        double startTime = (double)Time.time;
        //创建文件流
        FileStream fileStream = new FileStream(fileurl, FileMode.Open, FileAccess.Read);
        fileStream.Seek(0, SeekOrigin.Begin);
        //创建文件长度的缓冲区
        byte[] bytes = new byte[fileStream.Length];
        //读取文件
        fileStream.Read(bytes, 0, (int)fileStream.Length);
        //释放文件读取liu
        fileStream.Close();
        fileStream.Dispose();
        fileStream = null;

        //创建Texture
        int width = 300;
        int height = 372;
        Texture2D texture2D = new Texture2D(width, height);

        texture2D.LoadImage(bytes);

        //tex = texture2D;

        return texture2D;
    }
    /// <summary>
    /// texture转2进制
    /// </summary>
    /// <param name="sp"></param>
    /// <returns></returns>
    public static byte[] GetTextureToByte(Texture2D temp)
    {
        //在转换成bytes
        byte[] photoByte = temp.EncodeToPNG();
        return photoByte;
    }

    /// <summary>
    /// IO方式加载本地图片
    /// </summary>
    /// <param name="fileurl"></param>
    /// <returns>byte[]</returns>
    public static  byte[] LoadSpriteByIOByte(string fileurl)
    {
        //创建文件流
        FileStream fileStream = new FileStream(fileurl, FileMode.Open, FileAccess.Read);
        fileStream.Seek(0, SeekOrigin.Begin);
        //创建文件长度的缓冲区
        byte[] bytes = new byte[fileStream.Length];
        //读取文件
        fileStream.Read(bytes, 0, (int)fileStream.Length);
        //释放文件读取liu
        fileStream.Close();
        fileStream.Dispose();
        fileStream = null;
        return bytes;
    }


    /// <summary>
    /// C#按文件夹名称排序（顺序）
    /// </summary>
    /// <param name="dirs"></param>
    private static void OrderSortAsFolderName(ref DirectoryInfo[] dirs)
    {
        Array.Sort(dirs, delegate (DirectoryInfo x, DirectoryInfo y) { return x.Name.CompareTo(y.Name); });
    }
    /// <summary>
    /// C#按文件夹名称排序（倒序）
    /// </summary>
    /// <param name="dirs"></param>
    private static void ReverseSortAsFolderName(ref DirectoryInfo[] dirs)
    {
        Array.Sort(dirs, delegate (DirectoryInfo x, DirectoryInfo y) { return y.Name.CompareTo(x.Name); });
    }
    /// <summary>
    /// C#按文件夹夹创建时间排序（顺序）
    /// </summary>
    /// <param name="dirs"></param>
    private static void OrderSortAsFolderCreationTime(ref DirectoryInfo[] dirs)
    {
        Array.Sort(dirs, delegate (DirectoryInfo x, DirectoryInfo y) { return x.CreationTime.CompareTo(y.CreationTime); });
    }

    /// <summary>
    /// C#按文件夹创建时间排序（倒序）
    /// </summary>
    /// <param name="dirs"></param>
    private static void ReverseSortAsFolderCreationTime(ref DirectoryInfo[] dirs)
    {
        Array.Sort(dirs, delegate (DirectoryInfo x, DirectoryInfo y) { return y.CreationTime.CompareTo(x.CreationTime); });
    }

    /// <summary>
    /// C#按文件夹修改时间排序（顺序）
    /// </summary>
    /// <param name="dirs"></param>
    private static void OrderSortAsFolderLastWriteTime(ref DirectoryInfo[] dirs)
    {
        Array.Sort(dirs, delegate (DirectoryInfo x, DirectoryInfo y) { return x.CreationTime.CompareTo(y.LastWriteTime); });
    }

    /// <summary>
    /// C#按文件夹修改时间排序（倒序）
    /// </summary>
    /// <param name="dirs"></param>
    private static void ReverseSortAsFolderLastWriteTime(ref DirectoryInfo[] dirs)
    {
        Array.Sort(dirs, delegate (DirectoryInfo x, DirectoryInfo y) { return y.CreationTime.CompareTo(x.LastWriteTime); });
    }

    static double  unit = 1024;
    /// <summary>
    /// 因为C#提供的文件的大小是以B为单位的，所以显示文件大小的时候会出现一大串数字很不方便
    /// 所以，该函数为了方便地显示文件大小而出现
    /// 函数说明，
    ///     如果文件大小是0-1024B 以内的   显示以B为单位
    ///     如果文件大小是1KB-1024KB之间的 显示以KB为单位
    ///     如果文件大小是1M-1024M之间的   显示以M为单位
    ///     如果文件大小是1024M以上的      显示以GB为单位
    /// </summary>
    /// <param name="lengthOfDocument"> 文件的大小 单位：B 类型：long</param>
    /// <returns></returns>
    public static string GetLength(long lengthOfDocument)
    {

        if (lengthOfDocument < unit)
            return string.Format(lengthOfDocument.ToString("f2") + 'B');
        else if (lengthOfDocument > unit && lengthOfDocument <= Math.Pow(unit, 2))
            return string.Format((lengthOfDocument / unit).ToString("f2") + "KB");
        else if (lengthOfDocument > Math.Pow(unit, 2) && lengthOfDocument <= Math.Pow(unit, 3))
            return string.Format((lengthOfDocument / unit / unit).ToString("f2") + "MB");
        else
            return string.Format((lengthOfDocument / unit / unit / unit).ToString("f2") + "GB");
    }

    /// <summary>该函数为了方便地显示数量格式化而出现
    /// 函数说明，
    ///     如果文件大小是0-1000 以内的   直接显示
    ///     如果文件大小是1K-1000K之间的 显示以K为单位
    ///     如果文件大小是1M-1000M之间的   显示以M为单位
    ///     如果文件大小是1000M以上的      显示以B为单位
    /// </summary>
    /// <param name="lengthOfDocument"> ：1 类型：long</param>
    /// <returns></returns>
    public static string GetNumFormat(long lengthOfDocument)
    {

        if (lengthOfDocument < 1000)
            return string.Format(lengthOfDocument.ToString());
        else if (lengthOfDocument >= 1000 && lengthOfDocument < Math.Pow(1000, 2))
        {
            return string.Format((lengthOfDocument / 1000).ToString() + "K");

        }
            
        else if (lengthOfDocument >= Math.Pow(1000, 2) && lengthOfDocument < Math.Pow(1000, 3))
            return string.Format((lengthOfDocument / 1000 / 1000).ToString() + "M");
        else
            return string.Format((lengthOfDocument / 1000 / 1000 / 1000).ToString() + "B");
    }


    public static string GetVideoTime(long time)
    {
        string timeStr;
        if (time < 60)
        {
            timeStr = string.Format("00:{0:00}", time % 60);
        }
        else if (time < 3600)
        {
            timeStr = string.Format("{0}:", time / 60) + string.Format("{0}", time % 60);
        }
        else
        {
            timeStr = string.Format("{0}:", time / 3600) + string.Format("{0}:", (time % 3600) / 60) /*+ string.Format("{0}", time % 60)*/;
        }
        return timeStr;
    }

    public static string formatLongToTimeStr(long l)
    {
      //  Debug.Log("");
        String str = "";
        int hour = 0;
        int minute = 0;
        int second = 0;
        second = (int)l / 1000;

        if (second > 60)
        {
            minute = second / 60;
            second = second % 60;
        }
        if (minute > 60)
        {
            hour = minute / 60;
            minute = minute % 60;
        }
        return (hour+ ":" + minute+ ":"
            + second );
    }

    // 时间戳 转换为时间
    public static string StampToDateTime(string timeStamp)
    {
        DateTime startTime = System.TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));//获取时间戳
        DateTime dt = startTime.AddSeconds(double.Parse(timeStamp));
        return dt.ToString("yyyy/MM/dd");//转化为日期时间
    }


}