private Task <DMesh3Builder> loadObj(string filename)
{
TaskCompletionSource <DMesh3Builder> tcs1 = new TaskCompletionSource <DMesh3Builder>();
Task <DMesh3Builder> t1 = tcs1.Task;
t1.ConfigureAwait(false);
// Start a background task that will complete tcs1.Task
Task.Factory.StartNew(() => {
DMesh3Builder meshBuilder = new DMesh3Builder();
try {
IOReadResult result = StandardMeshReader.ReadFile(filename, new ReadOptions(), meshBuilder);
} catch (Exception e) when(
e is UnauthorizedAccessException ||
e is DirectoryNotFoundException ||
e is FileNotFoundException ||
e is NotSupportedException
)
{
Debug.LogError("Failed to Load" + filename + " : " + e.ToString());
meshBuilder = new DMesh3Builder();
}
tcs1.SetResult(meshBuilder);
});
return(t1);
}
private static void LoadAssetsAsMeshes(IList <Asset> assets, int trianglesLimit, double scale, Dictionary <Asset, DMesh3> destination)
{
if (destination == null)
{
return;
}
var meshBuilder = new DMesh3Builder()
{
NonManifoldTriBehavior = DMesh3Builder.AddTriangleFailBehaviors.DiscardTriangle
};
var objReader = new OBJFormatReader();
var reader = new StandardMeshReader()
{
MeshBuilder = meshBuilder, ReadInvariantCulture = true
};
//reader.AddFormatHandler(objReader);
foreach (var asset in assets)
{
//var isMeshLoaded = objReader.ReadFile(asset.OpenAssetFile(), meshBuilder, null, new ParsingMessagesHandler((s, o) => {; }));
var isMeshLoaded = reader.Read(asset.OpenAssetFile(), asset.FileFormat.ToString(), ReadOptions.Defaults);
if (isMeshLoaded.code == IOCode.Ok)
{
var mesh = meshBuilder.Meshes.Last();
Reducer r = new Reducer(mesh)
{
PreserveBoundaryShape = true,
};
r.ReduceToTriangleCount(trianglesLimit);
MeshTransforms.Scale(mesh, scale);
destination[asset] = mesh;
}
}
}
protected override void Recompute(DGArguments args)
{
System.Console.WriteLine("Reading file...");
ReadMesh = new DMesh3();
string path = CachedValue <string>(0, args);
if (!File.Exists(path))
{
return;
}
DMesh3Builder builder = new DMesh3Builder();
StandardMeshReader reader = new StandardMeshReader();
reader.MeshBuilder = builder;
IOReadResult result = reader.Read(path, ReadOptions.Defaults);
if (result.code != IOCode.Ok)
{
return;
}
ReadMesh = builder.Meshes[0];
}
// Use this for initialization
void Start()
{
meshGO = GameObject.Find("sample_mesh");
Mesh unityMesh = meshGO.GetComponent <MeshFilter>().mesh;
startMesh = g3UnityUtils.UnityMeshToDMesh(unityMesh);
double height = startMesh.CachedBounds.Height;
// find path to sample file
if (LoadSampleMesh)
{
string curPath = Application.dataPath;
string filePath = Path.Combine(curPath, Path.Combine("..\\sample_files", SampleFileName));
// load sample file, convert to unity coordinate system, translate and scale to origin
startMesh = StandardMeshReader.ReadMesh(filePath);
if (startMesh == null)
{
startMesh = new Sphere3Generator_NormalizedCube().Generate().MakeDMesh();
}
if (FlipLeftRight)
{
MeshTransforms.FlipLeftRightCoordSystems(startMesh);
}
MeshTransforms.Scale(startMesh, height / startMesh.CachedBounds.Height);
MeshTransforms.Translate(startMesh, -startMesh.CachedBounds.Center);
MeshNormals.QuickCompute(startMesh);
g3UnityUtils.SetGOMesh(meshGO, startMesh);
}
}
public static void TestOffsetAnimation()
{
Window window = new Window("TestFill");
window.SetDefaultSize(600, 600);
window.SetPosition(WindowPosition.Center);
DMesh3 mesh = StandardMeshReader.ReadMesh("c:\\scratch\\remesh.obj");
MeshBoundaryLoops loops = new MeshBoundaryLoops(mesh);
DCurve3 curve = loops[0].ToCurve();
Polygon2d poly = new Polygon2d();
foreach (Vector3d v in curve.Vertices)
{
poly.AppendVertex(v.xy);
}
Outer = new GeneralPolygon2d(poly);
DebugViewCanvas view = new DebugViewCanvas();
view.AddPolygon(Outer, Colorf.Black);
DGraph2 graph = TopoOffset2d.QuickCompute(Outer, AnimOffset, AnimSpacing);
view.AddGraph(graph, Colorf.Red);
window.Add(view);
window.ShowAll();
Active = view;
}
protected virtual void LoadMesh(CommandLineOptions o, out DMesh3 mesh)
{
if (printGeneratorManager.AcceptsParts)
{
string fMeshFilePath = Path.GetFullPath(o.MeshFilePath);
ConsoleWriteSeparator();
logger.WriteLine($"PARTS");
logger.WriteLine();
logger.Write("Loading mesh " + fMeshFilePath + "...");
mesh = StandardMeshReader.ReadMesh(fMeshFilePath);
logger.WriteLine(" done.");
logger.Write("Repairing mesh... ");
bool repaired = new MeshAutoRepair(mesh).Apply();
logger.WriteLine(repaired ? "repaired." : "not repaired.");
if (o.CenterXY)
{
CenterMeshAboveOrigin(mesh);
}
if (o.DropZ)
{
DropMeshToBuildPlate(mesh);
}
}
else
{
mesh = null;
}
}
// parse file and create a set of MeshSO objects
public bool ReadFile(string sPath)
{
sSourcePath = sPath;
SomeMeshesTooLargeForUnityWarning = false;
// read the input file
DMesh3Builder build = new DMesh3Builder();
StandardMeshReader reader = new StandardMeshReader()
{
MeshBuilder = build
};
reader.warningEvent += on_warning;
ReadOptions options = new ReadOptions();
options.ReadMaterials = true;
LastReadResult = reader.Read(sPath, options);
if (LastReadResult.code != IOCode.Ok)
{
return(false);
}
// create the material set
List <SOMaterial> vSOMaterials = new List <SOMaterial>();
for (int k = 0; k < build.Materials.Count; ++k)
{
SOMaterial m = build_material(sPath, build.Materials[k]);
vSOMaterials.Add(m);
}
// convert the read meshes into unity meshes
SceneObjects = new List <ImportedObject>();
for (int k = 0; k < build.Meshes.Count; ++k)
{
DMesh3 mesh = build.Meshes[k];
int matID = build.MaterialAssignment[k];
SOMaterial soMaterial =
(matID < 0 || matID >= vSOMaterials.Count) ? null : vSOMaterials[matID];
if (SwapLeftRight)
{
MeshTransforms.FlipLeftRightCoordSystems(mesh);
}
SceneObjects.Add(new ImportedObject()
{
mesh = mesh, material = soMaterial
});
}
return(SceneObjects.Count > 0);
}
public static DMesh3 LoadTestMesh(string sPath)
{
StandardMeshReader reader = new StandardMeshReader();
reader.MeshBuilder = new DMesh3Builder();
reader.Read(sPath, new ReadOptions());
return((reader.MeshBuilder as DMesh3Builder).Meshes[0]);
}
public static DMesh3 LoadTestInputMesh(string sPath)
{
StandardMeshReader reader = new StandardMeshReader();
reader.MeshBuilder = new DMesh3Builder();
reader.Read(Program.TEST_FILES_PATH + sPath, new ReadOptions());
return((reader.MeshBuilder as DMesh3Builder).Meshes[0]);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
string path = "";
DA.GetData(0, ref path);
DMesh3 dMsh = StandardMeshReader.ReadMesh(path);
DA.SetData(0, dMsh);
}
public static void Main(string[] args)
{
ExceptionManager.UnhandledException += delegate(UnhandledExceptionArgs expArgs) {
Console.WriteLine(expArgs.ExceptionObject.ToString());
expArgs.ExitApplication = true;
};
Gtk.Application.Init();
MainWindow = new Window("gsCNCViewer");
MainWindow.SetDefaultSize(900, 600);
MainWindow.SetPosition(WindowPosition.Center);
MainWindow.DeleteEvent += delegate {
Gtk.Application.Quit();
};
//DMesh3 part = StandardMeshReader.ReadMesh("../../../sample_files/hemisphere_h2p4.obj");
//DMesh3 stock = StandardMeshReader.ReadMesh("../../../sample_files/stock_5x5x2p5.obj");
DMesh3 part = StandardMeshReader.ReadMesh("../../../sample_files/mechpart1.obj");
DMesh3 stock = StandardMeshReader.ReadMesh("../../../sample_files/mechpart1_stock.obj");
PrintMeshAssembly meshes = new PrintMeshAssembly();
meshes.AddMesh(stock);
meshes.AddMesh(part, PrintMeshOptions.Cavity());
View = new SliceViewCanvas();
MainWindow.Add(View);
//DMesh3 tube_mesh = GenerateTubeMeshesForGCode("c:\\Users\\rms\\Downloads\\gear train.nc");
//StandardMeshWriter.WriteMesh("../../../sample_output/tubes.obj", tube_mesh, WriteOptions.Defaults);
string sPath = GenerateGCodeForMeshes(meshes);
if (SHOW_RELOADED_GCODE_PATHS)
{
LoadGeneratedGCodeFile(sPath);
}
MainWindow.KeyReleaseEvent += Window_KeyReleaseEvent;
// support drag-drop
Gtk.TargetEntry[] target_table = new TargetEntry[] {
new TargetEntry("text/uri-list", 0, 0),
};
Gtk.Drag.DestSet(MainWindow, DestDefaults.All, target_table, Gdk.DragAction.Copy);
MainWindow.DragDataReceived += MainWindow_DragDataReceived;;
MainWindow.ShowAll();
Gtk.Application.Run();
}
public void GenerateResultFile(string meshFilePath, string outputFilePath)
{
var parts = new[] {
new Tuple <DMesh3, object>(StandardMeshReader.ReadMesh(meshFilePath), null)
};
var gCodeFile = engine.Generator.GenerateGCode(parts, Settings, out _, null, (s) => logger.WriteLine(s));
SaveGCode(outputFilePath, gCodeFile);
}
public static void compute_distance_image()
{
DMesh3 mesh = StandardMeshReader.ReadMesh("c:\\scratch\\remesh.obj");
MeshBoundaryLoops loops = new MeshBoundaryLoops(mesh);
DCurve3 curve = loops[0].ToCurve();
Polygon2d poly = new Polygon2d();
foreach (Vector3d v in curve.Vertices)
{
poly.AppendVertex(v.xy);
}
int N = 1024;
double cellsize = poly.Bounds.MaxDim / (double)N;
Vector2d o = poly.Bounds.Min;
o -= 4 * cellsize * Vector2d.One;
N += 8;
ShiftGridIndexer2 indexer = new ShiftGridIndexer2(poly.Bounds.Min, cellsize);
double[] df = new double[N * N];
double maxd = 0;
for (int yi = 0; yi < N; ++yi)
{
for (int xi = 0; xi < N; ++xi)
{
Vector2d p = indexer.FromGrid(new Vector2i(xi, yi));
double d = Math.Sqrt(poly.DistanceSquared(p));
df[yi * N + xi] = d;
maxd = Math.Max(d, maxd);
}
}
SKBitmap bmp = new SKBitmap(N, N);
for (int yi = 0; yi < N; ++yi)
{
for (int xi = 0; xi < N; ++xi)
{
double d = df[yi * N + xi];
float f = (float)(d / maxd);
byte b = (byte)(int)(f * 255);
bmp.SetPixel(xi, yi, new SKColor(b, b, b));
}
}
using (var image = SKImage.FromBitmap(bmp))
using (var data = image.Encode(SKEncodedImageFormat.Png, 80)) {
// save the data to a stream
using (var stream = File.OpenWrite("c:\\scratch\\distances.png")) {
data.SaveTo(stream);
}
}
}
public void GenerateResultFile(string meshFilePath, string outputFilePath)
{
var mesh = StandardMeshReader.ReadMesh(meshFilePath);
var gcode = generator.GCodeFromMesh(
mesh: mesh,
details: out _,
cancellationToken: null);
SaveGCode(outputFilePath, gcode);
}
/// <summary>
/// Creates a geometry mesh, given a streamreader.
/// </summary>
/// <param name="reader">The streamreader.</param>
/// <returns>The streamreader.</returns>
public GeometryMesh ConvertFile(StreamReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
Thread.CurrentThread.CurrentCulture = Settings.Culture;
DMesh3 mesh = StandardMeshReader.ReadMesh(reader.BaseStream, "off");
return(new GeometryMesh(mesh, IOConventions.CheckIfNormalised(reader)));
}
public static List <DMesh3> LoadMeshes(string path)
{
var builder = new DMesh3Builder();
var reader = new StandardMeshReader {
MeshBuilder = builder
};
var result = reader.Read(path, ReadOptions.Defaults);
if (result.code == IOCode.Ok)
{
return(builder.Meshes);
}
return(null);
}
/// <summary>
/// Reads a STL file and creates a DMesh object
/// </summary>
/// <param name="filename"></param>
DMesh3 ImportMeshFromFile(string filename)
{
//import the mesh from file
var mesh = StandardMeshReader.ReadMesh(filename);
_smoothMesh = null;
_moldMesh = null;
_displayMesh = DMeshToMeshGeometry(_mesh);
//check is mesh is good, attempt to fix if not
OrientationCentre(mesh);
//load mesh and reset settings
return(mesh);
}
public static void test_points()
{
string filename = "c:\\scratch\\bunny_solid.obj";
DMesh3 mesh = StandardMeshReader.ReadMesh(filename);
PointSplatsGenerator pointgen = new PointSplatsGenerator()
{
PointIndices = IntSequence.Range(mesh.VertexCount),
PointF = mesh.GetVertex,
NormalF = (vid) => { return((Vector3d)mesh.GetVertexNormal(vid)); },
Radius = mesh.CachedBounds.DiagonalLength * 0.01
};
DMesh3 pointMesh = pointgen.Generate().MakeDMesh();
StandardMeshWriter.WriteMesh("c:\\scratch\\POINTS.obj", pointMesh, WriteOptions.Defaults);
}
public async Task <bool> Slice(IEnumerable <IObject3D> printableItems, PrinterSettings printerSettings, string filePath, IProgress <ProgressStatus> progressReporter, CancellationToken cancellationToken)
{
using (var outputStream = File.OpenWrite(filePath))
{
var sourceMeshes = new List <DMesh3>();
foreach (var item in printableItems.Where(d => d.MeshPath != null))
{
string sourceFilePath = await item.ResolveFilePath(null, cancellationToken);
// Load Mesh
if (File.Exists(sourceFilePath))
{
var mesh = StandardMeshReader.ReadMesh(sourceFilePath);
if (mesh != null)
{
sourceMeshes.Add(mesh);
}
var printCenter = printerSettings.GetValue <Vector2>(SettingsKey.print_center);
ApplyTransform(mesh, item.WorldMatrix(), printCenter);
}
}
PrintSettings settings = LoadSettingsForPrinter(printerSettings);
// Construct slicer
var slicer = new GeometrySlicer();
slicer.SliceMeshes(sourceMeshes, settings);
bool valid = slicer.ExtractResultsIfValid(out PrintMeshAssembly meshes, out PlanarSliceStack slices);
// Construct GCode generator
var pathGenerator = new ToolpathGenerator();
pathGenerator.CreateToolPaths(meshes, slices, settings);
// Write GCode file
var gcodeWriter = new StandardGCodeWriter();
var streamWriter = new StreamWriter(outputStream);
gcodeWriter.WriteFile(pathGenerator.CurrentGCode, streamWriter);
return(true);
}
}
public static void CreateExpectedResult(TestContext context)
{
var generator = new EngineFFF().Generator;
var directory = TestDataPaths.GetTestDataDirectory(CaseName);
var meshFilePath = TestDataPaths.GetMeshFilePath(directory);
var expectedFilePath = TestDataPaths.GetExpectedFilePath(directory);
var parts = new[] {
new Tuple <DMesh3, object>(StandardMeshReader.ReadMesh(meshFilePath), null)
};
var expectedResult = generator.GenerateGCode(parts, new GenericRepRapSettings(), out _, null, Console.WriteLine);
using var w = new StreamWriter(expectedFilePath);
var writer = new StandardGCodeWriter();
writer.WriteFile(expectedResult, w);
}
private async Task <SimpleMeshBuilder> loadObj(string filename)
{
StandardMeshReader reader = new StandardMeshReader();
reader.MeshBuilder = new SimpleMeshBuilder();
try
{
IOReadResult result = reader.Read(filename, new ReadOptions());
}
catch (Exception e) when(
e is UnauthorizedAccessException ||
e is DirectoryNotFoundException ||
e is FileNotFoundException ||
e is NotSupportedException
)
{
Debug.LogError("Failed to Load" + filename + " : " + e.ToString());
}
return(reader.MeshBuilder as SimpleMeshBuilder);
}
static GeneralPolygon2d GetPolygonFromMesh(string sPath)
{
DMesh3 mesh = StandardMeshReader.ReadMesh(sPath);
MeshBoundaryLoops loops = new MeshBoundaryLoops(mesh);
PlanarComplex complex = new PlanarComplex();
foreach (var loop in loops)
{
Polygon2d poly = new Polygon2d();
DCurve3 curve = MeshUtil.ExtractLoopV(mesh, loop.Vertices);
foreach (Vector3d v in curve.Vertices)
{
poly.AppendVertex(v.xy);
}
complex.Add(poly);
}
PlanarComplex.SolidRegionInfo solids = complex.FindSolidRegions(0.0, false);
return(solids.Polygons[0]);
}
public static Bitmap3 createVoxelizedRepresentation(String objPath)
{
DMesh3 mesh = StandardMeshReader.ReadMesh(objPath);
int num_cells = 128;
double cell_size = mesh.CachedBounds.MaxDim / num_cells;
MeshSignedDistanceGrid sdf = new MeshSignedDistanceGrid(mesh, cell_size);
sdf.Compute();
//** voxels**//
Bitmap3 bmp = new Bitmap3(sdf.Dimensions);
Console.WriteLine(bmp.Dimensions.x + " " + bmp.Dimensions.y + " " + bmp.Dimensions.z);
foreach (Vector3i idx in bmp.Indices())
{
float f = sdf[idx.x, idx.y, idx.z];
bmp.Set(idx, (f < 0) ? true : false);
//for bunny only removes bottom
if (idx.y < 8)
{
bmp.Set(idx, false);
}
if (test) //take only one line from top
{
if (idx.z != 50 || idx.x != 60)
{
bmp.Set(idx, false);
}
else
{
bmp.Set(idx, true);
Console.WriteLine(bmp.Get(idx));
}
}
}
return(bmp);
}
private MeshGeometry3D GetMeshGeometry()
{
byte[] data = null;
var mres = new ManualResetEventSlim();
Task.Run(async() =>
{
using (var client = new HttpClient())
{
var response = await client.GetAsync($"https://localhost:44306/api/Models/{Id}");
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsAsync <Mesh.Data.Mesh>();
data = content.Data;
}
}
mres.Set();
});
mres.Wait();
mres.Reset();
StandardMeshReader reader = new StandardMeshReader()
{
MeshBuilder = new DMesh3Builder()
};
using (var stream = new MemoryStream(data))
{
reader.Read(stream, "stl", new ReadOptions());
}
var mesh = (reader.MeshBuilder as DMesh3Builder).Meshes[0];
var mg = ToMeshGeometry3D(mesh);
return(mg);
}
// Use this for initialization
void Start()
{
// find path to sample file
string curPath = Application.dataPath;
string filePath = Path.Combine(curPath, Path.Combine("..\\sample_files", "bunny_solid.obj"));
// load sample file, convert to unity coordinate system, translate and scale to origin
startMesh = StandardMeshReader.ReadMesh(filePath);
if (startMesh == null)
{
startMesh = new Sphere3Generator_NormalizedCube().Generate().MakeDMesh();
}
MeshTransforms.FlipLeftRightCoordSystems(startMesh);
MeshTransforms.Translate(startMesh, -startMesh.CachedBounds.Center);
MeshTransforms.Scale(startMesh, 8.0 / startMesh.CachedBounds.MaxDim);
// load wireframe shader
Material wireframeShader = g3UnityUtils.SafeLoadMaterial("wireframe_shader/Wireframe");
// create initial mesh
meshGO = g3UnityUtils.CreateMeshGO("start_mesh", startMesh, wireframeShader);
}
public static void test_simple_obj()
{
string cwd = System.IO.Directory.GetCurrentDirectory();
System.Console.WriteLine("MeshIOTests : test_simple_obj() starting");
//SimpleMeshBuilder builder = new SimpleMeshBuilder();
DMesh3Builder builder = new DMesh3Builder();
StandardMeshReader reader = new StandardMeshReader();
reader.MeshBuilder = builder;
var readResult = reader.Read(Program.TEST_FILES_PATH + "socket_with_groups.obj", new ReadOptions());
System.Console.WriteLine("read complete");
if (readResult.code != IOCode.Ok)
{
System.Console.WriteLine("read failed : " + readResult.message);
throw new Exception("failed");
}
List <WriteMesh> meshes = new List <WriteMesh>();
foreach (IMesh m in builder.Meshes)
{
meshes.Add(new WriteMesh(m));
}
var writeResult = StandardMeshWriter.WriteFile(Program.TEST_OUTPUT_PATH + "temp_write.obj",
meshes, new WriteOptions());
System.Console.WriteLine("write complete");
if (writeResult.code != IOCode.Ok)
{
System.Console.WriteLine("write failed : " + writeResult.message);
throw new Exception("f**k");
}
}
virtual protected DMesh3 make_bunny()
{
if (cached_bunny == null)
{
// [RMS] yiiiiiikes
MemoryStream stream = FResources.LoadBinary("meshes/unit_height_bunny");
if (stream != null)
{
cached_bunny = StandardMeshReader.ReadMesh(stream, "obj");
MeshTransforms.ConvertZUpToYUp(cached_bunny);
MeshTransforms.FlipLeftRightCoordSystems(cached_bunny);
}
else
{
cached_bunny = make_shape_sphere();
MeshTransforms.Scale(cached_bunny, 1 / ShapeHeight);
}
}
DMesh3 mesh = new DMesh3(cached_bunny);
MeshTransforms.Scale(mesh, ShapeHeight);
return(mesh);
}
public static void Main(string[] args)
{
ExceptionManager.UnhandledException += delegate(UnhandledExceptionArgs expArgs) {
Console.WriteLine(expArgs.ExceptionObject.ToString());
expArgs.ExitApplication = true;
};
Gtk.Application.Init();
MainWindow = new Window("DLPViewer");
MainWindow.SetDefaultSize(900, 600);
MainWindow.SetPosition(WindowPosition.Center);
MainWindow.DeleteEvent += delegate {
Gtk.Application.Quit();
};
DMesh3 mesh = StandardMeshReader.ReadMesh("../../../sample_files/bunny_solid_5cm_min.obj");
MeshPlanarSlicer slicer = new MeshPlanarSlicer();
slicer.LayerHeightMM = 0.2;
slicer.AddMesh(mesh);
PlanarSliceStack sliceStack = slicer.Compute();
View = new DLPViewCanvas();
View.SetSlices(sliceStack);
MainWindow.Add(View);
MainWindow.KeyReleaseEvent += Window_KeyReleaseEvent;
MainWindow.ShowAll();
Gtk.Application.Run();
}
static void RunCalc()
{
// Target = Element you transform around.
// Source = Element you want to transform.
DMesh3Builder builder = new DMesh3Builder();
StandardMeshReader reader = new StandardMeshReader();
reader.MeshBuilder = builder;
var Target = reader.Read(@"D:\Eksamen 4th semester\Pointclouds\triangle4.obj", new ReadOptions());
var Source = reader.Read(@"D:\Eksamen 4th semester\Pointclouds\triangle3.obj", new ReadOptions());
DMeshAABBTree3 tree = new DMeshAABBTree3(builder.Meshes[0], autoBuild: true);
MeshICP calc = new MeshICP(builder.Meshes[1], tree);
calc.Solve();
calc.Solve(bUpdate: true);
Console.WriteLine(calc.Rotation);
Console.WriteLine(calc.Translation);
Console.WriteLine();
DMesh3 source = builder.Meshes[1];
DMesh3 target = builder.Meshes[0];
//foreach (var item in source.Vertices())
//{
// Console.WriteLine(item);
//}
//Console.WriteLine("--------------------");
Func <Vector3d, Vector3d> TransformF = (v1) =>
{
return(v1 += calc.Translation);
};
MeshTransforms.PerVertexTransform(source, TransformF);
var tarver = target.Vertices();
List <Vector3d> tarlist = tarver.ToList();
trees = new KdTree <double, string>(3, new DoubleMath());
foreach (var item in tarlist)
{
trees.Add(new double[] { item.x, item.y, item.z }, item.xy.ToString());
}
for (var findLimit = 0; findLimit <= tarlist.Count; findLimit++)
{
}
double[][] tar = new double[tarlist.Count][];
int i = 0;
foreach (var item in tarlist)
{
tar[i] = new double[] { item.x, item.y, 1 };
i++;
}
int k = 3;
int numClasses = 300;
Console.WriteLine("With k = 3");
List <int> res = new List <int>();
foreach (var item in target.Vertices())
{
double[] src = new double[] { item.x, item.y, item.z };
int predicted = Classify(src, tar, numClasses, k);
}
}
public static void Main(string[] args)
{
CommandArgumentSet arguments = new CommandArgumentSet();
//arguments.Register("-tcount", int.MaxValue);
//arguments.Register("-percent", 50.0f);
//arguments.Register("-v", false);
arguments.Register("-output", "");
if (arguments.Parse(args) == false)
{
return;
}
if (arguments.Filenames.Count != 1)
{
print_usage();
return;
}
string inputFilename = arguments.Filenames[0];
if (!File.Exists(inputFilename))
{
System.Console.WriteLine("File {0} does not exist", inputFilename);
return;
}
string outputFilename = Path.GetFileNameWithoutExtension(inputFilename);
string format = Path.GetExtension(inputFilename);
outputFilename = outputFilename + ".repaired" + format;
if (arguments.Saw("-output"))
{
outputFilename = arguments.Strings["-output"];
}
//int triCount = int.MaxValue;
//if (arguments.Saw("-tcount"))
// triCount = arguments.Integers["-tcount"];
//float percent = 50.0f;
//if (arguments.Saw("-percent"))
// percent = arguments.Floats["-percent"];
bool verbose = true;
//if (arguments.Saw("-v"))
// verbose = arguments.Flags["-v"];
List <DMesh3> meshes;
try {
DMesh3Builder builder = new DMesh3Builder();
IOReadResult result = StandardMeshReader.ReadFile(inputFilename, ReadOptions.Defaults, builder);
if (result.code != IOCode.Ok)
{
System.Console.WriteLine("Error reading {0} : {1}", inputFilename, result.message);
return;
}
meshes = builder.Meshes;
} catch (Exception e) {
System.Console.WriteLine("Exception reading {0} : {1}", inputFilename, e.Message);
return;
}
if (meshes.Count == 0)
{
System.Console.WriteLine("file did not contain any valid meshes");
return;
}
DMesh3 mesh = meshes[0];
for (int k = 1; k < meshes.Count; ++k)
{
MeshEditor.Append(mesh, meshes[k]);
}
if (mesh.TriangleCount == 0)
{
System.Console.WriteLine("mesh does not contain any triangles");
return;
}
if (verbose)
{
System.Console.WriteLine("initial mesh contains {0} triangles", mesh.TriangleCount);
}
if (verbose)
{
System.Console.WriteLine("Repairing...", mesh.TriangleCount);
}
MeshAutoRepair repair = new MeshAutoRepair(mesh);
repair.RemoveMode = MeshAutoRepair.RemoveModes.None;
bool bOK = repair.Apply();
if (verbose)
{
if (bOK == false)
{
System.Console.WriteLine("repair failed!");
}
else
{
System.Console.WriteLine("done! repaired mesh contains {0} triangles", mesh.TriangleCount);
}
}
try {
IOWriteResult wresult =
StandardMeshWriter.WriteMesh(outputFilename, mesh, WriteOptions.Defaults);
if (wresult.code != IOCode.Ok)
{
System.Console.WriteLine("Error writing {0} : {1}", inputFilename, wresult.message);
return;
}
} catch (Exception e) {
System.Console.WriteLine("Exception reading {0} : {1}", inputFilename, e.Message);
return;
}
return;
}
