com.soviby.unity.ui.ugui-toolkit/Assets/Editor/Helper/ImageUtils.cs

#if UNITY_EDITOR

using OpenCVForUnity.CoreModule;
using OpenCVForUnity.Features2dModule;
using OpenCVForUnity.ImgprocModule;
using OpenCVForUnity.Calib3dModule;
using OpenCVForUnity.UnityUtils;
using System;
using System.IO;
using System.Collections.Generic;
using UnityEngine;
using OpenCVForUnity.ImgcodecsModule;
using System.Threading.Tasks;
using UguiToolkit.Editor;
using System.Security.Cryptography;
using System.Text;

public static class ImageUtils
{
    public static void SetDebugMode(bool debug)
    {
        Utils.setDebugMode(debug);
    }

    public static string FormatImgFilePath(string imgFilePath)
    {
        string projectPath = Directory.GetParent(Application.dataPath).FullName;
        return Path.GetRelativePath(projectPath, imgFilePath).Replace("\\", "/");
    }

    public static void LoadPngImagesFromFolder(string folderPath, List<Mat> images, List<string> imagePaths, Func<string, bool> filterCallback)
    {
        foreach (string filePath in Directory.GetFiles(folderPath, "*.png"))
        {
            if (filterCallback(filePath)) continue;

            Mat img = Imgcodecs.imread(filePath, Imgcodecs.IMREAD_UNCHANGED);
            if (!img.empty())
            {
                images.Add(img);
                imagePaths.Add(FormatImgFilePath(filePath));
            }
        }
    }

    #region SliceTexture

    static List<int> hashListOfSlice;

    static int ToHashCode(in Color color)
    {
        int a = Mathf.RoundToInt(color.a * 255);
        if (a == 0) return 0;

        int r = Mathf.RoundToInt(color.r * 255);
        int g = Mathf.RoundToInt(color.g * 255);
        int b = Mathf.RoundToInt(color.b * 255);

        return (a << 24) + (r << 16) + (g << 8) + b;
    }

    static (int, int) CalcLine(List<int> hashList)
    {
        int start = 0, end = 0;
        int tmpStart = 0, tmpEnd = 0;
        int tmpHash = hashList[0];

        for (int i = 0; i < hashList.Count; i++)
        {
            if (tmpHash == hashList[i])
            {
                tmpEnd = i;
            }
            else
            {
                if (end - start < tmpEnd - tmpStart)
                {
                    start = tmpStart;
                    end = tmpEnd;
                }
                tmpStart = i;
                tmpEnd = i;
                tmpHash = hashList[i];
            }
        }

        if (end - start < tmpEnd - tmpStart)
        {
            start = tmpStart;
            end = tmpEnd;
        }

        return (start, end);
    }

    static List<int> CreateHashList(Mat image, in char axis)
    {
        if (hashListOfSlice == null) hashListOfSlice = new ();
        var hashList = hashListOfSlice;
        hashList.Clear();

        if (axis == 'x')
        {
            for (int i = 0; i < image.cols(); i++)
            {
                int hash = 0;
                for (int j = 0; j < image.rows(); j++)
                {
                    double[] color = image.get(j, i);
                    hash += ToHashCode(new Color((float)color[2] / 255, (float)color[1] / 255, (float)color[0] / 255, (float)color[3] / 255));
                }
                hashList.Add(hash);
            }
        }
        else
        {
            for (int j = 0; j < image.rows(); j++)
            {
                int hash = 0;
                for (int i = 0; i < image.cols(); i++)
                {
                    double[] color = image.get(j, i);
                    hash += ToHashCode(new Color((float)color[2] / 255, (float)color[1] / 255, (float)color[0] / 255, (float)color[3] / 255));
                }
                hashList.Add(hash);
            }
        }

        return hashList;
    }

    public static void SliceTexture(string imagePath, string outputPath)
    {
        var mat = SliceTexture(imagePath);
        Imgcodecs.imwrite(outputPath, mat, new MatOfInt(Imgcodecs.IMWRITE_PNG_COMPRESSION, 9));
    }

    public static Mat SliceTexture(string imagePath)
    {
        Mat image = Imgcodecs.imread(imagePath, Imgcodecs.IMREAD_UNCHANGED);  // ʹ<><CAB9>OpenCV<43><56><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>

        int width = image.cols();
        int height = image.rows();

        List<int> hashListX = CreateHashList(image, 'x');
        (int xStart, int xEnd) = CalcLine(hashListX);

        List<int> hashListY = CreateHashList(image, 'y');
        (int yStart, int yEnd) = CalcLine(hashListY);

        int outputWidth = width - (xEnd - xStart);
        int outputHeight = height - (yEnd - yStart);

        var outputMat = new Mat(outputHeight, outputWidth, CvType.CV_8UC4);
        for (int x = 0; x < outputWidth; x++)
        {
            int originalX = x < xStart ? x : x + (xEnd - xStart);
            for (int y = 0; y < outputHeight; y++)
            {
                int originalY = y < yStart ? y : y + (yEnd - yStart);
                double[] color = image.get(originalY, originalX);
                outputMat.put(y, x, color);
            }
        }

        return outputMat;
    }
    #endregion

    static List<Task<(double?, (double, double)?)>> tasks;
    static ObjectPool<RotationScaleDetector> detectorPool;

    public static async Task ProcessFolderAsync(List<Mat> images, string targetFilePath, 
        double distanceDifference, Action<int, (double, (double, double), bool)> callback,
        Action endCallback, bool isSliceTexture = false)
    {
        if (tasks == null) tasks = new (images.Count);
        if (detectorPool == null) detectorPool = new (images.Count);

        Mat targetImage = null;
        if (isSliceTexture)
        {
            targetImage = SliceTexture(targetFilePath);
        }
        else {
            targetImage = Imgcodecs.imread(targetFilePath, Imgcodecs.IMREAD_UNCHANGED);
        }

        List<RotationScaleDetector> detectors = new(images.Count);
        tasks.Clear();
        foreach (var img in images)
        {
            RotationScaleDetector detector = detectorPool.GetObject();
            tasks.Add(detector.GetRotationScaleAsync(targetImage, img, distanceDifference));
            detectors.Add(detector);
        }

        var resultsTask = await Task.WhenAll(tasks.ToArray());
        foreach (var detector in detectors) detectorPool.ReturnObject(detector);

        for (int index = 0; index < resultsTask.Length; index++)
        {
            int _index = index;
            var result = resultsTask[index];
            UnityMainThreadDispatcher.Instance().Enqueue(() =>
            {
                if (result.Item1.HasValue)
                {
                    double rotationAngleDegrees = result.Item1.Value;
                    double scaleX = 0;
                    double scaleY = 0;

                    if (result.Item2.HasValue)
                    {
                        var scale = result.Item2.Value;
                        scaleX = scale.Item1;
                        scaleY = scale.Item2;

                        callback(_index, (rotationAngleDegrees, (scaleX, scaleY), false));
                    }
                    else
                    { // SimilarityCalc
                        callback(_index, (rotationAngleDegrees, (scaleX, scaleY), true));
                    }

                    Debug.Log($"Target Image -> Image {_index}");
                    Debug.Log($"Rotation Angle: {rotationAngleDegrees} degrees");
                    Debug.Log($"Scale X: {scaleX}");
                    Debug.Log($"Scale Y: {scaleY}");
                    Debug.Log($"SimilarityCalc : {result.Item2 == null}");
                }
            });
        }

        UnityMainThreadDispatcher.Instance().Enqueue(() =>
        {
            endCallback();
        });
    }
}

public class RotationScaleDetector
{
    private SIFT sift;
    private BFMatcher bf;
    private Mat gray;
    private Mat descriptors1;
    private Mat descriptors2;
    private MatOfKeyPoint keypoints;
    private Mat inliers;
    private List<MatOfDMatch> knnMatches;
    private List<DMatch> goodMatches;
    private List<Point> srcPts;
    private List<Point> dstPts;
    private Mat resizedImage;
    private Mat dctImage;
    StringBuilder sb;

    public RotationScaleDetector()
    {
        sift = SIFT.create();
        bf = BFMatcher.create();
        gray = new Mat();
        descriptors1 = new Mat();
        descriptors2 = new Mat();
        keypoints = new MatOfKeyPoint();
        inliers = new Mat();
        knnMatches = new List<MatOfDMatch>();
        goodMatches = new List<DMatch>();
        srcPts = new List<Point>();
        dstPts = new List<Point>();
        resizedImage = new Mat();
        dctImage = new Mat();
        sb = new StringBuilder();
    }

    private KeyPoint[] Sift(Mat image, Mat descriptors)
    {
        Imgproc.cvtColor(image, gray, Imgproc.COLOR_BGR2GRAY);
        sift.detectAndCompute(gray, new Mat(), keypoints, descriptors);
        return keypoints.toArray();
    }

    #region MD5
    public string CalculateMD5(Mat image)
    {
        // <20><>Matת<74><D7AA>Ϊ<EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD><EFBFBD><EFBFBD>
        byte[] imageBytes = new byte[image.total() * image.elemSize()];
        image.get(0, 0, imageBytes);

        // <20><><EFBFBD><EFBFBD>MD5<44><35>ϣ<EFBFBD>㷨ʵ<E3B7A8><CAB5>
        using (MD5 md5 = MD5.Create())
        {
            // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣֵ
            byte[] hashBytes = md5.ComputeHash(imageBytes);

            // <20><><EFBFBD><EFBFBD>ϣ<EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊʮ<CEAA><CAAE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD>
            sb.Clear();
            foreach (byte b in hashBytes)
            {
                sb.Append(b.ToString("x2"));
            }

            return sb.ToString();
        }
    }
    #endregion

    #region Phash
    private Mat CalculatePhash(Mat image)
    {
        Imgproc.cvtColor(image, gray, Imgproc.COLOR_BGR2GRAY);
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>СΪ32x32<33><32><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊ32λ<32><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        Imgproc.resize(gray, resizedImage, new Size(32, 32), 0, 0, Imgproc.INTER_AREA);
        resizedImage.convertTo(resizedImage, CvType.CV_32F);
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɢ<EFBFBD><C9A2><EFBFBD>ұ任<D2B1><E4BBBB>DCT<43><54>
        Core.dct(resizedImage, dctImage);
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С
        if (dctImage.rows() < 8 || dctImage.cols() < 8)
        {
            Debug.LogError("DCT matrix is too small!");
            return new Mat();
        }
        // ȡ<><C8A1><EFBFBD>Ͻ<EFBFBD>8x8<78><38>DCTϵ<54><CFB5>
        Mat dctLowFreq = dctImage.submat(new OpenCVForUnity.CoreModule.Rect(0, 0, 8, 8));
        // <20><>DCTϵ<54><CFB5>ת<EFBFBD><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>
        float[] dctArray = new float[64];
        dctLowFreq.get(0, 0, dctArray);
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
        float medianValue = GetMedian(dctArray);
        // <20><><EFBFBD><EFBFBD>pHash
        Mat phash = new Mat(dctLowFreq.size(), CvType.CV_8U);
        for (int i = 0; i < dctLowFreq.rows(); i++)
        {
            for (int j = 0; j < dctLowFreq.cols(); j++)
            {
                phash.put(i, j, dctLowFreq.get(i, j)[0] > medianValue ? 1 : 0);
            }
        }
        return phash;
    }

    private float GetMedian(float[] array)
    {
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        System.Array.Sort(array);
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
        int middle = array.Length / 2;
        if (array.Length % 2 == 0)
        {
            return (array[middle - 1] + array[middle]) / 2.0f;
        }
        else
        {
            return array[middle];
        }
    }

    private bool IsPhashValid(Mat phash)
    {
        // <20><><EFBFBD><EFBFBD>pHash<73><68>Ϊ1<CEAA><31>λ<EFBFBD><CEBB>
        return Core.countNonZero(phash) >= 13;
    }

    private int CalculateHammingDistance(Mat phash1, Mat phash2)
    {
        if (phash1.rows() != phash2.rows() || phash1.cols() != phash2.cols())
        {
            Debug.LogError("pHash sizes do not match!");
            return -1;
        }

        int hammingDistance = 0;
        for (int i = 0; i < phash1.rows(); i++)
        {
            for (int j = 0; j < phash1.cols(); j++)
            {
                if (phash1.get(i, j)[0] != phash2.get(i, j)[0])
                {
                    hammingDistance++;
                }
            }
        }

        return hammingDistance;
    }

    #endregion

    public async Task<(double?, (double, double)?)> GetRotationScaleAsync(Mat img0, Mat img1, double distanceDifference)
    {
        return await Task.Run<(double?, (double, double)?)>(() => {
            try
            {
                string md5Hash0 = CalculateMD5(img0);
                string md5Hash1 = CalculateMD5(img1);
                if (md5Hash0 == md5Hash1)
                {
                    return (0, null);
                }

                Mat phash1 = CalculatePhash(img0);
                Mat phash2 = CalculatePhash(img1);

                if (IsPhashValid(phash1) && IsPhashValid(phash2) && CalculateHammingDistance(phash1, phash2) < 10)
                {
                    return (0, null);
                }

                KeyPoint[] kp1 = Sift(img0, descriptors1);
                KeyPoint[] kp2 = Sift(img1, descriptors2);

                if (kp1.Length == 0 || kp2.Length == 0)
                {
                    return (null, null);
                }

                knnMatches.Clear();
                goodMatches.Clear();
                bf.knnMatch(descriptors1, descriptors2, knnMatches, 2);

                foreach (MatOfDMatch matofDMatch in knnMatches)
                {
                    DMatch[] matches = matofDMatch.toArray();
                    if (matches[0].distance < distanceDifference * matches[1].distance)
                    {
                        goodMatches.Add(matches[0]);
                    }
                }

                if (goodMatches.Count < 3)
                {
                    return (null, null);
                }

                srcPts.Clear();
                dstPts.Clear();
                foreach (DMatch match in goodMatches)
                {
                    srcPts.Add(kp1[match.queryIdx].pt);
                    dstPts.Add(kp2[match.trainIdx].pt);
                }

                MatOfPoint2f srcMatOfPoint2f = new MatOfPoint2f(srcPts.ToArray());
                MatOfPoint2f dstMatOfPoint2f = new MatOfPoint2f(dstPts.ToArray());

                Mat M = Calib3d.estimateAffinePartial2D(srcMatOfPoint2f, dstMatOfPoint2f, inliers, Calib3d.RANSAC, 5);
                if (M.empty())
                {
                    return (null, null);
                }

                Mat R = M.colRange(0, 2);
                double theta = Math.Atan2(R.get(1, 0)[0], R.get(0, 0)[0]);
                double rotationAngleDegrees = theta * 180.0 / Math.PI;

                double scaleX = Core.norm(R.row(0));
                double scaleY = Core.norm(R.row(1));

                return (rotationAngleDegrees, (scaleX, scaleY));
            }
            catch (Exception e)
            { 
                Debug.LogException(e);

                return (null, null);
            }
        });
    }
}

#endif