sheet_metal/unfolder/Program.cs

Refer to the Sheet Metal Unfolder Example

// ****************************************************************************
// $Id$
//
// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.
// Copyright (C) 2014-2025, CADEX. All rights reserved.
//
// This file is part of the Manufacturing Toolkit software.
//
// You may use this file under the terms of the BSD license as follows:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// ****************************************************************************
 
using cadex;
using cadex.ModelData;
using System;
using System.Collections.Generic;
 
using PartVecType = System.Collections.Generic.List<cadex.ModelData.Part>;
 
namespace unfolder
{
    class Program
    {
        static int Main(string[] args)
        {
            string aKey = MTKLicenseKey.Value();
 
            // Activate the license (the key should be defined in mtk_license.cs)
            if (!LicenseManager.Activate(aKey))
            {
                Console.WriteLine("Failed to activate Manufacturing Toolkit license.");
                return 1;
            }
 
            if (args.Length != 2)
            {
                Console.WriteLine("Usage: " +
                    $"{System.Reflection.Assembly.GetExecutingAssembly().Location} <input_file> <output_folder>, where:");
                Console.WriteLine($"    <input_file> is a name of the file to be read");
                Console.WriteLine($"    <output_folder> is a name of the folder where DXF files with drawing to be written");
                return 1;
            }
 
            string aSource = args[0];
            string aDrawingPath = args[1];
 
            Model aModel = new Model();
            var aReader = new ModelReader();
 
            // Reading the file
            if (!aReader.Read(new UTF16String(aSource), aModel))
            {
                Console.WriteLine($"Failed to read the file {aSource}");
                return 1;
            }
            Console.WriteLine($"Model: {aModel.Name()}\n");
 
            var aPartProcessor = new PartProcessor(aDrawingPath);
            var aVisitor = new ModelElementUniqueVisitor(aPartProcessor);
            aModel.Accept(aVisitor);
 
            return 0;
        }
 
        class PartProcessor : ModelElementVoidVisitor
        {
            public PartProcessor(string theDrawingFolderPath)
            {
                myUnfolder = new SheetMetal_Unfolder();
                myDrawingFolderPath = theDrawingFolderPath;
            }
 
            public override void Apply(Part thePart)
            {
                string aPartName = thePart.Name().IsEmpty() ? "noname" : thePart.Name().ToString();
 
                var aBodyVec = thePart.Bodies();
                if (aBodyVec.Count != 0)
                {
                    // Looking for a suitable body
                    for (int i = 0; i < aBodyVec.Count; ++i)
                    {
                        Body aBody = aBodyVec[i];
 
                        var aShapeIt = new ShapeIterator(aBody);
                        foreach (var aShape in aShapeIt)
                        {
                            if (aShape.Type() == ShapeType.Solid)
                            {
                                Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - Solid #{i} has:\n");
                                ProcessSolid(Solid.Cast(aShape), aPartName, i);
                            }
                            else if (aShape.Type() == ShapeType.Shell)
                            {
                                Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - Shell #{i} has:\n");
                                ProcessShell(Shell.Cast(aShape), aPartName, i);
                            }
                        }
                    }
                }
 
                ++myPartIndex;
            }
 
            public void ProcessSolid(Solid theSolid, string thePartName, int theShapeIndex)
            {
                SheetMetal_FlatPattern aFlatPattern = myUnfolder.Perform(theSolid);
                PrintFlatPatternInfo(aFlatPattern);
 
                UTF16String aDrawingFileName = DrawingFileName(thePartName, theShapeIndex, "Solid");
                WriteToDrawing(aFlatPattern, aDrawingFileName);
            }
 
            public void ProcessShell(Shell theShell, string thePartName, int theShapeIndex)
            {
                SheetMetal_FlatPattern aFlatPattern = myUnfolder.Perform(theShell);
                PrintFlatPatternInfo(aFlatPattern);
 
                UTF16String aDrawingFileName = DrawingFileName(thePartName, theShapeIndex, "Shell");
                WriteToDrawing(aFlatPattern, aDrawingFileName);
            }
 
            public UTF16String DrawingFileName(string thePartName, int theShapeIndex, string theShapeName)
            {
                string aPartName = "Part " + myPartIndex.ToString() + " [" + thePartName + "]";
                string aShapeName = theShapeName + " " + theShapeIndex.ToString();
                UTF16String aFileName = new UTF16String(myDrawingFolderPath + "/" + aPartName + " - " + aShapeName + " - drawing.dxf");
                return aFileName;
            }
 
            SheetMetal_Unfolder myUnfolder;
            string myDrawingFolderPath;
            private int myPartIndex = 0;
        }
 
        static void PrintFlatPatternInfo(SheetMetal_FlatPattern theFlatPattern)
        {
            if (theFlatPattern == null)
            {
                Console.WriteLine($"    Failed to create flat pattern.");
                return;
            }
 
            Console.WriteLine($"    Flat Pattern with:");
            Console.WriteLine($"          length: {theFlatPattern.Length()} mm");
            Console.WriteLine($"          width: {theFlatPattern.Width()} mm");
            Console.WriteLine($"          thickness: {theFlatPattern.Thickness()} mm");
            Console.WriteLine($"          perimeter: {theFlatPattern.Perimeter()} mm");
        }
 
        static void WriteToDrawing(SheetMetal_FlatPattern theFlatPattern, UTF16String theFilePath)
        {
            if (theFlatPattern == null)
            {
                Console.WriteLine($"    Failed to create flat pattern.");
                return;
            }
 
            var aDrawingParams = new SheetMetal_FlatPattern.DrawingParameters();
            aDrawingParams.SetIsIgnoreBendingLines(true);
 
            var aDrawing = theFlatPattern.ToDrawing(aDrawingParams);
 
            var aDrawingModel = new Model();
            aDrawingModel.SetDrawing(aDrawing);
 
            var aWriter = new ModelWriter();
            if (aWriter.Write(aDrawingModel, theFilePath))
            {
                Console.WriteLine($"    A drawing of the flat pattern has been saved to {theFilePath.Data()}");
            }
            else
            {
                Console.WriteLine($"    Failed to save drawing of the flat pattern to {theFilePath.Data()}");
            }
        }
    }
}