public void Division_EQ_Test()
{
var calculator = new NormalCalculator();
Assert.Equal(0.5, calculator.Division(1, 2));
Assert.Equal(double.NaN, calculator.Division(1, 0));
}
public override void Run(RenderControl render)
{
if (!ReadData())
{
return;
}
var material = MeshPhongMaterial.Create("cae-material");
material.GetTemplate().SetVertexColors(true);
material.SetFaceSide(EnumFaceSide.DoubleSide);
var position = BufferAttribute.Create(EnumAttributeSemantic.Position, EnumAttributeComponents.Three, mPositions);
var color = BufferAttribute.Create(EnumAttributeSemantic.Color, EnumAttributeComponents.Three, mColors);
BufferGeometry geometry = new BufferGeometry();
geometry.AddAttribute(position);
geometry.AddAttribute(color);
NormalCalculator.ComputeVertexNormals(geometry);
var node = new PrimitiveSceneNode(geometry, EnumPrimitiveType.TRIANGLES, material);
node.SetPickable(false);
PaletteWidget pw = new PaletteWidget();
pw.Update(mColorTable);
render.ShowSceneNode(pw);
render.ShowSceneNode(node);
}
public void TestNormals()
{
var mdlReader = new MdlFilePolygonDataReader(_inputPath + @"\flowerpetals.mdl");
var triangles = Triangle.GetTrianglesFromPts(mdlReader.Points);
var meshGeometryModel = PaulBourkeSmoother.CreateMeshGeometry3DFromTriangles(triangles);
Assert.AreEqual(0, meshGeometryModel.Normals.Count);
XamlWriter.SaveMeshGeometryModel(_outputPath + @"\ModelWithoutSetNormals.xaml", meshGeometryModel, Color.FromRgb(255, 255, 0));
NormalCalculator.SetNormalsForModel(meshGeometryModel);
Assert.AreEqual(meshGeometryModel.Positions.Count, meshGeometryModel.Normals.Count);
XamlWriter.SaveMeshGeometryModel(_outputPath + @"\ModelWithSetNormals.xaml", meshGeometryModel, Color.FromRgb(255, 255, 0));
var normalModelPts = new List <Point3D>();
for (var index = 0; index < meshGeometryModel.Normals.Count; index++)
{
var normal = meshGeometryModel.Normals[index];
var position = meshGeometryModel.Positions[index];
var p2 = new Point3D(position.X + normal.X, position.Y + normal.Y, position.Z + normal.Z);
var lineModel = LineDisplayModel.GetLineModel(position, p2, .03);
normalModelPts.AddRange(lineModel);
}
XamlWriter.WritePolygonsToXamlFile("", _outputPath + @"\NormalsAsLines.xaml", normalModelPts, false);
}
public static MeshGeometry3D SmoothenMesh(int count, HashSet <int>[] positionNeighbors, MeshGeometry3D mesh)
{
mesh.Positions = GetSmoothenedPositions(mesh.Positions, mesh.TriangleIndices, positionNeighbors, count);
//important to set normals to avoid distorted display
NormalCalculator.SetNormalsForModel(mesh);
return(mesh);
}
public void TestCreateNormalWithTheDinosaurModel()
{
var mdlReader = new MdlFilePolygonDataReader(_inputPath + @"\dinosaur.mdl");
var triangles = Triangle.GetTrianglesFromPts(mdlReader.Points);
var meshGeometryModel = PaulBourkeSmoother.CreateMeshGeometry3DFromTriangles(triangles);
Assert.AreEqual(0, meshGeometryModel.Normals.Count);
NormalCalculator.SetNormalsForModel(meshGeometryModel);
Assert.AreEqual(meshGeometryModel.Positions.Count, meshGeometryModel.Normals.Count);
XamlWriter.SaveMeshGeometryModel(_outputPath + @"\ModelWithSetNormals.xaml", meshGeometryModel, Color.FromRgb(255, 255, 0));
}
void SetColliderMesh(MeshData meshData)
{
// collider mesh
col.sharedMesh = null;
Mesh mesh = new Mesh();
mesh.vertices = meshData.colliderVerts.ToArray();
mesh.triangles = meshData.colliderTris.ToArray();
NormalCalculator.RecalculateNormals(mesh, 60);
col.sharedMesh = mesh;
}
void RenderMesh(MeshData meshData)
{
// renderer mesh
filter.mesh.Clear();
filter.mesh.vertices = meshData.vertices.ToArray();
filter.mesh.triangles = meshData.triangles.ToArray();
filter.mesh.uv = meshData.uv.ToArray();
NormalCalculator.RecalculateNormals(filter.mesh, 60);
filter.mesh.RecalculateBounds();
}
//Sends the calculated mesh information
//to the mesh and collision components
public void RenderMesh(MeshData meshData)
{
filter.mesh.Clear();
filter.mesh.vertices = meshData.vertices.ToArray();
filter.mesh.triangles = meshData.triangles.ToArray();
filter.mesh.uv = meshData.uv.ToArray();
NormalCalculator.RecalculateNormals(filter.mesh, 60);
filter.mesh.RecalculateBounds();
// col.sharedMesh = null;
// Mesh mesh = new Mesh();
// mesh.vertices = meshData.colliderVerts.ToArray();
// mesh.triangles = meshData.colliderTris.ToArray();
// mesh.RecalculateNormals();
// col.sharedMesh = mesh;
}
public DeformableMesh(Vector3[] points, int[] ids, Vector3[] normals)
{
Points = points;
Ids = ids;
Normals = normals;
Topology = new TopologyManager(points, ids);
spatialContainer = new SpatialContainer(points, 3, 16);
normalCalculator = new NormalCalculator(Topology.Vertices, points, ids);
deformation = new Vector3[points.Length];
deformationMask = new bool[points.Length];
normalsToUpdateMask = new bool[points.Length];
running = true;
new Thread(
new ThreadStart(UpdateNormalsLoop)
).Start();
}
static void Main(string[] args)
{
string saveDataName = "results.xml";
double result = 0;
bool statusTreger = true;
while (statusTreger == true)
{
Console.WriteLine(StringsDefoult.MenuString);
string typeCalc = Console.ReadLine();
switch (typeCalc)
{
case "1":
bool stat = false;
Console.WriteLine("Enter your number :");
result = Convert.ToInt32(Console.ReadLine());
while (stat == false)
{
Console.WriteLine("Enter +/-*=");
string ent = Console.ReadLine();
int next_w = NormalCalculator.FuncWork(ent);
result = NormalCalculator.WorkFunc(next_w, result, saveDataName);
if (result == -2147483647)
{
break;
}
}
Console.ReadKey();
break;
case "2":
Console.WriteLine("Enter number :");
result = EngineeringCalculator.Calculater(saveDataName);
Console.ReadKey();
break;
case "3":
Console.Clear();
bool statusGeometryTreger = true;
double res = 0;
while (statusGeometryTreger != false)
{
Console.WriteLine(StringsDefoult.GeometryMeny);
string type = Console.ReadLine();
switch (type)
{
case "1":
Console.WriteLine("Right Triangle MODE active\nEnter your side length :");
double side = Convert.ToDouble(Console.ReadLine());
res = log.GeometryCalculator.ClasicTriangle(side);
Console.WriteLine("Square of your right Triangle is " + res);
Console.ReadKey();
break;
case "2":
Console.WriteLine("Rectangle MODE active\nEnter your side a length :");
double sidea = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Enter your side a length :");
double sideb = Convert.ToDouble(Console.ReadLine());
res = log.GeometryCalculator.Rectangle(sidea, sideb);
Console.WriteLine("Square of your Rectangle is " + res);
break;
case "3":
Console.WriteLine("Square MODE active\nEnter your side length :");
double sid = Convert.ToDouble(Console.ReadLine());
res = log.GeometryCalculator.Square(sid);
Console.WriteLine("Square of your square is " + res);
Console.ReadKey();
break;
case "4":
Console.WriteLine(" Circle MODE active\nEnter your side length :");
double r = Convert.ToDouble(Console.ReadLine());
res = log.GeometryCalculator.Circle(r);
Console.WriteLine(" Circle of your square is " + res);
Console.ReadKey();
break;
case "5":
Console.WriteLine("Regular Poligon MODE active\nEnter your side a length :");
double a = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Enter your namber of sides :");
double n = Convert.ToDouble(Console.ReadLine());
res = log.GeometryCalculator.RegularPoligon(n, a);
Console.WriteLine("Square of your Rectangle is " + res);
break;
case "exit":
statusGeometryTreger = false;
break;
}
}
break;
case "results":
try
{
List <ClassForSave> lastResult = AddFromFile.AddFromFileXml(saveDataName);
foreach (ClassForSave i in lastResult)
{
Console.WriteLine($" Your result {i.LastResult} \t In time {i.DataResultStatus}");
}
}
catch
{
Console.WriteLine("Results not found !!!!!!!");
}
Console.ReadKey();
break;
case "exit":
Console.WriteLine("Your Exit from program:");
statusTreger = false;
break;
default:
break;
}
Console.Clear();
}
}
public void Add_EQ_Test()
{
var calculator = new NormalCalculator();
Assert.Equal(2, calculator.Add(1, 1));
}
public void Division_NonEQ_Test()
{
var calculator = new NormalCalculator();
Assert.NotEqual(0.5, calculator.Division(1, 3));
}
public void Multiply_NonEQ_Test()
{
var calculator = new NormalCalculator();
Assert.NotEqual(1, calculator.Multiply(1, 3));
}
public void Multiply_EQ_Test()
{
var calculator = new NormalCalculator();
Assert.Equal(1, calculator.Multiply(1, 1));
}
public void Substract_NonEQ_Test()
{
var calculator = new NormalCalculator();
Assert.NotEqual(1, calculator.Substract(1, 1));
}
public void Add_NonEQ_Test()
{
var calculator = new NormalCalculator();
Assert.NotEqual(0, calculator.Add(1, 1));
}
