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-2023, CADEX. All rights reserved.
//
// This file is part of the CAD Exchanger 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 System;
using System.Collections.Generic;
 
using PartVecType = System.Collections.Generic.List<cadex.ModelData_Part>;
 
namespace unfolder
{
    class Program
    {
        static int Main(string[] args)
        {
            // Add runtime path to CAD Exchanger libraries
            cadex.helpers.LoadLibrarySearchDirectory.SetupDllDirectory();
 
            string aKey = LicenseKey.Value();
            string anMTKKey = MTKLicenseKey.Value();
 
            // Activate the license (aKey must be defined in cadex_license.cs
            // and anMTKKey should be defined in mtk_license.cs)
            if (!LicenseManager.Activate(aKey))
            {
                Console.WriteLine("Failed to activate CAD Exchanger license.");
                return 1;
            }
            if (!LicenseManager.Activate(anMTKKey))
            {
                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];
 
            ModelData_Model aModel = new ModelData_Model();
            var aReader = new ModelData_ModelReader();
 
            // Reading the file
            if (!aReader.Read(new Base_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 ModelData_SceneGraphElementUniqueVisitor(aPartProcessor);
            aModel.Accept(aVisitor);
 
            return 0;
        }
 
        class PartProcessor : ModelData_Model.VoidElementVisitor
        {
            public PartProcessor(string theDrawingFolderPath)
            {
                myUnfolder = new SheetMetal_Unfolder();
                myDrawingFolderPath = theDrawingFolderPath;
            }
 
            public override void Apply(ModelData_Part thePart)
            {
                string aPartName = thePart.Name().IsEmpty() ? "noname" : thePart.Name().Data();
 
                var aBRep = thePart.BRepRepresentation();
                if (aBRep != null)
                {
                    // Looking for a suitable body
                    ModelData_BodyList aBodyList = aBRep.Get();
                    for (uint i = 0; i < aBodyList.Size(); ++i)
                    {
                        ModelData_Body aBody = aBodyList.Element(i);
 
                        var aShapeIt = new ModelData_Shape.Iterator(aBody);
                        while (aShapeIt.HasNext())
                        {
                            var aShape = aShapeIt.Next();
                            if (aShape.Type() == ModelData_ShapeType.ModelData_ST_Solid)
                            {
                                Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - solid #{i} has:\n");
                                ProcessSolid(ModelData_Solid.Cast(aShape), aPartName, i);
                            }
                            else if (aShape.Type() == ModelData_ShapeType.ModelData_ST_Shell)
                            {
                                Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - shell #{i} has:\n");
                                ProcessShell(ModelData_Shell.Cast(aShape), aPartName, i);
                            }
                        }
                    }
                }
 
                ++myPartIndex;
            }
 
            public void ProcessSolid(ModelData_Solid theSolid, string thePartName, uint theShapeIndex)
            {
                double aThickness = CalculateInitialThicknessValue(theSolid);
                SheetMetal_FlatPattern aFlatPattern = myUnfolder.Perform(theSolid, aThickness);
                Base_UTF16String aFileName = DrawingFileName(thePartName, theShapeIndex, "solid");
                PrintFlatPatternAndWriteToDrawing(aFlatPattern, aFileName);
            }
 
            public void ProcessShell(ModelData_Shell theShell, string thePartName, uint theShapeIndex)
            {
                SheetMetal_FlatPattern aFlatPattern = myUnfolder.Perform(theShell);
                Base_UTF16String aFileName = DrawingFileName(thePartName, theShapeIndex, "shell");
                PrintFlatPatternAndWriteToDrawing(aFlatPattern, aFileName);
            }
 
            private Base_UTF16String DrawingFileName(string thePartName, uint theShapeIndex, string theShapeName)
            {
                string aPartName = "Part " + myPartIndex.ToString() + " [" + thePartName + "]";
                string aShapeName = theShapeName + " " + theShapeIndex.ToString();
                Base_UTF16String aFileName = new Base_UTF16String(myDrawingFolderPath + "/" + aPartName + " - " + aShapeName + " - drawing.dxf");
                return aFileName;
            }
 
            SheetMetal_Unfolder myUnfolder;
            string myDrawingFolderPath;
            private uint myPartIndex = 0;
        }
 
        static void PrintFlatPatternAndWriteToDrawing(SheetMetal_FlatPattern theFlatPattern, Base_UTF16String theDrawingFileName)
        {
            if (theFlatPattern.IsNull())
            {
                Console.WriteLine($"    Failed to create flat pattern.");
                return;
            }
 
            PrintFlatPattern(theFlatPattern);
 
            if (WriteToDrawing(theFlatPattern, theDrawingFileName))
            {
                Console.WriteLine($"    A drawing of the flat pattern has been saved to {theDrawingFileName.Data()}");
            }
            else
            {
                Console.WriteLine($"    Failed to save drawing of the flat pattern to {theDrawingFileName.Data()}");
            }
        }
 
        static void PrintFlatPattern(SheetMetal_FlatPattern theFlatPattern)
        {
            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 bool WriteToDrawing(SheetMetal_FlatPattern theFlatPattern, Base_UTF16String theFilePath)
        {
            ModelData_Drawing aDrawing = theFlatPattern.ToDrawing();
            if (aDrawing == null)
            {
                return false;
            }
 
            var aDrawingModel = new ModelData_Model();
            aDrawingModel.SetDrawing(aDrawing);
 
            var aWriter = new ModelData_ModelWriter();
            bool aRes = aWriter.Write(aDrawingModel, theFilePath);
            return aRes;
        }
 
        //Compute approximate thickness value, which can be used as the input thickness value for SheetMetal_Unfolder.
        static double CalculateInitialThicknessValue(ModelData_Shape theShape)
        {
            double aVolume = ModelAlgo_ValidationProperty.ComputeVolume(theShape);
            double aSurfaceArea = ModelAlgo_ValidationProperty.ComputeSurfaceArea(theShape);
            double aThickness = aVolume / (aSurfaceArea / 2.0);
 
            return aThickness;
        }
    }
}