using OpenCvSharp;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PaintDotNet.DedicatedAnalysis.GrainSizeStandard.IntegrationClass
{
    public class Class12
    {
        public void ImgThin(Mat src, int maxIterations = -1)
        {
            Cv2.Threshold(src, src, 100.0, 1.0, ThresholdTypes.Binary);
            int rows = src.Rows;
            int cols = src.Cols;
            int num = 0;
            while (true)
            {
                num++;
                if (maxIterations != -1 && num > maxIterations)
                {
                    break;
                }

                List<int[]> list = new List<int[]>();
                for (int i = 0; i < rows; i++)
                {
                    for (int j = 0; j < cols; j++)
                    {
                        src.At<byte>(i, j);
                        int num2 = (i != 0) ? src.At<byte>(i - 1, j) : 0;
                        int num3 = (i != 0 && j != cols - 1) ? src.At<byte>(i - 1, j + 1) : 0;
                        int num4 = (j != cols - 1) ? src.At<byte>(i, j + 1) : 0;
                        int num5 = (i != rows - 1 && j != cols - 1) ? src.At<byte>(i + 1, j + 1) : 0;
                        int num6 = (i != rows - 1) ? src.At<byte>(i + 1, j) : 0;
                        int num7 = (i != rows - 1 && j != 0) ? src.At<byte>(i + 1, j - 1) : 0;
                        int num8 = (j != 0) ? src.At<byte>(i, j - 1) : 0;
                        int num9 = (i != 0 && j != 0) ? src.At<byte>(i - 1, j - 1) : 0;
                        if (num2 + num3 + num4 + num5 + num6 + num7 + num8 + num9 >= 2 && num2 + num3 + num4 + num5 + num6 + num7 + num8 + num9 <= 6)
                        {
                            int num10 = 0;
                            if (num2 == 0 && num3 == 1)
                            {
                                num10++;
                            }

                            if (num3 == 0 && num4 == 1)
                            {
                                num10++;
                            }

                            if (num4 == 0 && num5 == 1)
                            {
                                num10++;
                            }

                            if (num5 == 0 && num6 == 1)
                            {
                                num10++;
                            }

                            if (num6 == 0 && num7 == 1)
                            {
                                num10++;
                            }

                            if (num7 == 0 && num8 == 1)
                            {
                                num10++;
                            }

                            if (num8 == 0 && num9 == 1)
                            {
                                num10++;
                            }

                            if (num9 == 0 && num2 == 1)
                            {
                                num10++;
                            }

                            if (num10 == 1 && num2 * num4 * num6 == 0 && num4 * num6 * num8 == 0)
                            {
                                list.Add(new int[2]
                                {
                                    i,
                                    j
                                });
                            }
                        }
                    }
                }

                list.ForEach(delegate (int[] aiP)
                {
                    src.Set(aiP, (byte)0);
                });
                if (list.Count() == 0)
                {
                    break;
                }

                list.Clear();
                for (int k = 0; k < rows; k++)
                {
                    for (int l = 0; l < cols; l++)
                    {
                        int num11 = src.At<byte>(k, l);
                        if (num11 != 1)
                        {
                            continue;
                        }

                        int num12 = (k != 0) ? src.At<byte>(k - 1, l) : 0;
                        int num13 = (k != 0 && l != cols - 1) ? src.At<byte>(k - 1, l + 1) : 0;
                        int num14 = (l != cols - 1) ? src.At<byte>(k, l + 1) : 0;
                        int num15 = (k != rows - 1 && l != cols - 1) ? src.At<byte>(k + 1, l + 1) : 0;
                        int num16 = (k != rows - 1) ? src.At<byte>(k + 1, l) : 0;
                        int num17 = (k != rows - 1 && l != 0) ? src.At<byte>(k + 1, l - 1) : 0;
                        int num18 = (l != 0) ? src.At<byte>(k, l - 1) : 0;
                        int num19 = (k != 0 && l != 0) ? src.At<byte>(k - 1, l - 1) : 0;
                        if (num12 + num13 + num14 + num15 + num16 + num17 + num18 + num19 >= 2 && num12 + num13 + num14 + num15 + num16 + num17 + num18 + num19 <= 6)
                        {
                            int num20 = 0;
                            if (num12 == 0 && num13 == 1)
                            {
                                num20++;
                            }

                            if (num13 == 0 && num14 == 1)
                            {
                                num20++;
                            }

                            if (num14 == 0 && num15 == 1)
                            {
                                num20++;
                            }

                            if (num15 == 0 && num16 == 1)
                            {
                                num20++;
                            }

                            if (num16 == 0 && num17 == 1)
                            {
                                num20++;
                            }

                            if (num17 == 0 && num18 == 1)
                            {
                                num20++;
                            }

                            if (num18 == 0 && num19 == 1)
                            {
                                num20++;
                            }

                            if (num19 == 0 && num12 == 1)
                            {
                                num20++;
                            }

                            if (num20 == 1 && num12 * num14 * num18 == 0 && num12 * num16 * num18 == 0)
                            {
                                list.Add(new int[2]
                                {
                                    k,
                                    l
                                });
                            }
                        }
                    }
                }

                list.ForEach(delegate (int[] aiP)
                {
                    src.Set(aiP, (byte)0);
                });
                if (list.Count() == 0)
                {
                    break;
                }

                list.Clear();
            }

            Cv2.Threshold(src, src, 0.0, 255.0, ThresholdTypes.Binary);
        }

        public void ConnectionBoundary(Mat Img, int iDistance)
        {
            Cv2.Threshold(Img, Img, 100.0, 1.0, ThresholdTypes.Binary);
            Mat mat = Connectivity(Img);
            List<int[]> list = new List<int[]>();
            List<int[]> list2 = new List<int[]>();
            int[] array = new int[2]
            {
                1,
                0
            };
            while (array[0] < Img.Rows - 1)
            {
                array[1] = 1;
                while (array[1] < Img.Cols - 1)
                {
                    if (1 <= Img.At<byte>(array[0], array[1]) && mat.At<byte>(array[0], array[1]) == 0)
                    {
                        Img.Set(array, (byte)0);
                    }

                    if (1 <= Img.At<byte>(array[0], array[1]) && 1 == mat.At<byte>(array[0], array[1]))
                    {
                        list.Add(new int[2]
                        {
                            array[0],
                            array[1]
                        });
                        int num = 0;
                        int i = 0;
                        for (num = -1; num <= 1; num++)
                        {
                            bool flag = false;
                            for (i = -1; i <= 1; i++)
                            {
                                if ((num != 0 || i != 0) && Img.At<byte>(array[0] + num, array[1] + i) >= 1)
                                {
                                    flag = true;
                                    break;
                                }
                            }

                            if (flag)
                            {
                                break;
                            }
                        }

                        list2.Add(new int[2]
                        {
                            -num,
                            -i
                        });
                    }

                    array[1]++;
                }

                array[0]++;
            }

            int num2 = list.Count();
            List<int[]>[] array2 = new List<int[]>[num2];
            List<int> list3 = new List<int>();
            List<int> list4 = new List<int>();
            for (int j = 0; j < num2; j++)
            {
                list3.Add(j);
                int[] array3 = list[j];
                array2[j] = new List<int[]>();
                array2[j].Add(new int[2]
                {
                    array3[0],
                    array3[1]
                });
            }

            Mat mat2 = new Mat(Img.Size(), MatType.CV_32SC1);
            array[0] = 0;
            while (array[0] < Img.Rows)
            {
                array[1] = 0;
                while (array[1] < Img.Cols)
                {
                    int value = Img.At<byte>(array[0], array[1]);
                    mat2.Set(array, value);
                    array[1]++;
                }

                array[0]++;
            }

            int[,] array4 = new int[260, 2]
            {
                {
                    -1,
                    0
                },
                {
                    0,
                    1
                },
                {
                    1,
                    0
                },
                {
                    0,
                    1
                },
                {
                    -1,
                    1
                },
                {
                    1,
                    1
                },
                {
                    1,
                    -1
                },
                {
                    -1,
                    -1
                },
                {
                    -2,
                    0
                },
                {
                    0,
                    2
                },
                {
                    2,
                    0
                },
                {
                    0,
                    -2
                },
                {
                    -2,
                    1
                },
                {
                    -1,
                    2
                },
                {
                    1,
                    2
                },
                {
                    2,
                    1
                },
                {
                    2,
                    -1
                },
                {
                    1,
                    -2
                },
                {
                    -1,
                    -2
                },
                {
                    -2,
                    -1
                },
                {
                    -2,
                    2
                },
                {
                    2,
                    2
                },
                {
                    2,
                    -2
                },
                {
                    -2,
                    -2
                },
                {
                    -3,
                    0
                },
                {
                    0,
                    3
                },
                {
                    3,
                    0
                },
                {
                    0,
                    -3
                },
                {
                    -3,
                    1
                },
                {
                    -1,
                    3
                },
                {
                    1,
                    3
                },
                {
                    3,
                    1
                },
                {
                    3,
                    -1
                },
                {
                    1,
                    -3
                },
                {
                    -1,
                    -3
                },
                {
                    -3,
                    -1
                },
                {
                    2,
                    3
                },
                {
                    -3,
                    2
                },
                {
                    -2,
                    -3
                },
                {
                    -2,
                    3
                },
                {
                    -3,
                    -2
                },
                {
                    3,
                    2
                },
                {
                    3,
                    -2
                },
                {
                    2,
                    -3
                },
                {
                    4,
                    0
                },
                {
                    0,
                    4
                },
                {
                    -4,
                    0
                },
                {
                    0,
                    -4
                },
                {
                    1,
                    4
                },
                {
                    4,
                    -1
                },
                {
                    4,
                    1
                },
                {
                    -1,
                    -4
                },
                {
                    -4,
                    1
                },
                {
                    -4,
                    -1
                },
                {
                    -1,
                    4
                },
                {
                    1,
                    -4
                },
                {
                    3,
                    3
                },
                {
                    3,
                    -3
                },
                {
                    -3,
                    3
                },
                {
                    -3,
                    -3
                },
                {
                    -4,
                    -2
                },
                {
                    -2,
                    -4
                },
                {
                    -4,
                    2
                },
                {
                    4,
                    2
                },
                {
                    -2,
                    4
                },
                {
                    4,
                    -2
                },
                {
                    2,
                    -4
                },
                {
                    2,
                    4
                },
                {
                    4,
                    -3
                },
                {
                    -3,
                    4
                },
                {
                    4,
                    3
                },
                {
                    5,
                    0
                },
                {
                    0,
                    5
                },
                {
                    0,
                    -5
                },
                {
                    -5,
                    0
                },
                {
                    3,
                    4
                },
                {
                    -3,
                    -4
                },
                {
                    -4,
                    -3
                },
                {
                    3,
                    -4
                },
                {
                    -4,
                    3
                },
                {
                    5,
                    -1
                },
                {
                    -1,
                    5
                },
                {
                    -1,
                    -5
                },
                {
                    5,
                    1
                },
                {
                    1,
                    -5
                },
                {
                    -5,
                    1
                },
                {
                    -5,
                    -1
                },
                {
                    1,
                    5
                },
                {
                    -2,
                    5
                },
                {
                    2,
                    -5
                },
                {
                    2,
                    5
                },
                {
                    5,
                    2
                },
                {
                    -5,
                    2
                },
                {
                    -2,
                    -5
                },
                {
                    5,
                    -2
                },
                {
                    -5,
                    -2
                },
                {
                    -4,
                    4
                },
                {
                    4,
                    -4
                },
                {
                    4,
                    4
                },
                {
                    -4,
                    -4
                },
                {
                    3,
                    -5
                },
                {
                    -5,
                    3
                },
                {
                    -3,
                    5
                },
                {
                    5,
                    -3
                },
                {
                    5,
                    3
                },
                {
                    -5,
                    -3
                },
                {
                    -3,
                    -5
                },
                {
                    3,
                    5
                },
                {
                    0,
                    6
                },
                {
                    0,
                    -6
                },
                {
                    -6,
                    0
                },
                {
                    6,
                    0
                },
                {
                    -6,
                    1
                },
                {
                    1,
                    6
                },
                {
                    -6,
                    -1
                },
                {
                    1,
                    -6
                },
                {
                    -1,
                    6
                },
                {
                    -1,
                    -6
                },
                {
                    6,
                    -1
                },
                {
                    6,
                    1
                },
                {
                    2,
                    6
                },
                {
                    -2,
                    -6
                },
                {
                    6,
                    2
                },
                {
                    -6,
                    2
                },
                {
                    2,
                    -6
                },
                {
                    -6,
                    -2
                },
                {
                    -2,
                    6
                },
                {
                    6,
                    -2
                },
                {
                    -5,
                    -4
                },
                {
                    5,
                    4
                },
                {
                    4,
                    5
                },
                {
                    -4,
                    5
                },
                {
                    4,
                    -5
                },
                {
                    -5,
                    4
                },
                {
                    5,
                    -4
                },
                {
                    -4,
                    -5
                },
                {
                    -3,
                    6
                },
                {
                    -6,
                    3
                },
                {
                    -3,
                    -6
                },
                {
                    -6,
                    -3
                },
                {
                    3,
                    -6
                },
                {
                    6,
                    3
                },
                {
                    3,
                    6
                },
                {
                    6,
                    -3
                },
                {
                    0,
                    7
                },
                {
                    7,
                    0
                },
                {
                    0,
                    -7
                },
                {
                    -7,
                    0
                },
                {
                    5,
                    -5
                },
                {
                    1,
                    7
                },
                {
                    -1,
                    7
                },
                {
                    -5,
                    -5
                },
                {
                    -7,
                    -1
                },
                {
                    -7,
                    1
                },
                {
                    -1,
                    -7
                },
                {
                    1,
                    -7
                },
                {
                    7,
                    1
                },
                {
                    -5,
                    5
                },
                {
                    5,
                    5
                },
                {
                    7,
                    -1
                },
                {
                    6,
                    4
                },
                {
                    -6,
                    4
                },
                {
                    6,
                    -4
                },
                {
                    -6,
                    -4
                },
                {
                    -4,
                    -6
                },
                {
                    4,
                    6
                },
                {
                    4,
                    -6
                },
                {
                    -4,
                    6
                },
                {
                    7,
                    -2
                },
                {
                    7,
                    2
                },
                {
                    2,
                    7
                },
                {
                    -7,
                    -2
                },
                {
                    -2,
                    -7
                },
                {
                    -2,
                    7
                },
                {
                    2,
                    -7
                },
                {
                    -7,
                    2
                },
                {
                    7,
                    -3
                },
                {
                    -3,
                    7
                },
                {
                    -3,
                    -7
                },
                {
                    3,
                    -7
                },
                {
                    -7,
                    3
                },
                {
                    3,
                    7
                },
                {
                    7,
                    3
                },
                {
                    -7,
                    -3
                },
                {
                    6,
                    -5
                },
                {
                    5,
                    6
                },
                {
                    5,
                    -6
                },
                {
                    6,
                    5
                },
                {
                    -5,
                    6
                },
                {
                    -5,
                    -6
                },
                {
                    -6,
                    5
                },
                {
                    -6,
                    -5
                },
                {
                    8,
                    0
                },
                {
                    0,
                    -8
                },
                {
                    -8,
                    0
                },
                {
                    0,
                    8
                },
                {
                    -4,
                    7
                },
                {
                    4,
                    -7
                },
                {
                    -8,
                    -1
                },
                {
                    -1,
                    8
                },
                {
                    -7,
                    4
                },
                {
                    -1,
                    -8
                },
                {
                    7,
                    4
                },
                {
                    1,
                    -8
                },
                {
                    1,
                    8
                },
                {
                    8,
                    1
                },
                {
                    8,
                    -1
                },
                {
                    -4,
                    -7
                },
                {
                    -7,
                    -4
                },
                {
                    7,
                    -4
                },
                {
                    -8,
                    1
                },
                {
                    4,
                    7
                },
                {
                    -2,
                    8
                },
                {
                    2,
                    -8
                },
                {
                    -2,
                    -8
                },
                {
                    8,
                    2
                },
                {
                    -8,
                    2
                },
                {
                    -8,
                    -2
                },
                {
                    2,
                    8
                },
                {
                    8,
                    -2
                },
                {
                    -6,
                    6
                },
                {
                    6,
                    6
                },
                {
                    6,
                    -6
                },
                {
                    -6,
                    -6
                },
                {
                    3,
                    -8
                },
                {
                    -3,
                    8
                },
                {
                    8,
                    3
                },
                {
                    8,
                    -3
                },
                {
                    3,
                    8
                },
                {
                    -3,
                    -8
                },
                {
                    -8,
                    3
                },
                {
                    -8,
                    -3
                },
                {
                    7,
                    -5
                },
                {
                    -7,
                    -5
                },
                {
                    5,
                    7
                },
                {
                    7,
                    5
                },
                {
                    5,
                    -7
                },
                {
                    -7,
                    5
                },
                {
                    -5,
                    -7
                },
                {
                    -5,
                    7
                },
                {
                    8,
                    -4
                },
                {
                    -4,
                    -8
                },
                {
                    -8,
                    -4
                },
                {
                    8,
                    4
                },
                {
                    4,
                    8
                },
                {
                    -8,
                    4
                },
                {
                    4,
                    -8
                },
                {
                    -4,
                    8
                },
                {
                    0,
                    -9
                },
                {
                    0,
                    9
                },
                {
                    -9,
                    0
                },
                {
                    9,
                    0
                },
                {
                    9,
                    -1
                },
                {
                    -9,
                    -1
                },
                {
                    1,
                    -9
                },
                {
                    -1,
                    9
                },
                {
                    -1,
                    -9
                },
                {
                    -9,
                    1
                },
                {
                    1,
                    9
                },
                {
                    9,
                    1
                }
            };
            while (list3.Count() != 0)
            {
                int num3 = list3[0];
                list3.RemoveAt(0);
                int index = array2[num3].Count() - 1;
                int[] array5 = array2[num3][index];
                int[] pnt = new int[2]
                {
                    array5[0],
                    array5[1]
                };
                int[] array6 = list2[num3];
                bool flag2 = false;
                for (int k = 0; k < iDistance; k++)
                {
                    if (0 > array6[0] * array4[k, 0] || 0 > array6[1] * array4[k, 1])
                    {
                        continue;
                    }

                    pnt[0] = array5[0] + array4[k, 0];
                    pnt[1] = array5[1] + array4[k, 1];
                    if (0 > pnt[0] || Img.Rows <= pnt[0] || 0 > pnt[1] || Img.Cols <= pnt[1])
                    {
                        continue;
                    }

                    int num4 = mat2.At<int>(pnt[0], pnt[1]);
                    if (1 < num4 && num3 != num4)
                    {
                        list3.Remove(num4);
                        if (!list4.Contains(num4))
                        {
                            int num5 = array2[num4].FindIndex((int[] t) => t[0] == pnt[0] && t[1] == pnt[1]);
                            int num6 = array2[num4].Count() - 1;
                            if (1 <= num6 - num5)
                            {
                                for (int l = num5 + 1; l <= num6; l++)
                                {
                                    mat2.Set(array2[num4][l], 0);
                                }

                                array2[num4].RemoveRange(num5 + 1, num6 - num5);
                            }

                            list4.Add(num4);
                            list4.Add(num3);
                        }

                        ConnectTwoPnt(array5, pnt, array2[num3]);
                        flag2 = true;
                        break;
                    }

                    if (1 == num4)
                    {
                        ConnectTwoPnt(array5, pnt, array2[num3]);
                        flag2 = true;
                        break;
                    }
                }

                if (!flag2)
                {
                    pnt[0] = array5[0] + array6[0];
                    pnt[1] = array5[1] + array6[1];
                    if (0 <= pnt[0] && Img.Rows > pnt[0] && 0 <= pnt[1] && Img.Cols > pnt[1])
                    {
                        array2[num3].Add(pnt);
                        mat2.Set(pnt, num3);
                        list3.Add(num3);
                    }
                }
            }

            for (int m = 0; m < num2; m++)
            {
                array2[m].ForEach(delegate (int[] aiP)
                {
                    Img.Set(aiP, (byte)1);
                });
            }

            Cv2.Threshold(Img, Img, 0.0, 255.0, ThresholdTypes.Binary);
        }

        public void ConnectTwoPnt(int[] pntA, int[] pntB, List<int[]> DevelopmentA)
        {
            int num = pntA[0];
            int num2 = pntA[1];
            int num3 = pntB[0] - num;
            int num4 = pntB[1] - num2;
            int num5 = (num3 != 0) ? (num3 / Math.Abs(num3)) : 0;
            int num6 = (num4 != 0) ? (num4 / Math.Abs(num4)) : 0;
            while (num3 != 0 || num4 != 0)
            {
                if (Math.Abs(num3) > Math.Abs(num4))
                {
                    num += num5;
                }
                else
                {
                    num2 += num6;
                }

                DevelopmentA.Add(new int[2]
                {
                    num,
                    num2
                });
                num3 = pntB[0] - num;
                num4 = pntB[1] - num2;
            }
        }

        public Mat Connectivity(Mat Img)
        {
            Mat mat = new Mat(Img.Size(), MatType.CV_8UC1);
            int[] array = new int[2]
            {
                1,
                0
            };
            while (array[0] < Img.Rows - 1)
            {
                array[1] = 0;
                while (array[1] < Img.Cols)
                {
                    byte b = Img.At<byte>(array[0] - 1, array[1]);
                    b = (byte)(b + Img.At<byte>(array[0], array[1]));
                    b = (byte)(b + Img.At<byte>(array[0] + 1, array[1]));
                    mat.Set(array, b);
                    array[1]++;
                }

                array[0]++;
            }

            Mat mat2 = new Mat(Img.Size(), MatType.CV_8UC1);
            array[0] = 1;
            while (array[0] < Img.Rows - 1)
            {
                array[1] = 1;
                while (array[1] < Img.Cols - 1)
                {
                    byte b2 = mat.At<byte>(array[0], array[1] - 1);
                    b2 = (byte)(b2 + mat.At<byte>(array[0], array[1]));
                    b2 = (byte)(b2 + mat.At<byte>(array[0], array[1] + 1));
                    b2 = (byte)(b2 - Img.At<byte>(array[0], array[1]));
                    mat2.Set(array, b2);
                    array[1]++;
                }

                array[0]++;
            }

            mat = null;
            return mat2;
        }
    }
}