private static Sphere GetCircumsphere(Tetrahedron tetra)
{
var p = tetra.p;
float[][] a = new float[][] {
new float[] { p[1].x - p[0].x, p[1].y - p[0].y, p[1].z - p[0].z },
new float[] { p[2].x - p[0].x, p[2].y - p[0].y, p[2].z - p[0].z },
new float[] { p[3].x - p[0].x, p[3].y - p[0].y, p[3].z - p[0].z }
};
float[] b =
{
0.5f * (p[1].x * p[1].x - p[0].x * p[0].x + p[1].y * p[1].y - p[0].y * p[0].y + p[1].z * p[1].z - p[0].z * p[0].z),
0.5f * (p[2].x * p[2].x - p[0].x * p[0].x + p[2].y * p[2].y - p[0].y * p[0].y + p[2].z * p[2].z - p[0].z * p[0].z),
0.5f * (p[3].x * p[3].x - p[0].x * p[0].x + p[3].y * p[3].y - p[0].y * p[0].y + p[3].z * p[3].z - p[0].z * p[0].z)
};
float[] x = { 0f, 0f, 0f };
var det = Gauss(a, b, ref x);
if (det == 0)
{
return(new Sphere(Vector3.zero, -1));
}
else
{
var center = new Vector3(x[0], x[1], x[2]);
return(new Sphere(center, Vector3.Distance(center, p[0])));
}
}
// generate tetrahedralization of hypercube faces
void SetTetrahedrons()
{
for (int i = 0; i < 4; i++)
{
for (int s = -1; s <= 1; s += 2)
{
for (int j = 0; j < 5; j++)
{
Tetrahedron t = new Tetrahedron();
for (int k = 0; k < 4; k++)
{
Vector4 v = new Vector4();
v[i] = s;
for (int l = 0; l < 3; l++)
{
v[(i + l + 1) % 4] = CubeTetrahedralization[j, k][l];
}
t.v[k] = v;
//Debug.LogFormat("{0},{1},{2}:{3}", i, j, k, v);
}
tetrahedrons.Add(t);
}
}
}
}
//protected double[,] GenerateLocalK(Tetrahedron element)
//{
// int lenght = element.Nodes.Count * DEGREES_OF_FREEDOM;
// double[,] k = new double[lenght, lenght];
// Material material = MaterialStorage.Materials.FirstOrDefault(m => m.Id == element.IdMaterial);
// double[] b = new double[DEGREES_OF_FREEDOM + 1];
// double[] c = new double[DEGREES_OF_FREEDOM + 1];
// double[] d = new double[DEGREES_OF_FREEDOM + 1];
// double vol = element.VolumeWithSign();
// double sign = Math.Abs(vol) / vol;
// double G = material.ElasticModulus / (2 * (1 + material.PoissonsRatio));
// double h = material.PoissonsRatio * material.ElasticModulus
// / ((1 + material.PoissonsRatio) * (1 - 2 * material.PoissonsRatio));
// double r = 2 * G + h;
// vol = 1 / (36 * Math.Abs(vol));
// b[0] = -Det(element.Nodes[1].Y, element.Nodes[1].Z, element.Nodes[2].Y, element.Nodes[2].Z, element.Nodes[3].Y, element.Nodes[3].Z) * sign;
// b[1] = Det(element.Nodes[0].Y, element.Nodes[0].Z, element.Nodes[2].Y, element.Nodes[2].Z, element.Nodes[3].Y, element.Nodes[3].Z) * sign;
// b[2] = -Det(element.Nodes[0].Y, element.Nodes[0].Z, element.Nodes[1].Y, element.Nodes[1].Z, element.Nodes[3].Y, element.Nodes[3].Z) * sign;
// b[3] = Det(element.Nodes[0].Y, element.Nodes[0].Z, element.Nodes[1].Y, element.Nodes[1].Z, element.Nodes[2].Y, element.Nodes[2].Z) * sign;
// c[0] = Det(element.Nodes[1].X, element.Nodes[1].Z, element.Nodes[2].X, element.Nodes[2].Z, element.Nodes[3].X, element.Nodes[3].Z) * sign;
// c[1] = -Det(element.Nodes[0].X, element.Nodes[0].Z, element.Nodes[2].X, element.Nodes[2].Z, element.Nodes[3].X, element.Nodes[3].Z) * sign;
// c[2] = Det(element.Nodes[0].X, element.Nodes[0].Z, element.Nodes[1].X, element.Nodes[1].Z, element.Nodes[3].X, element.Nodes[3].Z) * sign;
// c[3] = -Det(element.Nodes[0].X, element.Nodes[0].Z, element.Nodes[1].X, element.Nodes[1].Z, element.Nodes[2].X, element.Nodes[2].Z) * sign;
// d[0] = -Det(element.Nodes[1].X, element.Nodes[1].Y, element.Nodes[2].X, element.Nodes[2].Y, element.Nodes[3].X, element.Nodes[3].Y) * sign;
// d[1] = Det(element.Nodes[0].X, element.Nodes[0].Y, element.Nodes[2].X, element.Nodes[2].Y, element.Nodes[3].X, element.Nodes[3].Y) * sign;
// d[2] = -Det(element.Nodes[0].X, element.Nodes[0].Y, element.Nodes[1].X, element.Nodes[1].Y, element.Nodes[3].X, element.Nodes[3].Y) * sign;
// d[3] = Det(element.Nodes[0].X, element.Nodes[0].Y, element.Nodes[1].X, element.Nodes[1].Y, element.Nodes[2].X, element.Nodes[2].Y) * sign;
// for (int i = 0; i < DEGREES_OF_FREEDOM + 1; i++)
// {
// for (int j = 0; j < DEGREES_OF_FREEDOM + 1; j++)
// {
// k[i * DEGREES_OF_FREEDOM, j * DEGREES_OF_FREEDOM] = b[i] * b[j] * r + (c[i] * c[j] + d[i] * d[j]) * G;
// k[i * DEGREES_OF_FREEDOM, j * DEGREES_OF_FREEDOM + 1] = b[i] * c[j] * h + c[i] * b[j] * G;
// k[i * DEGREES_OF_FREEDOM, j * DEGREES_OF_FREEDOM + 2] = b[i] * d[j] * h + d[i] * b[j] * G;
// k[i * DEGREES_OF_FREEDOM + 1, j * DEGREES_OF_FREEDOM] = c[i] * b[j] * h + b[i] * c[j] * G;
// k[i * DEGREES_OF_FREEDOM + 1, j * DEGREES_OF_FREEDOM + 1] = c[i] * c[j] * r + (b[i] * b[j] + d[i] * d[j]) * G;
// k[i * DEGREES_OF_FREEDOM + 1, j * DEGREES_OF_FREEDOM + 2] = c[i] * d[j] * h + d[i] * c[j] * G;
// k[i * DEGREES_OF_FREEDOM + 2, j * DEGREES_OF_FREEDOM] = d[i] * b[j] * h + b[i] * d[j] * G;
// k[i * DEGREES_OF_FREEDOM + 2, j * DEGREES_OF_FREEDOM + 1] = d[i] * c[j] * h + c[i] * d[j] * G;
// k[i * DEGREES_OF_FREEDOM + 2, j * DEGREES_OF_FREEDOM + 2] = d[i] * d[j] * r + (c[i] * c[j] + b[i] * b[j]) * G;
// }
// }
// k = Multiply(k, vol);
// return k;
//}
protected double[,] GenerateLocalK(Tetrahedron element)
{
int lenght = element.Nodes.Count * DEGREES_OF_FREEDOM;
double[,] k = new double[lenght, lenght];
Material material = MaterialStorage.Materials.FirstOrDefault(m => m.Id == element.IdMaterial);
double[,] E = GenerateE(material.ElasticModulus, material.PoissonsRatio);
double[,] Q = GenerateQ();
double[,] B = GenerateB(element);
double[,] N = Multiply(Q, B);
k = Multiply(Transponate(N), E);
k = Multiply(k, N);
//k = Multiply(Transponate(B), Transponate(Q));
//k = Multiply(k, E);
//k = Multiply(k, Q);
//k = Multiply(k, B);
k = Multiply(k, element.Volume());
//k = Multiply(k, element.VolumeWithSign());
return(k);
}
private void RenderAllInOne()
{
IEnumerator <Tetrahedron> toRender = Triangulation.Tetrahedrons.GetEnumerator();
List <Vector3> vertices = new List <Vector3>();
List <int> triangles = new List <int>();
List <Color> colors = new List <Color>();
int i = 0;
while (toRender.MoveNext())
{
Tetrahedron tetrahedron = toRender.Current;
vertices.AddRange(tetrahedron.Vectors);
colors.AddRange(tetrahedron.Colors);
foreach (int x in tetrahedron.Indices)
{
triangles.Add(x + 4 * i);
}
i++;
}
MeshFilter filter = allMeshes.GetComponent <MeshFilter>();
filter.mesh.vertices = vertices.ToArray();
filter.mesh.triangles = triangles.ToArray();
filter.mesh.colors = colors.ToArray();
}
/// <summary>
/// Returns a random point inside the given tetrahedron.
/// </summary>
public static Vector3D GetRandomPoint(this Tetrahedron tetrahedron, Random random)
{
var s = (float)random.NextDouble();
var t = (float)random.NextDouble();
var u = (float)random.NextDouble();
if (s + t > 1)
{
// Fold the cube into a prism:
s = 1 - s;
t = 1 - t;
}
if (t + u > 1)
{
// Fold the prism into a tetrahedron:
var temp = u;
u = 1 - s - t;
t = 1 - temp;
}
else if (s + t + u > 1)
{
var temp = u;
u = s + t + u - 1;
s = 1 - t - temp;
}
var a = 1 - s - t - u; // (a, s, t, u) are the barycentric coordinates of the random point.
return((tetrahedron.Vertex1 * a) + (tetrahedron.Vertex2 * s) + (tetrahedron.Vertex3 * t) + (tetrahedron.Vertex4 * u));
}
public List <Side> oppositeSide(Tetrahedron tetrahedron, Side side)
{
HashSet <int> sideEndPts = TetraUtil.vertexIDs(side.vertices);
HashSet <int> notSideEndPts = new HashSet <int>();
List <Side> outputSides = new List <Side>();
foreach (Tetrahedron t in tetrahedrons)
{
if (t.type != 2)
{
if (t.sides.Contains(side))
{
HashSet <int> tempSet = TetraUtil.vertexIDs(t.vertices);
notSideEndPts.UnionWith(tempSet.Except(sideEndPts));
}
foreach (Side s in t.sides)
{
HashSet <int> tempSideVtx = TetraUtil.vertexIDs(s.vertices);
tempSideVtx.IntersectWith(notSideEndPts);
if (tempSideVtx.Count == 2)
{
outputSides.Add(s);
}
}
}
}
return(outputSides);
}
private void UpdateTriangulation(Measurement3D measurement, List <Tetrahedron> badTetrahedrons, List <Triangle> polygon)
{
// for each triangle in badTriangles do // remove them from the data structure
foreach (Tetrahedron tetrahedron in badTetrahedrons)
{
// remove triangle from triangulation
Triangulation.Remove(tetrahedron);
}
// for each edge in polygon do // re-triangulate the polygonal hole
foreach (Triangle triangle in polygon)
{
// newTri:= form a triangle from edge to point
// add newTri to triangulation
if (triangle.InSamePlane(measurement))
{
Debug.Log("In same plane");
continue;
}
Tetrahedron tetrahedron = new Tetrahedron(
measurement,
triangle.a,
triangle.b,
triangle.c);
Triangulation.Add(tetrahedron);
}
}
protected double[,] GenerateA(Tetrahedron element)
{
int lenght = element.Nodes.Count * DEGREES_OF_FREEDOM;
double[,] A = new double[lenght, lenght];
for (int i = 0; i < element.Nodes.Count; i++)
{
A[i * 3, 0] = 1.0f;
A[i * 3, 1] = element.Nodes[i].X;
A[i * 3, 2] = element.Nodes[i].Y;
A[i * 3, 3] = element.Nodes[i].Z;
A[i * 3 + 1, 4] = 1.0f;
A[i * 3 + 1, 5] = element.Nodes[i].X;
A[i * 3 + 1, 6] = element.Nodes[i].Y;
A[i * 3 + 1, 7] = element.Nodes[i].Z;
A[i * 3 + 2, 8] = 1.0f;
A[i * 3 + 2, 9] = element.Nodes[i].X;
A[i * 3 + 2, 10] = element.Nodes[i].Y;
A[i * 3 + 2, 11] = element.Nodes[i].Z;
}
return(A);
}
public static ThreeDShape GetThreeDShape()
{
Random random = new Random();
int whichShape = random.Next(1, 4);
if (whichShape == 1)
{
Cube cube = new Cube(random.Next(1, 10));
return(cube);
}
if (whichShape == 2)
{
Sphere sphere = new Sphere(random.Next(1, 10));
return(sphere);
}
Tetrahedron tetrahedron = new Tetrahedron(random.Next(1, 10));
return(tetrahedron);
}
// Use this for initialization
void Start()
{
rend = gameObject.GetComponent<Renderer>();
//mat = new Material(Shader.Find("Standard"));
//rend = new Renderer();
//rend.material = mat;
gMO = GameObject.Find("GameManager");
gM = gMO.GetComponent<GameManager>();
tetrahedron = gameObject.GetComponent<Tetrahedron>();
octahedron = gameObject.GetComponent<Octahedron>();
dodecahedron = gameObject.GetComponent<Dodecahedron>();
icosahedron = gameObject.GetComponent<Icosahedron>();
counter = (int)Random.Range(1f, 5f);
if(counter == 5)
counter = 4;
if(counter == 1)
tetrahedron.MakeMesh();
if(counter == 2)
octahedron.MakeMesh();
if(counter == 3)
dodecahedron.MakeMesh();
if(counter == 4)
icosahedron.MakeMesh();
gM.ZombiePlus();
}
public void ValidTetrahedron()
{
var solid = new Tetrahedron()
{
Size = new SharpDX.Vector3(1.0f, 1.0f, 1.0f)
};
}
public static void tetrahedron_num_test()
//****************************************************************************80
//
// Purpose:
//
// TETRAHEDRON_NUM_TEST tests TETRAHEDRON_NUM.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 23 May 2007
//
// Author:
//
// John Burkardt
//
{
int n;
Console.WriteLine("");
Console.WriteLine("TETRAHEDRON_NUM_TEST");
Console.WriteLine(" TETRAHEDRON_NUM computes the tetrahedron numbers.");
Console.WriteLine("");
for (n = 1; n <= 10; n++)
{
Console.WriteLine(" "
+ n.ToString().PadLeft(4) + " "
+ Tetrahedron.tetrahedron_num(n).ToString().PadLeft(6) + "");
}
}
/*[Input("Size",DefaultValues= new double[] { 1,1,1})]
* IDiffSpread<Vector3> FSize;*/
protected override DX11IndexedGeometry GetGeom(DX11RenderContext context, int slice)
{
Tetrahedron settings = new Tetrahedron();
settings.Size = new Vector3(1, 1, 1);
return(context.Primitives.Tetrahedron(settings));
}
bool IsWithinCircumsphereBounds(Vector3 pos, Tetrahedron tetra)
{
if (Vector3.Distance(pos, tetra.Circumcenter) <= tetra.Circumradius)
{
return(true);
}
return(false);
}
protected override DX11IndexedGeometry GetGeom(DX11RenderContext context, int slice)
{
Tetrahedron settings = new Tetrahedron();
settings.Radius = this.FSize[slice];
return(context.Primitives.Tetrahedron(settings));
}
/// <summary>
/// Returns the volume of the given tetrahedron.
/// </summary>
public static float GetVolume(this Tetrahedron tetrahedron)
{
var a = tetrahedron.Vertex2 - tetrahedron.Vertex1;
var b = tetrahedron.Vertex3 - tetrahedron.Vertex1;
var c = tetrahedron.Vertex4 - tetrahedron.Vertex1;
return(Math.Abs(a.CrossProduct(b).DotProduct(c)) / 6);
}
public void support(int pointIndex_, Tetrahedron tetrahedron_, Vector3 direction_)
{
Vector3 newPoint = tetrahedron_.getFarthestPointInDirection(direction_);
if (pointIndex_ < 4) //Make sure the index isn't more than 4, to assure we only have 4 points
{
pointsList[pointIndex_] = newPoint; //using an array and the pointIndex, we can swap points!
}
}
static void Create()
{
GameObject gameObject = new GameObject("Tetrahedron");
Tetrahedron s = gameObject.AddComponent <Tetrahedron>();
MeshFilter meshFilter = gameObject.GetComponent <MeshFilter>();
meshFilter.mesh = new Mesh();
s.Rebuild();
}
public List <TetraPart> getTetraParts(List <List <int> > fragments,
out List <Tetrahedron> fracTetras,
out List <Plane> fracPlanes)
{
List <TetraPart> tetraParts = new List <TetraPart>();
for (int i = 0; i < fragments.Count; i++)
{
tetraParts.Add(new TetraPart());
}
for (int i = 0; i < nodeIndexOfTetra.Count; i++)
{
if (!damagedNodes.Contains(i))
{
int node = nodeIndexOfTetra[i].a;
for (int j = 0; j < fragments.Count; j++)
{
if (fragments[j].Contains(node))
{
List <Vector3> tetrList = new List <Vector3>();
tetrList.Add(nodes[nodeIndexOfTetra[i].a]);
tetrList.Add(nodes[nodeIndexOfTetra[i].b]);
tetrList.Add(nodes[nodeIndexOfTetra[i].c]);
tetrList.Add(nodes[nodeIndexOfTetra[i].d]);
tetraParts[j].PushBackTetra(tetrList);
break;
}
}
}
}
fracTetras = new List <Tetrahedron>();
fracPlanes = new List <Plane>();
foreach (int i in damagedNodes)
{
Tetrahedron fracTetra = getFractureTetra(i);
Plane fracPlane = getFracturePlane(i);
if (fracPlane.normal.sqrMagnitude > 1e-6)
{
fracTetras.Add(fracTetra);
fracPlanes.Add(fracPlane);
}
else
{
tetraParts[tetraParts.Count - 1].PushBackTetra(new List <Vector3>
{
fracTetra.tetra[0],
fracTetra.tetra[1],
fracTetra.tetra[2],
fracTetra.tetra[3]
});
}
}
return(tetraParts);
}
public static void TetraPost()
{
var t = new Tetrahedron();
//t.Settings.Calculation.MaxDataPoints = 1000000;
t.Settings.Calculation.MaxDataPoints = 10000000;
t.Settings.Calculation.FrameCount = 10;
t.StartRender("tetraAnimPost2");
}
void Start()
{
rotationSpeed = Random.Range(-5f, 5f);
rend = gameObject.GetComponent <Renderer>();
tetrahedron = gameObject.GetComponent <Tetrahedron>();
octahedron = gameObject.GetComponent <Octahedron>();
dodecahedron = gameObject.GetComponent <Dodecahedron>();
icosahedron = gameObject.GetComponent <Icosahedron>();
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
try {
Tetrahedron ___test = new Tetrahedron();
___test.run_test(-1);
} catch(Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
public static void TetraPostNoRepeat()
{
var t = new Tetrahedron();
//t.Settings.Calculation.MaxDataPoints = 1000000;
t.Settings.Calculation.MaxDataPoints = 10000000;
t.Settings.Calculation.FrameCount = 10;
t.Settings.Render.TransparentBackground = false;
t.StartRender("tetraAnimPostNoRepeat2", GameStyle.NoRepeat);
}
void Start()
{
rotationSpeed = Random.Range(-5f, 5f);
rend = gameObject.GetComponent<Renderer>();
tetrahedron = gameObject.GetComponent<Tetrahedron>();
octahedron = gameObject.GetComponent<Octahedron>();
dodecahedron = gameObject.GetComponent<Dodecahedron>();
icosahedron = gameObject.GetComponent<Icosahedron>();
}
static void Main(string[] args)
{
Circle circle = new Circle();
Square square = new Square();
Triangle triangle = new Triangle();
Sphere sphere = new Sphere();
Cube cube = new Cube();
Tetrahedron tetrahedron = new Tetrahedron();
}
// END CUT HERE
// BEGIN CUT HERE
public static void Main()
{
try {
Tetrahedron ___test = new Tetrahedron();
___test.run_test(-1);
} catch (Exception e) {
//Console.WriteLine(e.StackTrace);
Console.WriteLine(e.ToString());
}
}
/// <summary>
/// Generate triangles from tetrahedron sides
/// </summary>
/// <param name="tetrahedron">Tetrahedron</param>
/// <returns>List of triangles</returns>
List <Triangle> TrianglesFromTetrahedrons(Tetrahedron tetrahedron)
{
List <Triangle> result = new List <Triangle>();
for (int i = 0; i < tetrahedron.Nodes.Count; i++)
{
Triangle triangle = new Triangle(tetrahedron.Nodes[i], tetrahedron.Nodes[(i + 1) % 4], tetrahedron.Nodes[(i + 2) % 4]);
result.Add(triangle);
}
return(result);
}
static void Create()
{
GameObject GO = new GameObject("Tetrahedron");
Tetrahedron tetrahedron = GO.AddComponent <Tetrahedron>();
MeshFilter mf = GO.AddComponent <MeshFilter>();
mf.mesh = new Mesh();
MeshRenderer mr = GO.AddComponent <MeshRenderer>();
tetrahedron.Rebuild();
}
private unsafe bool IsTetrahedronPositiveOrder(Vector3[] points, ref Tetrahedron tetrahedron)
{
fixed(Tetrahedron *tetrahedronPointer = &tetrahedron)
{
return(IsTetrahedronPositiveOrder(
ref points[tetrahedronPointer->Vertices[0]],
ref points[tetrahedronPointer->Vertices[1]],
ref points[tetrahedronPointer->Vertices[2]],
ref points[tetrahedronPointer->Vertices[3]]));
}
}
public void TetrahedronRaiseEventsProperly()
{
int count = 0;
var solid = new Tetrahedron()
{
Size = new SharpDX.Vector3(1.0f, 1.0f, 1.0f)
};
solid.PropertyChanged += (s, e) => count++;
solid.Size = new SharpDX.Vector3(2.0f, 0.0f, 0.0f);
Assert.AreEqual <int>(count, 1);
}
private void Initialize(Tetrahedron parent, Vector3 direction)
{
mesh = parent.mesh;
materials = parent.materials;
material = parent.material;
maxRotationSpeed = parent.maxRotationSpeed;
maxDepth = parent.maxDepth;
depth = parent.depth + 1;
childScale = parent.childScale;
transform.parent = parent.transform;
transform.localScale = Vector3.one * childScale;
transform.localPosition = direction * (0.5f + 0.5f * childScale);
}
/// <summary>
/// Adds the super tetrahedron, which encompass every vertices.
/// </summary>
private unsafe void AddSuperTetrahedron()
{
// Compute the bounding box of the primitive
var boundingBox = BoundingBox.Empty;
for (int i = 0; i < vertices.Length; i++)
{
BoundingBox.Merge(ref boundingBox, ref vertices[i], out boundingBox);
}
// Add space for extrapolation
boundingBox.Minimum -= ExtrapolationDistance;
boundingBox.Maximum += ExtrapolationDistance;
// Let's encompass the bounding box (Min:A, Max:B), in this manner (2D example, but same applies in 3D):
// *
// |\
// | \
// *--B
// | |\
// A--*-*
{
// TODO: This might not be enough and we might want to pretend those points are at infinity (see incomplete implementation later)
// http://stackoverflow.com/questions/30741459/bowyer-watson-algorithm-how-to-fill-holes-left-by-removing-triangles-with-sup#answer-36992359
// Store additional vertices in extra space
// Note: we build 3 extra vertices on a plane with normal (1,1,1) to makes computation easier
// As an example, (assuming 2D), if B=(1,1) or (0.5,1.5), we can encompass it with (2,0) and (0,2))
var combinedSize = boundingBox.Extent.X + boundingBox.Extent.Y + boundingBox.Extent.Z;
vertices[vertices.Length - 4] = boundingBox.Minimum - boundingBox.Extent * 1000.0f;
vertices[vertices.Length - 3] = boundingBox.Minimum + Vector3.UnitZ * combinedSize * 1000.0f;
vertices[vertices.Length - 2] = boundingBox.Minimum + Vector3.UnitY * combinedSize * 1000.0f;
vertices[vertices.Length - 1] = boundingBox.Minimum + Vector3.UnitX * combinedSize * 1000.0f;
// Create super tetrahedron
var superTetrahedron = new Tetrahedron();
for (int i = 0; i < 4; ++i)
{
superTetrahedron.Vertices[i] = vertices.Length - 4 + i;
superTetrahedron.Neighbours[i] = -1; // No neighbour
}
if (!IsTetrahedronPositiveOrder(vertices, ref superTetrahedron))
{
throw new InvalidOperationException("Tetrahedron not in positive order");
}
tetrahedralization.Add(superTetrahedron);
}
}
// Use this for initialization
void Start()
{
Tetrahedron tetrahedron = new Tetrahedron(
new Measurement3D(4, -2, 6),
new Measurement3D(-5, 0, 2),
new Measurement3D(7, 1, -3),
new Measurement3D(0, 5, 1));
MonoTetrahedron monoTetrahedron = Instantiate(tetraPrefab);
MonoCircumSphere monoCircumSphere = Instantiate(circumPrefab);
monoTetrahedron.SetTetrahedron(tetrahedron);
monoCircumSphere.Initialize(tetrahedron.CircumSphere);
}
bool IsDelaunay(Tetrahedron t)
{
for (int i = 0; i < availablePoints.Count; i++)
{
if (i != t.x0 && i != t.x1 && i != t.x2 && i != t.x3)
{
if (IsWithinCircumsphereBounds(availablePoints[i], t))
{
return(false);
}
}
}
return(true);
}
/// <summary>
/// create an Tetrahedron' renderer.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static SimpleRenderer Create(Tetrahedron model)
{
return Create(model, model.Lengths, Tetrahedron.strPosition);
}
private void Calculate_Click(object sender, System.EventArgs e)
{
Pach_GetModel_Command Model = new Pach_GetModel_Command();
Source[] Source;
if (PachydermAc_PlugIn.Instance.Source(out Source) && !object.ReferenceEquals(FileLocation.SelectedPath, "")) Rhino.RhinoApp.WriteLine("Model geometry not specified... Exiting calculation...");
ParticleRays[] RTParticles = new ParticleRays[Source.Length];
Calculate.Enabled = false;
PachydermAc_PlugIn plugin = PachydermAc_PlugIn.Instance;
Scene Sc;
if (PachydermAc_PlugIn.Instance.Geometry_Spec() == 0) Sc = PachTools.Get_NURBS_Scene(0, (double)Air_Temp.Value, 0, 0, false);
else Sc = PachTools.Get_Poly_Scene(0, (double)Air_Temp.Value, 0, 0, false);
for (int i = 0; i < Source.Length; i++)
{
if (Source != null)
{
List<Point3d> L = new List<Point3d>();
List<Rhino.Geometry.Point3d> L_RC = new List<Rhino.Geometry.Point3d>();
for (int j = 0; j < Source.Length; j++)
{
L.Add(Source[j].Origin());
L_RC.Add(new Rhino.Geometry.Point3d(Source[j].Origin().X, Source[j].Origin().Y, Source[j].Origin().Z));
}
if (plugin.Geometry_Spec() == 0)
{
Sc.partition(L_RC, 15);
RTParticles[i] = new ParticleRays(Source[i], Sc, (int)RT_Count.Value, CutOffLength());
}
else if (plugin.Geometry_Spec() == 1)
{
Sc.partition(L, 15);
RTParticles[i] = new ParticleRays(Source[i], Sc, (int)RT_Count.Value, CutOffLength());
}
RTParticles[i].Begin();
}
else
{
Rhino.RhinoApp.WriteLine("Model geometry not specified... Exiting calculation...");
}
Pachyderm_Acoustic.Visualization.Phonon P;
if (ParticleChoice.SelectedIndex == 0)
{ P = new Tetrahedron(); }
else if (ParticleChoice.SelectedIndex == 1)
{
P = new Icosahedron();
}
else { P = new Geodesic_sphere(); }
RenderParticles(RTParticles, (double)(Frame_Rate.Value * Seconds.Value), P);
Rhino.RhinoDoc.ActiveDoc.Views.Redraw();
}
Calculate.Enabled = true;
}
private void btnCircumcenterTetra_Click(object sender, RoutedEventArgs e)
{
try
{
PrepFor3D();
ClearAllVisuals();
// Create dots
Point3D[] points = Enumerable.Range(0, 4).Select(o => Math3D.GetRandomVector_Spherical(HALFSIZE3D).ToPoint()).ToArray();
Visual3D visual = AddDots(_viewportFull, points, _dotColor);
_dots3D.Add(new Item3D(visual, 0, points));
// Create a tetrahedron
Tetrahedron tetra = new Tetrahedron(0, 1, 2, 3, points, new SortedList<Tuple<int, int, int>, TriangleIndexedLinked>());
// Edge lines
_misc3D.Add(new Item3D(AddLines(_viewportFull, tetra.EdgeArray, points, Colors.Black)));
Point3D center = tetra.CircumsphereCenter;
_misc3D.Add(new Item3D(AddDot(_viewportFull, center, Colors.ForestGreen)));
_misc3D.Add(new Item3D(AddDot(_viewportFull, center, UtilityWPF.ColorFromHex("205ED66C"), tetra.CircumsphereRadius, true)));
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
