public static bool Save(List <MeshGroup> meshGroupsToSave, string meshPathAndFileName, MeshOutputSettings outputInfo = null, ReportProgressRatio reportProgress = null) { try { if (outputInfo == null) { outputInfo = new MeshOutputSettings(); } switch (Path.GetExtension(meshPathAndFileName).ToUpper()) { case ".STL": Mesh mesh = DoMerge(meshGroupsToSave, outputInfo); return(StlProcessing.Save(mesh, meshPathAndFileName, outputInfo)); case ".AMF": outputInfo.ReportProgress = reportProgress; return(AmfProcessing.Save(meshGroupsToSave, meshPathAndFileName, outputInfo)); default: return(false); } } catch (Exception) { return(false); } }
public static bool SaveUncompressed(List<MeshGroup> meshToSave, string fileName, MeshOutputSettings outputInfo = null) { using (FileStream file = new FileStream(fileName, FileMode.Create, FileAccess.Write)) { return Save(meshToSave, file, outputInfo); } }
static public void SaveToLibraryFolder2(PrintItemWrapper printItemWrapper, List<MeshGroup> meshGroups, bool AbsolutePositioned) { string[] metaData = { "Created By", "MatterControl" }; if (AbsolutePositioned) { metaData = new string[] { "Created By", "MatterControl", "BedPosition", "Absolute" }; } if (printItemWrapper.FileLocation.Contains(ApplicationDataStorage.Instance.ApplicationLibraryDataPath)) { MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); MeshFileIo.Save(meshGroups, printItemWrapper.FileLocation, outputInfo); } else // save a copy to the library and update this to point at it { string fileName = Path.ChangeExtension(Path.GetRandomFileName(), ".amf"); printItemWrapper.FileLocation = Path.Combine(ApplicationDataStorage.Instance.ApplicationLibraryDataPath, fileName); MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); MeshFileIo.Save(meshGroups, printItemWrapper.FileLocation, outputInfo); printItemWrapper.PrintItem.Commit(); // let the queue know that the item has changed so it load the correct part QueueData.Instance.SaveDefaultQueue(); } printItemWrapper.OnFileHasChanged(); }
public static bool Save(Mesh meshToSave, string fileName, MeshOutputSettings outputInfo = null) { using (FileStream file = new FileStream(fileName, FileMode.Create, FileAccess.Write)) { if (outputInfo == null) { outputInfo = new MeshOutputSettings(); } return Save(meshToSave, file, outputInfo); } }
public static bool Save(Mesh meshToSave, string fileName, MeshOutputSettings outputInfo = null) { using (FileStream file = new FileStream(fileName, FileMode.Create, FileAccess.Write)) { if (outputInfo == null) { outputInfo = new MeshOutputSettings(); } return(Save(meshToSave, file, outputInfo)); } }
public static bool Save(this Mesh meshToSave, string fileName, CancellationToken cancellationToken, MeshOutputSettings outputInfo = null) { using (var file = new FileStream(fileName, FileMode.Create, FileAccess.Write)) { if (outputInfo == null) { outputInfo = new MeshOutputSettings(); } return(Save(meshToSave, file, cancellationToken, outputInfo)); } }
/// <summary> /// Writes the mesh to disk in a zip container /// </summary> /// <param name="meshToSave">The mesh to save</param> /// <param name="fileName">The file path to save at</param> /// <param name="outputInfo">Extra meta data to store in the file</param> /// <returns>The results of the save operation</returns> public static bool Save(List<MeshGroup> meshToSave, string fileName, MeshOutputSettings outputInfo = null) { using (Stream stream = File.OpenWrite(fileName)) using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Create)) { ZipArchiveEntry zipEntry = archive.CreateEntry(Path.GetFileName(fileName)); using (var entryStream = zipEntry.Open()) { return Save(meshToSave, entryStream, outputInfo); } } }
/// <summary> /// Writes the mesh to disk in a zip container /// </summary> /// <param name="meshToSave">The mesh to save</param> /// <param name="fileName">The file path to save at</param> /// <param name="outputInfo">Extra meta data to store in the file</param> /// <returns>The results of the save operation</returns> public static bool Save(List <MeshGroup> meshToSave, string fileName, MeshOutputSettings outputInfo = null) { using (Stream stream = File.OpenWrite(fileName)) using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Create)) { ZipArchiveEntry zipEntry = archive.CreateEntry(Path.GetFileName(fileName)); using (var entryStream = zipEntry.Open()) { return(Save(meshToSave, entryStream, outputInfo)); } } }
public static Mesh DoMerge(List <MeshGroup> meshGroupsToMerge, MeshOutputSettings outputInfo) { Mesh allPolygons = new Mesh(); if (outputInfo.CsgOptionState == MeshOutputSettings.CsgOption.DoCsgMerge) { foreach (MeshGroup meshGroup in meshGroupsToMerge) { foreach (Mesh mesh in meshGroup.Meshes) { allPolygons = CsgOperations.Union(allPolygons, mesh); } } } else { foreach (MeshGroup meshGroup in meshGroupsToMerge) { foreach (Mesh mesh in meshGroup.Meshes) { int currentMeshMaterialIntdex = MeshMaterialData.Get(mesh).MaterialIndex; if (outputInfo.MaterialIndexsToSave == null || outputInfo.MaterialIndexsToSave.Contains(currentMeshMaterialIntdex)) { foreach (Face face in mesh.Faces) { List <Vertex> faceVertices = new List <Vertex>(); foreach (FaceEdge faceEdgeToAdd in face.FaceEdges()) { // we allow duplicates (the true) to make sure we are not changing the loaded models acuracy. Vertex newVertex = allPolygons.CreateVertex(faceEdgeToAdd.firstVertex.Position, CreateOption.CreateNew, SortOption.WillSortLater); faceVertices.Add(newVertex); } // we allow duplicates (the true) to make sure we are not changing the loaded models acuracy. allPolygons.CreateFace(faceVertices.ToArray(), CreateOption.CreateNew); } } } } allPolygons.CleanAndMergMesh(); } return(allPolygons); }
/// <summary> /// Writes the mesh to disk in a zip container /// </summary> /// <param name="meshToSave">The mesh to save</param> /// <param name="fileName">The file path to save at</param> /// <param name="outputInfo">Extra meta data to store in the file</param> /// <returns>The results of the save operation</returns> public static bool Save(List<MeshGroup> meshToSave, string fileName, MeshOutputSettings outputInfo = null) { try { using (Stream stream = File.OpenWrite(fileName)) using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Create)) { ZipArchiveEntry zipEntry = archive.CreateEntry(Path.GetFileName(fileName)); using (var entryStream = zipEntry.Open()) { return Save(meshToSave, entryStream, outputInfo); } } } catch (Exception e) { Debug.Print(e.Message); BreakInDebugger(); return false; } }
/// <summary> /// Writes the mesh to disk in a zip container /// </summary> /// <param name="meshToSave">The mesh to save</param> /// <param name="fileName">The file path to save at</param> /// <param name="outputInfo">Extra meta data to store in the file</param> /// <returns>The results of the save operation</returns> public static bool Save(List <MeshGroup> meshToSave, string fileName, MeshOutputSettings outputInfo = null) { try { using (Stream stream = File.OpenWrite(fileName)) using (ZipArchive archive = new ZipArchive(stream, ZipArchiveMode.Create)) { ZipArchiveEntry zipEntry = archive.CreateEntry(Path.GetFileName(fileName)); using (var entryStream = zipEntry.Open()) { return(Save(meshToSave, entryStream, outputInfo)); } } } catch (Exception e) { Debug.Print(e.Message); BreakInDebugger(); return(false); } }
public static bool Save(List<MeshGroup> meshGroupsToSave, string meshPathAndFileName, MeshOutputSettings outputInfo = null, ReportProgressRatio reportProgress = null) { try { if (outputInfo == null) { outputInfo = new MeshOutputSettings(); } switch (Path.GetExtension(meshPathAndFileName).ToUpper()) { case ".STL": Mesh mesh = DoMerge(meshGroupsToSave, outputInfo); return StlProcessing.Save(mesh, meshPathAndFileName, outputInfo); case ".AMF": outputInfo.ReportProgress = reportProgress; return AmfProcessing.Save(meshGroupsToSave, meshPathAndFileName, outputInfo); default: return false; } } catch (Exception) { return false; } }
public static bool Save(Mesh mesh, string meshPathAndFileName, MeshOutputSettings outputInfo = null) { return Save(new MeshGroup(mesh), meshPathAndFileName, outputInfo); }
public static bool Save(MeshGroup meshGroupToSave, string meshPathAndFileName, MeshOutputSettings outputInfo = null) { List<MeshGroup> meshGroupsToSave = new List<MeshGroup>(); meshGroupsToSave.Add(meshGroupToSave); return Save(meshGroupsToSave, meshPathAndFileName, outputInfo); }
public override IEnumerable<PrintItemAction> GetMenuItems() { return new List<PrintItemAction>() { new PrintItemAction() { SingleItemOnly = false, Title = "Merge...", Action = (items, queueDataWidget) => { List<QueueRowItem> allRowItems = new List<QueueRowItem>(items); if (allRowItems.Count > 1) { RenameItemWindow renameItemWindow = new RenameItemWindow(allRowItems[0].PrintItemWrapper.Name, (returnInfo) => { Task.Run(() => { List<MeshGroup> combinedMeshes = new List<MeshGroup>(); // Load up all the parts and merge them together foreach(QueueRowItem item in allRowItems) { List<MeshGroup> loadedMeshGroups = MeshFileIo.Load(item.PrintItemWrapper.FileLocation); combinedMeshes.AddRange(loadedMeshGroups); } // save them out string[] metaData = { "Created By", "MatterControl", "BedPosition", "Absolute" }; MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); string libraryDataPath = ApplicationDataStorage.Instance.ApplicationLibraryDataPath; if (!Directory.Exists(libraryDataPath)) { Directory.CreateDirectory(libraryDataPath); } string tempFileNameToSaveTo = Path.Combine(libraryDataPath, Path.ChangeExtension(Path.GetRandomFileName(), "amf")); bool savedSuccessfully = MeshFileIo.Save(combinedMeshes, tempFileNameToSaveTo, outputInfo); // Swap out the files if the save operation completed successfully if (savedSuccessfully && File.Exists(tempFileNameToSaveTo)) { // create a new print item // add it to the queue PrintItemWrapper newPrintItem = new PrintItemWrapper(new PrintItem(returnInfo.newName, tempFileNameToSaveTo)); QueueData.Instance.AddItem(newPrintItem, 0); // select the part we added, if possible QueueData.Instance.SelectedIndex = 0; queueDataWidget.LeaveEditMode(); } }); }, "Set Name".Localize()) { Title = "MatterHackers - Set Name".Localize(), ElementHeader = "Set Name".Localize(), }; } } } }; }
public static bool Save(Mesh meshToSave, Stream stream, MeshOutputSettings outputInfo) { switch (outputInfo.OutputTypeSetting) { case MeshOutputSettings.OutputType.Ascii: { StreamWriter streamWriter = new StreamWriter(stream); streamWriter.WriteLine("solid Default"); foreach (Face face in meshToSave.Faces) { List <Vector3> positionsCCW = new List <Vector3>(); foreach (FaceEdge faceEdge in face.FaceEdges()) { positionsCCW.Add(faceEdge.firstVertex.Position); } int numPolys = positionsCCW.Count - 2; int secondIndex = 1; int thirdIndex = 2; for (int polyIndex = 0; polyIndex < numPolys; polyIndex++) { streamWriter.WriteLine(" facet normal " + FormatForStl(face.normal)); streamWriter.WriteLine(" outer loop"); streamWriter.WriteLine(" vertex " + FormatForStl(positionsCCW[0])); streamWriter.WriteLine(" vertex " + FormatForStl(positionsCCW[secondIndex])); streamWriter.WriteLine(" vertex " + FormatForStl(positionsCCW[thirdIndex])); streamWriter.WriteLine(" endloop"); streamWriter.WriteLine(" endfacet"); secondIndex = thirdIndex; thirdIndex++; } } streamWriter.WriteLine("endsolid Default"); streamWriter.Close(); } break; case MeshOutputSettings.OutputType.Binary: using (BinaryWriter bw = new BinaryWriter(stream)) { // 80 bytes of nothing bw.Write(new Byte[80]); // the number of tranigles bw.Write(meshToSave.Faces.Count); int binaryPolyCount = 0; foreach (Face face in meshToSave.Faces) { List <Vector3> positionsCCW = new List <Vector3>(); foreach (FaceEdge faceEdge in face.FaceEdges()) { positionsCCW.Add(faceEdge.firstVertex.Position); } int numPolys = positionsCCW.Count - 2; int secondIndex = 1; int thirdIndex = 2; for (int polyIndex = 0; polyIndex < numPolys; polyIndex++) { binaryPolyCount++; // save the normal (all 0 so it can compress better) bw.Write((float)0); bw.Write((float)0); bw.Write((float)0); // save the position bw.Write((float)positionsCCW[0].x); bw.Write((float)positionsCCW[0].y); bw.Write((float)positionsCCW[0].z); bw.Write((float)positionsCCW[secondIndex].x); bw.Write((float)positionsCCW[secondIndex].y); bw.Write((float)positionsCCW[secondIndex].z); bw.Write((float)positionsCCW[thirdIndex].x); bw.Write((float)positionsCCW[thirdIndex].y); bw.Write((float)positionsCCW[thirdIndex].z); // and the attribute bw.Write((ushort)0); secondIndex = thirdIndex; thirdIndex++; } } bw.BaseStream.Position = 80; // the number of tranigles bw.Write(binaryPolyCount); } break; } return(true); }
public static bool Save(Mesh meshToSave, Stream stream, MeshOutputSettings outputInfo) { switch (outputInfo.OutputTypeSetting) { case MeshOutputSettings.OutputType.Ascii: { StreamWriter streamWriter = new StreamWriter(stream); streamWriter.WriteLine("solid Default"); foreach (Face face in meshToSave.Faces) { List<Vector3> positionsCCW = new List<Vector3>(); foreach (FaceEdge faceEdge in face.FaceEdges()) { positionsCCW.Add(faceEdge.firstVertex.Position); } int numPolys = positionsCCW.Count - 2; int secondIndex = 1; int thirdIndex = 2; for (int polyIndex = 0; polyIndex < numPolys; polyIndex++) { streamWriter.WriteLine(" facet normal " + FormatForStl(face.normal)); streamWriter.WriteLine(" outer loop"); streamWriter.WriteLine(" vertex " + FormatForStl(positionsCCW[0])); streamWriter.WriteLine(" vertex " + FormatForStl(positionsCCW[secondIndex])); streamWriter.WriteLine(" vertex " + FormatForStl(positionsCCW[thirdIndex])); streamWriter.WriteLine(" endloop"); streamWriter.WriteLine(" endfacet"); secondIndex = thirdIndex; thirdIndex++; } } streamWriter.WriteLine("endsolid Default"); streamWriter.Close(); } break; case MeshOutputSettings.OutputType.Binary: using (BinaryWriter bw = new BinaryWriter(stream)) { // 80 bytes of nothing bw.Write(new Byte[80]); // the number of tranigles bw.Write(meshToSave.Faces.Count); int binaryPolyCount = 0; foreach (Face face in meshToSave.Faces) { List<Vector3> positionsCCW = new List<Vector3>(); foreach (FaceEdge faceEdge in face.FaceEdges()) { positionsCCW.Add(faceEdge.firstVertex.Position); } int numPolys = positionsCCW.Count - 2; int secondIndex = 1; int thirdIndex = 2; for (int polyIndex = 0; polyIndex < numPolys; polyIndex++) { binaryPolyCount++; // save the normal (all 0 so it can compress better) bw.Write((float)0); bw.Write((float)0); bw.Write((float)0); // save the position bw.Write((float)positionsCCW[0].x); bw.Write((float)positionsCCW[0].y); bw.Write((float)positionsCCW[0].z); bw.Write((float)positionsCCW[secondIndex].x); bw.Write((float)positionsCCW[secondIndex].y); bw.Write((float)positionsCCW[secondIndex].z); bw.Write((float)positionsCCW[thirdIndex].x); bw.Write((float)positionsCCW[thirdIndex].y); bw.Write((float)positionsCCW[thirdIndex].z); // and the attribute bw.Write((ushort)0); secondIndex = thirdIndex; thirdIndex++; } } bw.BaseStream.Position = 80; // the number of tranigles bw.Write(binaryPolyCount); } break; } return true; }
public static bool Save(Mesh mesh, Stream stream, CancellationToken cancellationToken, MeshOutputSettings outputInfo) { switch (outputInfo.OutputTypeSetting) { case MeshOutputSettings.OutputType.Ascii: { var streamWriter = new StreamWriter(stream); streamWriter.WriteLine("solid Default"); for (int faceIndex = 0; faceIndex < mesh.Faces.Count; faceIndex++) { if (cancellationToken.IsCancellationRequested) { return(false); } var face = mesh.Faces[faceIndex]; streamWriter.WriteLine(" facet normal " + FormatForStl(mesh.Faces[faceIndex].normal)); streamWriter.WriteLine(" outer loop"); streamWriter.WriteLine(" vertex " + FormatForStl(mesh.Vertices[face.v0])); streamWriter.WriteLine(" vertex " + FormatForStl(mesh.Vertices[face.v1])); streamWriter.WriteLine(" vertex " + FormatForStl(mesh.Vertices[face.v2])); streamWriter.WriteLine(" endloop"); streamWriter.WriteLine(" endfacet"); } streamWriter.WriteLine("endsolid Default"); streamWriter.Close(); } break; case MeshOutputSettings.OutputType.Binary: using (var bw = new BinaryWriter(stream)) { // 80 bytes of nothing bw.Write(new byte[80]); // the number of triangles bw.Write(mesh.Faces.Count); int binaryPolyCount = 0; for (int faceIndex = 0; faceIndex < mesh.Faces.Count; faceIndex++) { if (cancellationToken.IsCancellationRequested) { return(false); } var face = mesh.Faces[faceIndex]; binaryPolyCount++; // save the normal (all 0 so it can compress better) WriteToBinaryStl(bw, mesh.Faces[faceIndex].normal); // save the position WriteToBinaryStl(bw, mesh.Vertices[face.v0]); WriteToBinaryStl(bw, mesh.Vertices[face.v1]); WriteToBinaryStl(bw, mesh.Vertices[face.v2]); // and the attribute bw.Write((ushort)0); } bw.BaseStream.Position = 80; // the number of triangles bw.Write(binaryPolyCount); } break; } return(true); }
private static string SaveAndGetFilenameForMaterial(MeshGroup extruderMeshGroup, List<int> materialIndexsToSaveInThisSTL) { string fileName = Path.ChangeExtension(Path.GetRandomFileName(), ".stl"); string applicationUserDataPath = ApplicationDataStorage.ApplicationUserDataPath; string folderToSaveStlsTo = Path.Combine(applicationUserDataPath, "data", "temp", "amf_to_stl"); if (!Directory.Exists(folderToSaveStlsTo)) { Directory.CreateDirectory(folderToSaveStlsTo); } MeshOutputSettings settings = new MeshOutputSettings(); settings.MaterialIndexsToSave = materialIndexsToSaveInThisSTL; string extruder1StlFileToSlice = Path.Combine(folderToSaveStlsTo, fileName); MeshFileIo.Save(extruderMeshGroup, extruder1StlFileToSlice, settings); return extruder1StlFileToSlice; }
protected static void SaveToLibraryFolder(PrintItemWrapper printItemWrapper, List<MeshGroup> meshGroups, bool AbsolutePositioned) { string[] metaData = { "Created By", "MatterControl" }; if (AbsolutePositioned) { metaData = new string[] { "Created By", "MatterControl", "BedPosition", "Absolute" }; } // if it is not already in the right location if (!printItemWrapper.FileLocation.Contains(ApplicationDataStorage.Instance.ApplicationLibraryDataPath)) { // save a copy to the library and update this to point at it string fileName = Path.ChangeExtension(Path.GetRandomFileName(), ".amf"); printItemWrapper.FileLocation = Path.Combine(ApplicationDataStorage.Instance.ApplicationLibraryDataPath, fileName); MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); MeshFileIo.Save(meshGroups, printItemWrapper.FileLocation, outputInfo); } }
public static bool Save(MeshGroup meshGroupToSave, string meshPathAndFileName, MeshOutputSettings outputInfo = null) { List <MeshGroup> meshGroupsToSave = new List <MeshGroup>(); meshGroupsToSave.Add(meshGroupToSave); return(Save(meshGroupsToSave, meshPathAndFileName, outputInfo)); }
public static bool Save(List<MeshGroup> meshToSave, Stream stream, MeshOutputSettings outputInfo) { TextWriter amfFile = new StreamWriter(stream); amfFile.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>"); amfFile.WriteLine("<amf unit=\"millimeter\" version=\"1.1\">"); if (outputInfo != null) { foreach (KeyValuePair<string, string> metaData in outputInfo.MetaDataKeyValue) { amfFile.WriteLine(Indent(1) + "<metadata type=\"{0}\">{1}</metadata>".FormatWith(metaData.Key, metaData.Value)); } } { int objectId = 1; foreach (MeshGroup meshGroup in meshToSave) { amfFile.WriteLine(Indent(1) + "<object id=\"{0}\">".FormatWith(objectId++)); { int vertexCount = 0; List<int> meshVertexStart = new List<int>(); amfFile.WriteLine(Indent(2) + "<mesh>"); { amfFile.WriteLine(Indent(3) + "<vertices>"); { foreach (Mesh mesh in meshGroup.Meshes) { meshVertexStart.Add(vertexCount); foreach (Vertex vertex in mesh.Vertices) { Vector3 position = vertex.Position; amfFile.WriteLine(Indent(4) + "<vertex>"); { amfFile.WriteLine(Indent(5) + "<coordinates>"); amfFile.WriteLine(Indent(6) + "<x>{0}</x>".FormatWith(position.x)); amfFile.WriteLine(Indent(6) + "<y>{0}</y>".FormatWith(position.y)); amfFile.WriteLine(Indent(6) + "<z>{0}</z>".FormatWith(position.z)); amfFile.WriteLine(Indent(5) + "</coordinates>"); } amfFile.WriteLine(Indent(4) + "</vertex>"); vertexCount++; } } } amfFile.WriteLine(Indent(3) + "</vertices>"); for (int meshIndex = 0; meshIndex < meshGroup.Meshes.Count; meshIndex++) { int firstVertexIndex = meshVertexStart[meshIndex]; Mesh mesh = meshGroup.Meshes[meshIndex]; MeshMaterialData material = MeshMaterialData.Get(mesh); if (material.MaterialIndex == -1) { amfFile.WriteLine(Indent(3) + "<volume>"); } else { amfFile.WriteLine(Indent(3) + "<volume materialid=\"{0}\">".FormatWith(material.MaterialIndex)); } { for (int faceIndex = 0; faceIndex < mesh.Faces.Count; faceIndex++) { Face face = mesh.Faces[faceIndex]; List<Vertex> positionsCCW = new List<Vertex>(); foreach (FaceEdge faceEdge in face.FaceEdges()) { positionsCCW.Add(faceEdge.firstVertex); } int numPolys = positionsCCW.Count - 2; int secondIndex = 1; int thirdIndex = 2; for (int polyIndex = 0; polyIndex < numPolys; polyIndex++) { amfFile.WriteLine(Indent(4) + "<triangle>"); amfFile.WriteLine(Indent(5) + "<v1>{0}</v1>".FormatWith(firstVertexIndex + mesh.Vertices.IndexOf(positionsCCW[0]))); amfFile.WriteLine(Indent(5) + "<v2>{0}</v2>".FormatWith(firstVertexIndex + mesh.Vertices.IndexOf(positionsCCW[secondIndex]))); amfFile.WriteLine(Indent(5) + "<v3>{0}</v3>".FormatWith(firstVertexIndex + mesh.Vertices.IndexOf(positionsCCW[thirdIndex]))); amfFile.WriteLine(Indent(4) + "</triangle>"); secondIndex = thirdIndex; thirdIndex++; } } } amfFile.WriteLine(Indent(3) + "</volume>"); } } amfFile.WriteLine(Indent(2) + "</mesh>"); } amfFile.WriteLine(Indent(1) + "</object>"); } HashSet<int> materials = new HashSet<int>(); foreach (MeshGroup meshGroup in meshToSave) { foreach (Mesh mesh in meshGroup.Meshes) { MeshMaterialData material = MeshMaterialData.Get(mesh); if (material.MaterialIndex != -1) { materials.Add(material.MaterialIndex); } } } foreach (int material in materials) { amfFile.WriteLine(Indent(1) + "<material id=\"{0}\">".FormatWith(material)); amfFile.WriteLine(Indent(2) + "<metadata type=\"Name\">Material {0}</metadata>".FormatWith(material)); amfFile.WriteLine(Indent(1) + "</material>"); } } amfFile.WriteLine("</amf>"); amfFile.Flush(); return true; }
public static bool Save(Mesh mesh, string meshPathAndFileName, MeshOutputSettings outputInfo = null) { return(Save(new MeshGroup(mesh), meshPathAndFileName, outputInfo)); }
private void MergeAndSavePartsDoWork(SaveAsWindow.SaveAsReturnInfo returnInfo) { if (returnInfo != null) { PrintItem printItem = new PrintItem(); printItem.Name = returnInfo.newName; printItem.FileLocation = Path.GetFullPath(returnInfo.fileNameAndPath); printItemWrapper = new PrintItemWrapper(printItem, returnInfo.destinationLibraryProvider.GetProviderLocator()); } // we sent the data to the asynch lists but we will not pull it back out (only use it as a temp holder). PushMeshGroupDataToAsynchLists(TraceInfoOpperation.DO_COPY); Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; try { // push all the transforms into the meshes for (int i = 0; i < asynchMeshGroups.Count; i++) { asynchMeshGroups[i].Transform(asynchMeshGroupTransforms[i].TotalTransform); bool continueProcessing; ReportProgressChanged((i + 1) * .4 / asynchMeshGroups.Count, "", out continueProcessing); } saveSucceded = true; string[] metaData = { "Created By", "MatterControl", "BedPosition", "Absolute" }; MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); if (Path.GetExtension(printItemWrapper.FileLocation).ToUpper() == ".STL") { printItemWrapper.FileLocation = Path.ChangeExtension(printItemWrapper.FileLocation, ".AMF"); } MeshFileIo.Save(asynchMeshGroups, printItemWrapper.FileLocation, outputInfo); printItemWrapper.ReportFileChange(); if (returnInfo != null && returnInfo.destinationLibraryProvider != null) { // save this part to correct library provider LibraryProvider libraryToSaveTo = returnInfo.destinationLibraryProvider; if (libraryToSaveTo != null) { libraryToSaveTo.AddItem(printItemWrapper); libraryToSaveTo.Dispose(); } } else // we have already save it and the library should pick it up { } } catch (System.UnauthorizedAccessException e2) { Debug.Print(e2.Message); GuiWidget.BreakInDebugger(); saveSucceded = false; UiThread.RunOnIdle(() => { //Do something special when unauthorized? StyledMessageBox.ShowMessageBox(null, "Oops! Unable to save changes.", "Unable to save"); }); } catch(Exception e) { Debug.Print(e.Message); GuiWidget.BreakInDebugger(); saveSucceded = false; UiThread.RunOnIdle(() => { StyledMessageBox.ShowMessageBox(null, "Oops! Unable to save changes.", "Unable to save"); }); } }
public static Mesh DoMerge(List<MeshGroup> meshGroupsToMerge, MeshOutputSettings outputInfo) { Mesh allPolygons = new Mesh(); if (outputInfo.CsgOptionState == MeshOutputSettings.CsgOption.DoCsgMerge) { foreach (MeshGroup meshGroup in meshGroupsToMerge) { foreach (Mesh mesh in meshGroup.Meshes) { allPolygons = CsgOperations.Union(allPolygons, mesh); } } } else { foreach (MeshGroup meshGroup in meshGroupsToMerge) { foreach (Mesh mesh in meshGroup.Meshes) { int currentMeshMaterialIntdex = MeshMaterialData.Get(mesh).MaterialIndex; if (outputInfo.MaterialIndexsToSave == null || outputInfo.MaterialIndexsToSave.Contains(currentMeshMaterialIntdex)) { foreach (Face face in mesh.Faces) { List<Vertex> faceVertices = new List<Vertex>(); foreach (FaceEdge faceEdgeToAdd in face.FaceEdges()) { // we allow duplicates (the true) to make sure we are not changing the loaded models acuracy. Vertex newVertex = allPolygons.CreateVertex(faceEdgeToAdd.firstVertex.Position, CreateOption.CreateNew, SortOption.WillSortLater); faceVertices.Add(newVertex); } // we allow duplicates (the true) to make sure we are not changing the loaded models acuracy. allPolygons.CreateFace(faceVertices.ToArray(), CreateOption.CreateNew); } } } } allPolygons.CleanAndMergMesh(); } return allPolygons; }
public static bool SaveUncompressed(List <MeshGroup> meshToSave, string fileName, MeshOutputSettings outputInfo = null) { using (FileStream file = new FileStream(fileName, FileMode.Create, FileAccess.Write)) { return(Save(meshToSave, file, outputInfo)); } }
private void MergeAndSavePartsDoWork(SaveAsWindow.SaveAsReturnInfo returnInfo) { if (returnInfo != null) { PrintItem printItem = new PrintItem(); printItem.Name = returnInfo.newName; printItem.FileLocation = Path.GetFullPath(returnInfo.fileNameAndPath); printItemWrapper = new PrintItemWrapper(printItem, returnInfo.destinationLibraryProvider.GetProviderLocator()); } // we sent the data to the async lists but we will not pull it back out (only use it as a temp holder). PushMeshGroupDataToAsynchLists(TraceInfoOpperation.DO_COPY); Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; try { // push all the transforms into the meshes for (int i = 0; i < asyncMeshGroups.Count; i++) { asyncMeshGroups[i].Transform(asyncMeshGroupTransforms[i]); bool continueProcessing; ReportProgressChanged((i + 1) * .4 / asyncMeshGroups.Count, "", out continueProcessing); } string[] metaData = { "Created By", "MatterControl", "BedPosition", "Absolute" }; MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); // If null we are replacing a file from the current print item wrapper if (returnInfo == null) { var fileInfo = new FileInfo(printItemWrapper.FileLocation); bool requiresTypeChange = !fileInfo.Extension.Equals(".amf", StringComparison.OrdinalIgnoreCase); if (requiresTypeChange && !printItemWrapper.UseIncrementedNameDuringTypeChange) { // Not using incremented file name, simply change to AMF printItemWrapper.FileLocation = Path.ChangeExtension(printItemWrapper.FileLocation, ".amf"); } else if (requiresTypeChange) { string newFileName; string incrementedFileName; // Switching from .stl, .obj or similar to AMF. Save the file and update the // the filename with an incremented (n) value to reflect the extension change in the UI string fileName = Path.GetFileNameWithoutExtension(fileInfo.Name); // Drop bracketed number sections from our source filename to ensure we don't generate something like "file (1) (1).amf" if (fileName.Contains("(")) { fileName = fileNameNumberMatch.Replace(fileName, "").Trim(); } // Generate and search for an incremented file name until no match is found at the target directory int foundCount = 0; do { newFileName = string.Format("{0} ({1})", fileName, ++foundCount); incrementedFileName = Path.Combine(fileInfo.DirectoryName, newFileName + ".amf"); // Continue incrementing while any matching file exists } while (Directory.GetFiles(fileInfo.DirectoryName, newFileName + ".*").Any()); // Change the FileLocation to the new AMF file printItemWrapper.FileLocation = incrementedFileName; } try { // get a new location to save to string tempFileNameToSaveTo = ApplicationDataStorage.Instance.GetTempFileName("amf"); // save to the new temp location bool savedSuccessfully = MeshFileIo.Save(asyncMeshGroups, tempFileNameToSaveTo, outputInfo, ReportProgressChanged); // Swap out the files if the save operation completed successfully if (savedSuccessfully && File.Exists(tempFileNameToSaveTo)) { // Ensure the target path is clear if(File.Exists(printItemWrapper.FileLocation)) { File.Delete(printItemWrapper.FileLocation); } // Move the newly saved file back into place File.Move(tempFileNameToSaveTo, printItemWrapper.FileLocation); // Once the file is swapped back into place, update the PrintItem to account for extension change printItemWrapper.PrintItem.Commit(); } } catch(Exception ex) { Trace.WriteLine("Error saving file: ", ex.Message); } } else // we are saving a new file and it will not exist until we are done { MeshFileIo.Save(asyncMeshGroups, printItemWrapper.FileLocation, outputInfo, ReportProgressChanged); } // Wait for a second to report the file changed to give the OS a chance to finish closing it. UiThread.RunOnIdle(printItemWrapper.ReportFileChange, 3); if (returnInfo != null && returnInfo.destinationLibraryProvider != null) { // save this part to correct library provider LibraryProvider libraryToSaveTo = returnInfo.destinationLibraryProvider; if (libraryToSaveTo != null) { libraryToSaveTo.AddItem(printItemWrapper); libraryToSaveTo.Dispose(); } } else // we have already saved it and the library should pick it up { } saveSucceded = true; } catch (System.UnauthorizedAccessException e2) { Debug.Print(e2.Message); GuiWidget.BreakInDebugger(); saveSucceded = false; UiThread.RunOnIdle(() => { //Do something special when unauthorized? StyledMessageBox.ShowMessageBox(null, "Oops! Unable to save changes.", "Unable to save"); }); } catch (Exception e) { Debug.Print(e.Message); GuiWidget.BreakInDebugger(); saveSucceded = false; UiThread.RunOnIdle(() => { StyledMessageBox.ShowMessageBox(null, "Oops! Unable to save changes.", "Unable to save"); }); } }
private void mergeAndSavePartsBackgroundWorker_DoWork(object sender, DoWorkEventArgs e) { SaveAsWindow.SaveAsReturnInfo returnInfo = e.Argument as SaveAsWindow.SaveAsReturnInfo; if (returnInfo != null) { printItemWrapper = returnInfo.printItemWrapper; } // we sent the data to the asynch lists but we will not pull it back out (only use it as a temp holder). PushMeshGroupDataToAsynchLists(TraceInfoOpperation.DO_COPY); Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; try { // push all the transforms into the meshes for (int i = 0; i < asynchMeshGroups.Count; i++) { asynchMeshGroups[i].Transform(asynchMeshGroupTransforms[i].TotalTransform); bool continueProcessing; ReportProgressChanged((i + 1) * .4 / asynchMeshGroups.Count, "", out continueProcessing); } saveSucceded = true; string[] metaData = { "Created By", "MatterControl", "BedPosition", "Absolute" }; MeshOutputSettings outputInfo = new MeshOutputSettings(MeshOutputSettings.OutputType.Binary, metaData); MeshFileIo.Save(asynchMeshGroups, printItemWrapper.FileLocation, outputInfo); printItemWrapper.OnFileHasChanged(); } catch (System.UnauthorizedAccessException) { saveSucceded = false; UiThread.RunOnIdle(() => { //Do something special when unauthorized? StyledMessageBox.ShowMessageBox(null, "Oops! Unable to save changes.", "Unable to save"); }); } catch { saveSucceded = false; UiThread.RunOnIdle(() => { StyledMessageBox.ShowMessageBox(null, "Oops! Unable to save changes.", "Unable to save"); }); } e.Result = e.Argument; }
public static bool Save(List <MeshGroup> meshToSave, Stream stream, MeshOutputSettings outputInfo) { TextWriter amfFile = new StreamWriter(stream); amfFile.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>"); amfFile.WriteLine("<amf unit=\"millimeter\" version=\"1.1\">"); if (outputInfo != null) { foreach (KeyValuePair <string, string> metaData in outputInfo.MetaDataKeyValue) { amfFile.WriteLine(Indent(1) + "<metadata type=\"{0}\">{1}</metadata>".FormatWith(metaData.Key, metaData.Value)); } } { int objectId = 1; bool continueProcessing; int totalMeshes = 0; foreach (MeshGroup meshGroup in meshToSave) { foreach (Mesh mesh in meshGroup.Meshes) { totalMeshes++; } } double ratioPerMesh = 1d / totalMeshes; double currentRation = 0; for (int meshGroupIndex = 0; meshGroupIndex < meshToSave.Count; meshGroupIndex++) { MeshGroup meshGroup = meshToSave[meshGroupIndex]; amfFile.WriteLine(Indent(1) + "<object id=\"{0}\">".FormatWith(objectId++)); { int vertexCount = 0; List <int> meshVertexStart = new List <int>(); amfFile.WriteLine(Indent(2) + "<mesh>"); { amfFile.WriteLine(Indent(3) + "<vertices>"); { for (int meshIndex = 0; meshIndex < meshGroup.Meshes.Count; meshIndex++) { Mesh mesh = meshGroup.Meshes[meshIndex]; double vertCount = (double)mesh.Vertices.Count; meshVertexStart.Add(vertexCount); for (int vertexIndex = 0; vertexIndex < mesh.Vertices.Count; vertexIndex++) { Vertex vertex = mesh.Vertices[vertexIndex]; if (outputInfo.ReportProgress != null) { outputInfo.ReportProgress(currentRation + vertexIndex / vertCount * ratioPerMesh * .5, "", out continueProcessing); } Vector3 position = vertex.Position; amfFile.WriteLine(Indent(4) + "<vertex>"); { amfFile.WriteLine(Indent(5) + "<coordinates>"); amfFile.WriteLine(Indent(6) + "<x>{0}</x>".FormatWith(position.x)); amfFile.WriteLine(Indent(6) + "<y>{0}</y>".FormatWith(position.y)); amfFile.WriteLine(Indent(6) + "<z>{0}</z>".FormatWith(position.z)); amfFile.WriteLine(Indent(5) + "</coordinates>"); } amfFile.WriteLine(Indent(4) + "</vertex>"); vertexCount++; } currentRation += ratioPerMesh * .5; } } amfFile.WriteLine(Indent(3) + "</vertices>"); for (int meshIndex = 0; meshIndex < meshGroup.Meshes.Count; meshIndex++) { Mesh mesh = meshGroup.Meshes[meshIndex]; int firstVertexIndex = meshVertexStart[meshIndex]; MeshMaterialData material = MeshMaterialData.Get(mesh); if (material.MaterialIndex == -1) { amfFile.WriteLine(Indent(3) + "<volume>"); } else { amfFile.WriteLine(Indent(3) + "<volume materialid=\"{0}\">".FormatWith(material.MaterialIndex)); } double faceCount = (double)mesh.Faces.Count; for (int faceIndex = 0; faceIndex < mesh.Faces.Count; faceIndex++) { if (outputInfo.ReportProgress != null) { outputInfo.ReportProgress(currentRation + faceIndex / faceCount * ratioPerMesh * .5, "", out continueProcessing); } Face face = mesh.Faces[faceIndex]; List <Vertex> positionsCCW = new List <Vertex>(); foreach (FaceEdge faceEdge in face.FaceEdges()) { positionsCCW.Add(faceEdge.firstVertex); } int numPolys = positionsCCW.Count - 2; int secondIndex = 1; int thirdIndex = 2; for (int polyIndex = 0; polyIndex < numPolys; polyIndex++) { amfFile.WriteLine(Indent(4) + "<triangle>"); amfFile.WriteLine(Indent(5) + "<v1>{0}</v1>".FormatWith(firstVertexIndex + mesh.Vertices.IndexOf(positionsCCW[0]))); amfFile.WriteLine(Indent(5) + "<v2>{0}</v2>".FormatWith(firstVertexIndex + mesh.Vertices.IndexOf(positionsCCW[secondIndex]))); amfFile.WriteLine(Indent(5) + "<v3>{0}</v3>".FormatWith(firstVertexIndex + mesh.Vertices.IndexOf(positionsCCW[thirdIndex]))); amfFile.WriteLine(Indent(4) + "</triangle>"); secondIndex = thirdIndex; thirdIndex++; } } currentRation += ratioPerMesh * .5; amfFile.WriteLine(Indent(3) + "</volume>"); } } amfFile.WriteLine(Indent(2) + "</mesh>"); } amfFile.WriteLine(Indent(1) + "</object>"); } HashSet <int> materials = new HashSet <int>(); foreach (MeshGroup meshGroup in meshToSave) { foreach (Mesh mesh in meshGroup.Meshes) { MeshMaterialData material = MeshMaterialData.Get(mesh); if (material.MaterialIndex != -1) { materials.Add(material.MaterialIndex); } } } foreach (int material in materials) { amfFile.WriteLine(Indent(1) + "<material id=\"{0}\">".FormatWith(material)); amfFile.WriteLine(Indent(2) + "<metadata type=\"Name\">Material {0}</metadata>".FormatWith(material)); amfFile.WriteLine(Indent(1) + "</material>"); } } amfFile.WriteLine("</amf>"); amfFile.Flush(); return(true); }