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; }