niko
409 lines
9.3 KiB
C#
409 lines
9.3 KiB
C#
using System;
|
|
using TriangleNet.Data;
|
|
using TriangleNet.Geometry;
|
|
|
|
namespace TriangleNet.Tools
|
|
{
|
|
// Token: 0x02000018 RID: 24
|
|
public class QualityMeasure
|
|
{
|
|
// Token: 0x060000CA RID: 202 RVA: 0x000139C2 File Offset: 0x00011BC2
|
|
public QualityMeasure()
|
|
{
|
|
this.areaMeasure = new QualityMeasure.AreaMeasure();
|
|
this.alphaMeasure = new QualityMeasure.AlphaMeasure();
|
|
this.qMeasure = new QualityMeasure.Q_Measure();
|
|
}
|
|
|
|
// Token: 0x17000024 RID: 36
|
|
// (get) Token: 0x060000CB RID: 203 RVA: 0x000139EB File Offset: 0x00011BEB
|
|
public double AreaMinimum
|
|
{
|
|
get
|
|
{
|
|
return this.areaMeasure.area_min;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000025 RID: 37
|
|
// (get) Token: 0x060000CC RID: 204 RVA: 0x000139F8 File Offset: 0x00011BF8
|
|
public double AreaMaximum
|
|
{
|
|
get
|
|
{
|
|
return this.areaMeasure.area_max;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000026 RID: 38
|
|
// (get) Token: 0x060000CD RID: 205 RVA: 0x00013A05 File Offset: 0x00011C05
|
|
public double AreaRatio
|
|
{
|
|
get
|
|
{
|
|
return this.areaMeasure.area_max / this.areaMeasure.area_min;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000027 RID: 39
|
|
// (get) Token: 0x060000CE RID: 206 RVA: 0x00013A1E File Offset: 0x00011C1E
|
|
public double AlphaMinimum
|
|
{
|
|
get
|
|
{
|
|
return this.alphaMeasure.alpha_min;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000028 RID: 40
|
|
// (get) Token: 0x060000CF RID: 207 RVA: 0x00013A2B File Offset: 0x00011C2B
|
|
public double AlphaMaximum
|
|
{
|
|
get
|
|
{
|
|
return this.alphaMeasure.alpha_max;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000029 RID: 41
|
|
// (get) Token: 0x060000D0 RID: 208 RVA: 0x00013A38 File Offset: 0x00011C38
|
|
public double AlphaAverage
|
|
{
|
|
get
|
|
{
|
|
return this.alphaMeasure.alpha_ave;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002A RID: 42
|
|
// (get) Token: 0x060000D1 RID: 209 RVA: 0x00013A45 File Offset: 0x00011C45
|
|
public double AlphaArea
|
|
{
|
|
get
|
|
{
|
|
return this.alphaMeasure.alpha_area;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002B RID: 43
|
|
// (get) Token: 0x060000D2 RID: 210 RVA: 0x00013A52 File Offset: 0x00011C52
|
|
public double Q_Minimum
|
|
{
|
|
get
|
|
{
|
|
return this.qMeasure.q_min;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002C RID: 44
|
|
// (get) Token: 0x060000D3 RID: 211 RVA: 0x00013A5F File Offset: 0x00011C5F
|
|
public double Q_Maximum
|
|
{
|
|
get
|
|
{
|
|
return this.qMeasure.q_max;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002D RID: 45
|
|
// (get) Token: 0x060000D4 RID: 212 RVA: 0x00013A6C File Offset: 0x00011C6C
|
|
public double Q_Average
|
|
{
|
|
get
|
|
{
|
|
return this.qMeasure.q_ave;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700002E RID: 46
|
|
// (get) Token: 0x060000D5 RID: 213 RVA: 0x00013A79 File Offset: 0x00011C79
|
|
public double Q_Area
|
|
{
|
|
get
|
|
{
|
|
return this.qMeasure.q_area;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060000D6 RID: 214 RVA: 0x00013A86 File Offset: 0x00011C86
|
|
public void Update(Mesh mesh)
|
|
{
|
|
this.mesh = mesh;
|
|
this.areaMeasure.Reset();
|
|
this.alphaMeasure.Reset();
|
|
this.qMeasure.Reset();
|
|
this.Compute();
|
|
}
|
|
|
|
// Token: 0x060000D7 RID: 215 RVA: 0x00013AB8 File Offset: 0x00011CB8
|
|
private void Compute()
|
|
{
|
|
int num = 0;
|
|
foreach (Triangle triangle in this.mesh.triangles.Values)
|
|
{
|
|
num++;
|
|
Point point = triangle.vertices[0];
|
|
Point point2 = triangle.vertices[1];
|
|
Point point3 = triangle.vertices[2];
|
|
double num2 = point.x - point2.x;
|
|
double num3 = point.y - point2.y;
|
|
double num4 = Math.Sqrt(num2 * num2 + num3 * num3);
|
|
double num5 = point2.x - point3.x;
|
|
num3 = point2.y - point3.y;
|
|
double num6 = Math.Sqrt(num5 * num5 + num3 * num3);
|
|
double num7 = point3.x - point.x;
|
|
num3 = point3.y - point.y;
|
|
double num8 = Math.Sqrt(num7 * num7 + num3 * num3);
|
|
double num9 = this.areaMeasure.Measure(point, point2, point3);
|
|
this.alphaMeasure.Measure(num4, num6, num8, num9);
|
|
this.qMeasure.Measure(num4, num6, num8, num9);
|
|
}
|
|
this.alphaMeasure.Normalize(num, this.areaMeasure.area_total);
|
|
this.qMeasure.Normalize(num, this.areaMeasure.area_total);
|
|
}
|
|
|
|
// Token: 0x060000D8 RID: 216 RVA: 0x00013C20 File Offset: 0x00011E20
|
|
public int Bandwidth()
|
|
{
|
|
if (this.mesh == null)
|
|
{
|
|
return 0;
|
|
}
|
|
int num = 0;
|
|
int num2 = 0;
|
|
foreach (Triangle triangle in this.mesh.triangles.Values)
|
|
{
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
int id = triangle.GetVertex(i).id;
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
int id2 = triangle.GetVertex(j).id;
|
|
num2 = Math.Max(num2, id2 - id);
|
|
num = Math.Max(num, id - id2);
|
|
}
|
|
}
|
|
}
|
|
return num + 1 + num2;
|
|
}
|
|
|
|
// Token: 0x040000A3 RID: 163
|
|
private QualityMeasure.AreaMeasure areaMeasure;
|
|
|
|
// Token: 0x040000A4 RID: 164
|
|
private QualityMeasure.AlphaMeasure alphaMeasure;
|
|
|
|
// Token: 0x040000A5 RID: 165
|
|
private QualityMeasure.Q_Measure qMeasure;
|
|
|
|
// Token: 0x040000A6 RID: 166
|
|
private Mesh mesh;
|
|
|
|
// Token: 0x02000041 RID: 65
|
|
private class AreaMeasure
|
|
{
|
|
// Token: 0x06000246 RID: 582 RVA: 0x0001B9BC File Offset: 0x00019BBC
|
|
public void Reset()
|
|
{
|
|
this.area_min = double.MaxValue;
|
|
this.area_max = double.MinValue;
|
|
this.area_total = 0.0;
|
|
this.area_zero = 0;
|
|
}
|
|
|
|
// Token: 0x06000247 RID: 583 RVA: 0x0001B9F4 File Offset: 0x00019BF4
|
|
public double Measure(Point a, Point b, Point c)
|
|
{
|
|
double num = 0.5 * Math.Abs(a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
|
|
this.area_min = Math.Min(this.area_min, num);
|
|
this.area_max = Math.Max(this.area_max, num);
|
|
this.area_total += num;
|
|
if (num == 0.0)
|
|
{
|
|
this.area_zero++;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0400013D RID: 317
|
|
public double area_min = double.MaxValue;
|
|
|
|
// Token: 0x0400013E RID: 318
|
|
public double area_max = double.MinValue;
|
|
|
|
// Token: 0x0400013F RID: 319
|
|
public double area_total;
|
|
|
|
// Token: 0x04000140 RID: 320
|
|
public int area_zero;
|
|
}
|
|
|
|
// Token: 0x02000042 RID: 66
|
|
private class AlphaMeasure
|
|
{
|
|
// Token: 0x06000249 RID: 585 RVA: 0x0001BAC2 File Offset: 0x00019CC2
|
|
public void Reset()
|
|
{
|
|
this.alpha_min = double.MaxValue;
|
|
this.alpha_max = double.MinValue;
|
|
this.alpha_ave = 0.0;
|
|
this.alpha_area = 0.0;
|
|
}
|
|
|
|
// Token: 0x0600024A RID: 586 RVA: 0x0001BB00 File Offset: 0x00019D00
|
|
private double acos(double c)
|
|
{
|
|
if (c <= -1.0)
|
|
{
|
|
return 3.141592653589793;
|
|
}
|
|
if (1.0 <= c)
|
|
{
|
|
return 0.0;
|
|
}
|
|
return Math.Acos(c);
|
|
}
|
|
|
|
// Token: 0x0600024B RID: 587 RVA: 0x0001BB34 File Offset: 0x00019D34
|
|
public double Measure(double ab, double bc, double ca, double area)
|
|
{
|
|
double num = double.MaxValue;
|
|
double num2 = ab * ab;
|
|
double num3 = bc * bc;
|
|
double num4 = ca * ca;
|
|
double num5;
|
|
double num6;
|
|
double num7;
|
|
if (ab == 0.0 && bc == 0.0 && ca == 0.0)
|
|
{
|
|
num5 = 2.0943951023931953;
|
|
num6 = 2.0943951023931953;
|
|
num7 = 2.0943951023931953;
|
|
}
|
|
else
|
|
{
|
|
if (ca == 0.0 || ab == 0.0)
|
|
{
|
|
num5 = 3.141592653589793;
|
|
}
|
|
else
|
|
{
|
|
num5 = this.acos((num4 + num2 - num3) / (2.0 * ca * ab));
|
|
}
|
|
if (ab == 0.0 || bc == 0.0)
|
|
{
|
|
num6 = 3.141592653589793;
|
|
}
|
|
else
|
|
{
|
|
num6 = this.acos((num2 + num3 - num4) / (2.0 * ab * bc));
|
|
}
|
|
if (bc == 0.0 || ca == 0.0)
|
|
{
|
|
num7 = 3.141592653589793;
|
|
}
|
|
else
|
|
{
|
|
num7 = this.acos((num3 + num4 - num2) / (2.0 * bc * ca));
|
|
}
|
|
}
|
|
num = Math.Min(num, num5);
|
|
num = Math.Min(num, num6);
|
|
num = Math.Min(num, num7);
|
|
num = num * 3.0 / 3.141592653589793;
|
|
this.alpha_ave += num;
|
|
this.alpha_area += area * num;
|
|
this.alpha_min = Math.Min(num, this.alpha_min);
|
|
this.alpha_max = Math.Max(num, this.alpha_max);
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x0600024C RID: 588 RVA: 0x0001BCD8 File Offset: 0x00019ED8
|
|
public void Normalize(int n, double area_total)
|
|
{
|
|
if (n > 0)
|
|
{
|
|
this.alpha_ave /= (double)n;
|
|
}
|
|
else
|
|
{
|
|
this.alpha_ave = 0.0;
|
|
}
|
|
if (0.0 < area_total)
|
|
{
|
|
this.alpha_area /= area_total;
|
|
return;
|
|
}
|
|
this.alpha_area = 0.0;
|
|
}
|
|
|
|
// Token: 0x04000141 RID: 321
|
|
public double alpha_min;
|
|
|
|
// Token: 0x04000142 RID: 322
|
|
public double alpha_max;
|
|
|
|
// Token: 0x04000143 RID: 323
|
|
public double alpha_ave;
|
|
|
|
// Token: 0x04000144 RID: 324
|
|
public double alpha_area;
|
|
}
|
|
|
|
// Token: 0x02000043 RID: 67
|
|
private class Q_Measure
|
|
{
|
|
// Token: 0x0600024E RID: 590 RVA: 0x0001BD33 File Offset: 0x00019F33
|
|
public void Reset()
|
|
{
|
|
this.q_min = double.MaxValue;
|
|
this.q_max = double.MinValue;
|
|
this.q_ave = 0.0;
|
|
this.q_area = 0.0;
|
|
}
|
|
|
|
// Token: 0x0600024F RID: 591 RVA: 0x0001BD74 File Offset: 0x00019F74
|
|
public double Measure(double ab, double bc, double ca, double area)
|
|
{
|
|
double num = (bc + ca - ab) * (ca + ab - bc) * (ab + bc - ca) / (ab * bc * ca);
|
|
this.q_min = Math.Min(this.q_min, num);
|
|
this.q_max = Math.Max(this.q_max, num);
|
|
this.q_ave += num;
|
|
this.q_area += num * area;
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000250 RID: 592 RVA: 0x0001BDE0 File Offset: 0x00019FE0
|
|
public void Normalize(int n, double area_total)
|
|
{
|
|
if (n > 0)
|
|
{
|
|
this.q_ave /= (double)n;
|
|
}
|
|
else
|
|
{
|
|
this.q_ave = 0.0;
|
|
}
|
|
if (area_total > 0.0)
|
|
{
|
|
this.q_area /= area_total;
|
|
return;
|
|
}
|
|
this.q_area = 0.0;
|
|
}
|
|
|
|
// Token: 0x04000145 RID: 325
|
|
public double q_min;
|
|
|
|
// Token: 0x04000146 RID: 326
|
|
public double q_max;
|
|
|
|
// Token: 0x04000147 RID: 327
|
|
public double q_ave;
|
|
|
|
// Token: 0x04000148 RID: 328
|
|
public double q_area;
|
|
}
|
|
}
|
|
}
|