using System;
using TriangleNet.Data;
using TriangleNet.Geometry;

namespace TriangleNet.Tools
{
	// Token: 0x0200001A RID: 26
	public class Statistic
	{
		// Token: 0x1700002F RID: 47
		// (get) Token: 0x060000DD RID: 221 RVA: 0x00013E9D File Offset: 0x0001209D
		public double ShortestEdge
		{
			get
			{
				return this.minEdge;
			}
		}

		// Token: 0x17000030 RID: 48
		// (get) Token: 0x060000DE RID: 222 RVA: 0x00013EA5 File Offset: 0x000120A5
		public double LongestEdge
		{
			get
			{
				return this.maxEdge;
			}
		}

		// Token: 0x17000031 RID: 49
		// (get) Token: 0x060000DF RID: 223 RVA: 0x00013EAD File Offset: 0x000120AD
		public double ShortestAltitude
		{
			get
			{
				return this.minAspect;
			}
		}

		// Token: 0x17000032 RID: 50
		// (get) Token: 0x060000E0 RID: 224 RVA: 0x00013EB5 File Offset: 0x000120B5
		public double LargestAspectRatio
		{
			get
			{
				return this.maxAspect;
			}
		}

		// Token: 0x17000033 RID: 51
		// (get) Token: 0x060000E1 RID: 225 RVA: 0x00013EBD File Offset: 0x000120BD
		public double SmallestArea
		{
			get
			{
				return this.minArea;
			}
		}

		// Token: 0x17000034 RID: 52
		// (get) Token: 0x060000E2 RID: 226 RVA: 0x00013EC5 File Offset: 0x000120C5
		public double LargestArea
		{
			get
			{
				return this.maxArea;
			}
		}

		// Token: 0x17000035 RID: 53
		// (get) Token: 0x060000E3 RID: 227 RVA: 0x00013ECD File Offset: 0x000120CD
		public double SmallestAngle
		{
			get
			{
				return this.minAngle;
			}
		}

		// Token: 0x17000036 RID: 54
		// (get) Token: 0x060000E4 RID: 228 RVA: 0x00013ED5 File Offset: 0x000120D5
		public double LargestAngle
		{
			get
			{
				return this.maxAngle;
			}
		}

		// Token: 0x17000037 RID: 55
		// (get) Token: 0x060000E5 RID: 229 RVA: 0x00013EDD File Offset: 0x000120DD
		public int InputVertices
		{
			get
			{
				return this.inVetrices;
			}
		}

		// Token: 0x17000038 RID: 56
		// (get) Token: 0x060000E6 RID: 230 RVA: 0x00013EE5 File Offset: 0x000120E5
		public int InputTriangles
		{
			get
			{
				return this.inTriangles;
			}
		}

		// Token: 0x17000039 RID: 57
		// (get) Token: 0x060000E7 RID: 231 RVA: 0x00013EED File Offset: 0x000120ED
		public int InputSegments
		{
			get
			{
				return this.inSegments;
			}
		}

		// Token: 0x1700003A RID: 58
		// (get) Token: 0x060000E8 RID: 232 RVA: 0x00013EF5 File Offset: 0x000120F5
		public int InputHoles
		{
			get
			{
				return this.inHoles;
			}
		}

		// Token: 0x1700003B RID: 59
		// (get) Token: 0x060000E9 RID: 233 RVA: 0x00013EFD File Offset: 0x000120FD
		public int Vertices
		{
			get
			{
				return this.outVertices;
			}
		}

		// Token: 0x1700003C RID: 60
		// (get) Token: 0x060000EA RID: 234 RVA: 0x00013F05 File Offset: 0x00012105
		public int Triangles
		{
			get
			{
				return this.outTriangles;
			}
		}

		// Token: 0x1700003D RID: 61
		// (get) Token: 0x060000EB RID: 235 RVA: 0x00013F0D File Offset: 0x0001210D
		public int Edges
		{
			get
			{
				return this.outEdges;
			}
		}

		// Token: 0x1700003E RID: 62
		// (get) Token: 0x060000EC RID: 236 RVA: 0x00013F15 File Offset: 0x00012115
		public int BoundaryEdges
		{
			get
			{
				return this.boundaryEdges;
			}
		}

		// Token: 0x1700003F RID: 63
		// (get) Token: 0x060000ED RID: 237 RVA: 0x00013F1D File Offset: 0x0001211D
		public int InteriorBoundaryEdges
		{
			get
			{
				return this.intBoundaryEdges;
			}
		}

		// Token: 0x17000040 RID: 64
		// (get) Token: 0x060000EE RID: 238 RVA: 0x00013F25 File Offset: 0x00012125
		public int ConstrainedEdges
		{
			get
			{
				return this.constrainedEdges;
			}
		}

		// Token: 0x17000041 RID: 65
		// (get) Token: 0x060000EF RID: 239 RVA: 0x00013F2D File Offset: 0x0001212D
		public int[] AngleHistogram
		{
			get
			{
				return this.angleTable;
			}
		}

		// Token: 0x17000042 RID: 66
		// (get) Token: 0x060000F0 RID: 240 RVA: 0x00013F35 File Offset: 0x00012135
		public int[] MinAngleHistogram
		{
			get
			{
				return this.minAngles;
			}
		}

		// Token: 0x17000043 RID: 67
		// (get) Token: 0x060000F1 RID: 241 RVA: 0x00013F3D File Offset: 0x0001213D
		public int[] MaxAngleHistogram
		{
			get
			{
				return this.maxAngles;
			}
		}

		// Token: 0x060000F2 RID: 242 RVA: 0x00013F48 File Offset: 0x00012148
		private void GetAspectHistogram(Mesh mesh)
		{
			int[] array = new int[16];
			double[] array2 = new double[]
			{
				1.5, 2.0, 2.5, 3.0, 4.0, 6.0, 10.0, 15.0, 25.0, 50.0,
				100.0, 300.0, 1000.0, 10000.0, 100000.0, 0.0
			};
			Otri otri = default(Otri);
			Vertex[] array3 = new Vertex[3];
			double[] array4 = new double[3];
			double[] array5 = new double[3];
			double[] array6 = new double[3];
			otri.orient = 0;
			foreach (Triangle triangle in mesh.triangles.Values)
			{
				otri.triangle = triangle;
				array3[0] = otri.Org();
				array3[1] = otri.Dest();
				array3[2] = otri.Apex();
				double num = 0.0;
				for (int i = 0; i < 3; i++)
				{
					int num2 = Statistic.plus1Mod3[i];
					int num3 = Statistic.minus1Mod3[i];
					array4[i] = array3[num2].x - array3[num3].x;
					array5[i] = array3[num2].y - array3[num3].y;
					array6[i] = array4[i] * array4[i] + array5[i] * array5[i];
					if (array6[i] > num)
					{
						num = array6[i];
					}
				}
				double num4 = Math.Abs((array3[2].x - array3[0].x) * (array3[1].y - array3[0].y) - (array3[1].x - array3[0].x) * (array3[2].y - array3[0].y)) / 2.0;
				double num5 = num4 * num4 / num;
				double num6 = num / num5;
				int num7 = 0;
				while (num6 > array2[num7] * array2[num7] && num7 < 15)
				{
					num7++;
				}
				array[num7]++;
			}
		}

		// Token: 0x060000F3 RID: 243 RVA: 0x00014138 File Offset: 0x00012338
		public void Update(Mesh mesh, int sampleDegrees)
		{
			this.inVetrices = mesh.invertices;
			this.inTriangles = mesh.inelements;
			this.inSegments = mesh.insegments;
			this.inHoles = mesh.holes.Count;
			this.outVertices = mesh.vertices.Count - mesh.undeads;
			this.outTriangles = mesh.triangles.Count;
			this.outEdges = mesh.edges;
			this.boundaryEdges = mesh.hullsize;
			this.intBoundaryEdges = mesh.subsegs.Count - mesh.hullsize;
			this.constrainedEdges = mesh.subsegs.Count;
			Point[] array = new Point[3];
			sampleDegrees = 60;
			double[] array2 = new double[sampleDegrees / 2 - 1];
			double[] array3 = new double[3];
			double[] array4 = new double[3];
			double[] array5 = new double[3];
			double num = 3.141592653589793 / (double)sampleDegrees;
			double num2 = 57.29577951308232;
			this.angleTable = new int[sampleDegrees];
			this.minAngles = new int[sampleDegrees];
			this.maxAngles = new int[sampleDegrees];
			for (int i = 0; i < sampleDegrees / 2 - 1; i++)
			{
				array2[i] = Math.Cos(num * (double)(i + 1));
				array2[i] *= array2[i];
			}
			for (int j = 0; j < sampleDegrees; j++)
			{
				this.angleTable[j] = 0;
			}
			this.minAspect = mesh.bounds.Width + mesh.bounds.Height;
			this.minAspect *= this.minAspect;
			this.maxAspect = 0.0;
			this.minEdge = this.minAspect;
			this.maxEdge = 0.0;
			this.minArea = this.minAspect;
			this.maxArea = 0.0;
			this.minAngle = 0.0;
			this.maxAngle = 2.0;
			bool flag = true;
			bool flag2 = true;
			foreach (Triangle triangle in mesh.triangles.Values)
			{
				double num3 = 0.0;
				double num4 = 1.0;
				array[0] = triangle.vertices[0];
				array[1] = triangle.vertices[1];
				array[2] = triangle.vertices[2];
				double num5 = 0.0;
				for (int k = 0; k < 3; k++)
				{
					int num6 = Statistic.plus1Mod3[k];
					int num7 = Statistic.minus1Mod3[k];
					array3[k] = array[num6].X - array[num7].X;
					array4[k] = array[num6].Y - array[num7].Y;
					array5[k] = array3[k] * array3[k] + array4[k] * array4[k];
					if (array5[k] > num5)
					{
						num5 = array5[k];
					}
					if (array5[k] > this.maxEdge)
					{
						this.maxEdge = array5[k];
					}
					if (array5[k] < this.minEdge)
					{
						this.minEdge = array5[k];
					}
				}
				double num8 = Math.Abs((array[2].X - array[0].X) * (array[1].Y - array[0].Y) - (array[1].X - array[0].X) * (array[2].Y - array[0].Y));
				if (num8 < this.minArea)
				{
					this.minArea = num8;
				}
				if (num8 > this.maxArea)
				{
					this.maxArea = num8;
				}
				double num9 = num8 * num8 / num5;
				if (num9 < this.minAspect)
				{
					this.minAspect = num9;
				}
				double num10 = num5 / num9;
				if (num10 > this.maxAspect)
				{
					this.maxAspect = num10;
				}
				int num13;
				for (int l = 0; l < 3; l++)
				{
					int num6 = Statistic.plus1Mod3[l];
					int num7 = Statistic.minus1Mod3[l];
					double num11 = array3[num6] * array3[num7] + array4[num6] * array4[num7];
					double num12 = num11 * num11 / (array5[num6] * array5[num7]);
					num13 = sampleDegrees / 2 - 1;
					for (int m = num13 - 1; m >= 0; m--)
					{
						if (num12 > array2[m])
						{
							num13 = m;
						}
					}
					if (num11 <= 0.0)
					{
						this.angleTable[num13]++;
						if (num12 > this.minAngle)
						{
							this.minAngle = num12;
						}
						if (flag && num12 < this.maxAngle)
						{
							this.maxAngle = num12;
						}
						if (num12 > num3)
						{
							num3 = num12;
						}
						if (flag2 && num12 < num4)
						{
							num4 = num12;
						}
					}
					else
					{
						this.angleTable[sampleDegrees - num13 - 1]++;
						if (flag || num12 > this.maxAngle)
						{
							this.maxAngle = num12;
							flag = false;
						}
						if (flag2 || num12 > num4)
						{
							num4 = num12;
							flag2 = false;
						}
					}
				}
				num13 = sampleDegrees / 2 - 1;
				for (int n = num13 - 1; n >= 0; n--)
				{
					if (num3 > array2[n])
					{
						num13 = n;
					}
				}
				this.minAngles[num13]++;
				num13 = sampleDegrees / 2 - 1;
				for (int num14 = num13 - 1; num14 >= 0; num14--)
				{
					if (num4 > array2[num14])
					{
						num13 = num14;
					}
				}
				if (flag2)
				{
					this.maxAngles[num13]++;
				}
				else
				{
					this.maxAngles[sampleDegrees - num13 - 1]++;
				}
				flag2 = true;
			}
			this.minEdge = Math.Sqrt(this.minEdge);
			this.maxEdge = Math.Sqrt(this.maxEdge);
			this.minAspect = Math.Sqrt(this.minAspect);
			this.maxAspect = Math.Sqrt(this.maxAspect);
			this.minArea *= 0.5;
			this.maxArea *= 0.5;
			if (this.minAngle >= 1.0)
			{
				this.minAngle = 0.0;
			}
			else
			{
				this.minAngle = num2 * Math.Acos(Math.Sqrt(this.minAngle));
			}
			if (this.maxAngle >= 1.0)
			{
				this.maxAngle = 180.0;
				return;
			}
			if (flag)
			{
				this.maxAngle = num2 * Math.Acos(Math.Sqrt(this.maxAngle));
				return;
			}
			this.maxAngle = 180.0 - num2 * Math.Acos(Math.Sqrt(this.maxAngle));
		}

		// Token: 0x060000F5 RID: 245 RVA: 0x000147E0 File Offset: 0x000129E0
		// Note: this type is marked as 'beforefieldinit'.
		static Statistic()
		{
			int[] array = new int[3];
			array[0] = 1;
			array[1] = 2;
			Statistic.plus1Mod3 = array;
			Statistic.minus1Mod3 = new int[] { 2, 0, 1 };
		}

		// Token: 0x040000A9 RID: 169
		public static long InCircleCount = 0L;

		// Token: 0x040000AA RID: 170
		public static long InCircleAdaptCount = 0L;

		// Token: 0x040000AB RID: 171
		public static long CounterClockwiseCount = 0L;

		// Token: 0x040000AC RID: 172
		public static long CounterClockwiseAdaptCount = 0L;

		// Token: 0x040000AD RID: 173
		public static long Orient3dCount = 0L;

		// Token: 0x040000AE RID: 174
		public static long HyperbolaCount = 0L;

		// Token: 0x040000AF RID: 175
		public static long CircumcenterCount = 0L;

		// Token: 0x040000B0 RID: 176
		public static long CircleTopCount = 0L;

		// Token: 0x040000B1 RID: 177
		public static long RelocationCount = 0L;

		// Token: 0x040000B2 RID: 178
		private double minEdge;

		// Token: 0x040000B3 RID: 179
		private double maxEdge;

		// Token: 0x040000B4 RID: 180
		private double minAspect;

		// Token: 0x040000B5 RID: 181
		private double maxAspect;

		// Token: 0x040000B6 RID: 182
		private double minArea;

		// Token: 0x040000B7 RID: 183
		private double maxArea;

		// Token: 0x040000B8 RID: 184
		private double minAngle;

		// Token: 0x040000B9 RID: 185
		private double maxAngle;

		// Token: 0x040000BA RID: 186
		private int inVetrices;

		// Token: 0x040000BB RID: 187
		private int inTriangles;

		// Token: 0x040000BC RID: 188
		private int inSegments;

		// Token: 0x040000BD RID: 189
		private int inHoles;

		// Token: 0x040000BE RID: 190
		private int outVertices;

		// Token: 0x040000BF RID: 191
		private int outTriangles;

		// Token: 0x040000C0 RID: 192
		private int outEdges;

		// Token: 0x040000C1 RID: 193
		private int boundaryEdges;

		// Token: 0x040000C2 RID: 194
		private int intBoundaryEdges;

		// Token: 0x040000C3 RID: 195
		private int constrainedEdges;

		// Token: 0x040000C4 RID: 196
		private int[] angleTable;

		// Token: 0x040000C5 RID: 197
		private int[] minAngles;

		// Token: 0x040000C6 RID: 198
		private int[] maxAngles;

		// Token: 0x040000C7 RID: 199
		private static readonly int[] plus1Mod3;

		// Token: 0x040000C8 RID: 200
		private static readonly int[] minus1Mod3;
	}
}