MTKConverter/Program.cs

Refer to the MTK Converter Example

MTKConverter_PartProcessor.cs

// ****************************************************************************
// $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.Collections.Generic;
 
namespace mtkconverter
{
    class MTKConverter_ProcessData
    {
        protected MTKConverter_ProcessData(Part thePart)
        {
            myPart = thePart;
        }
 
        public Part myPart;
    }
 
    abstract class MTKConverter_PartProcessor : ModelElementVoidVisitor
    {
        protected MTKConverter_PartProcessor()
        {
            myData = new List<MTKConverter_ProcessData>();
        }
 
        public List<MTKConverter_ProcessData> myData;
 
        public override void Apply(Part thePart)
        {
            bool aPartWasProcessed = false;
            var aProcessData = CreateProcessData(thePart);
 
            var aBodyList = thePart.Bodies();
            for (int i = 0; i < aBodyList.Count; ++i)
            {
                Body aBody = aBodyList[i];
                var aShapeIt = new ShapeIterator(aBody);
                foreach (var aShape in aShapeIt)
                {
                    if (aShape.Type() == ShapeType.Solid)
                    {
                        ProcessSolid(aProcessData, Solid.Cast(aShape));
                        aPartWasProcessed = true;
                    }
                    else if (aShape.Type() == ShapeType.Shell)
                    {
                        ProcessShell(aProcessData, Shell.Cast(aShape));
                        aPartWasProcessed = true;
                    }
                }
            }
            if (aPartWasProcessed)
            {
                PostProcessPart(thePart);
                myData.Add(aProcessData);
            }
        }
        public abstract MTKConverter_ProcessData CreateProcessData(Part thePart);
 
        public abstract void ProcessSolid(MTKConverter_ProcessData theProcessData, Solid theSolid);
        public abstract void ProcessShell(MTKConverter_ProcessData theProcessData, Shell theShell);
 
        public abstract void PostProcessPart(Part thePart);
    }
 
    abstract class MTKConverter_VoidPartProcessor : MTKConverter_PartProcessor
    {
        public MTKConverter_VoidPartProcessor() : base() { }
 
        public override void ProcessSolid(MTKConverter_ProcessData theProcessData, Solid theSolid) { }
        public override void ProcessShell(MTKConverter_ProcessData theProcessData, Shell theShell) { }
 
        public override void PostProcessPart(Part thePart) { }
    }
}

MTKConverter_MachiningProcessor.cs

// ****************************************************************************
// $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;
 
namespace mtkconverter
{
    class MTKConverter_MachiningData : MTKConverter_ProcessData
    {
        public MTKConverter_MachiningData(Part thePart) : base(thePart)
        {
            myFeatureList = new MTKBase_FeatureList();
            myIssueList = new MTKBase_FeatureList();
        }
 
        public MTKBase_FeatureList myFeatureList;
        public MTKBase_FeatureList myIssueList;
        public Machining_OperationType myOperation;
    }
 
    class MTKConverter_MachiningProcessor : MTKConverter_VoidPartProcessor
    {
        public MTKConverter_MachiningProcessor(Machining_OperationType theOperation) : base()
        {
            myOperation = theOperation;
        }
 
        private Machining_OperationType myOperation;
 
        public override MTKConverter_ProcessData CreateProcessData(Part thePart)
        {
            return new MTKConverter_MachiningData(thePart);
        }
 
        public override void ProcessSolid(MTKConverter_ProcessData theProcessData, Solid theSolid)
        {
            var aMachiningData = theProcessData as MTKConverter_MachiningData;
            aMachiningData.myOperation = myOperation;
 
            Machining_FeatureRecognizer aFeatureRecognizer = new Machining_FeatureRecognizer();
            aFeatureRecognizer.Parameters().SetOperation(myOperation);
            Machining_Analyzer anAnalyzer = new Machining_Analyzer();
            anAnalyzer.AddTool(aFeatureRecognizer);
            Machining_Data aData = anAnalyzer.Perform(theSolid);
            if (aData.IsEmpty())
            {
                return;
            }
 
            //features
            aMachiningData.myFeatureList.Append(aData.FeatureList());
 
            //issues
            DFMMachining_DrillingAnalyzerParameters aDrillingParameters = new DFMMachining_DrillingAnalyzerParameters();
            DFMMachining_Analyzer aDrillingAnalyzer = new DFMMachining_Analyzer(aDrillingParameters);
            aMachiningData.myIssueList.Append(aDrillingAnalyzer.Perform(theSolid, aData));
 
            DFMMachining_MillingAnalyzerParameters aMillingParameters = new DFMMachining_MillingAnalyzerParameters();
            DFMMachining_Analyzer aMillingAnalyzer = new DFMMachining_Analyzer(aMillingParameters);
            MTKBase_FeatureList aMillingIssueList = aMillingAnalyzer.Perform(theSolid, aData);
            for (uint i = 0; i < aMillingIssueList.Size(); ++i)
            {
                MTKBase_Feature anIssue = aMillingIssueList.Feature(i);
                if (myOperation == Machining_OperationType.Machining_OT_LatheMilling
                    && !DFMMachining_DeepPocketIssue.CompareType(anIssue))
                {
                    continue;
                }
                aMachiningData.myIssueList.Append(anIssue);
            }
 
            if (myOperation == Machining_OperationType.Machining_OT_LatheMilling)
            {
                DFMMachining_TurningAnalyzerParameters aTurninigParameters = new DFMMachining_TurningAnalyzerParameters();
                DFMMachining_Analyzer aTurningAnalyzer = new DFMMachining_Analyzer(aTurninigParameters);
                MTKBase_FeatureList aTurningIssueList = aTurningAnalyzer.Perform(theSolid, aData);
 
                for (uint i = 0; i < aTurningIssueList.Size(); ++i)
                {
                    MTKBase_Feature anIssue = aTurningIssueList.Feature(i);
                    aMachiningData.myIssueList.Append(anIssue);
                }
            }
        }
    }
}

MTKConverter_SheetMetalProcessor.cs

// ****************************************************************************
// $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;
 
namespace mtkconverter
{
    class MTKConverter_UnfoldedPartData
    {
        public MTKConverter_UnfoldedPartData()
        {
            myFlatPatterns = new List<SheetMetal_FlatPattern>();
            myIssueList = new MTKBase_FeatureList();
        }
 
        public bool IsInit() { return myFlatPatterns.Count > 0; }
        public List<SheetMetal_FlatPattern> myFlatPatterns;
        public MTKBase_FeatureList myIssueList;
    }
 
    class MTKConverter_SheetMetalData : MTKConverter_ProcessData
    {
        public MTKConverter_SheetMetalData(Part thePart) : base(thePart)
        {
            myFeatureList = new MTKBase_FeatureList();
            myIssueList = new MTKBase_FeatureList();
            myUnfoldedPartData = new MTKConverter_UnfoldedPartData();
        }
 
        public bool myIsSheetMetalPart = false;
        public MTKBase_FeatureList myFeatureList;
        public MTKBase_FeatureList myIssueList;
        public MTKConverter_UnfoldedPartData myUnfoldedPartData;
    }
 
    class MTKConverter_SheetMetalProcessor : MTKConverter_VoidPartProcessor
    {
        public MTKConverter_SheetMetalProcessor(Model theUnfoldedModel) : base()
        {
            myAnalyzer = new SheetMetal_Analyzer();
            myAnalyzer.AddTool(new SheetMetal_FeatureRecognizer());
            myAnalyzer.AddTool(new SheetMetal_Unfolder());
 
            myUnfoldedModel = theUnfoldedModel;
            myCurrentUnfoldedBody = new SheetBody();
        }
 
        private SheetMetal_Analyzer myAnalyzer;
        private Model myUnfoldedModel;
        private SheetBody myCurrentUnfoldedBody;
 
        public override MTKConverter_ProcessData CreateProcessData(Part thePart)
        {
            return new MTKConverter_SheetMetalData(thePart);
        }
 
        public override void ProcessSolid(MTKConverter_ProcessData theProcessData, Solid theSolid)
        {
            SheetMetal_Data anSMData = myAnalyzer.Perform(theSolid);
            Process(theProcessData, anSMData);
        }
 
        public override void ProcessShell(MTKConverter_ProcessData theProcessData, Shell theShell)
        {
            SheetMetal_Data anSMData = myAnalyzer.Perform(theShell);
            Process(theProcessData, anSMData);
        }
 
        public override void PostProcessPart(Part thePart)
        {
            if (myCurrentUnfoldedBody.Shapes().Count == 0)
            {
                return;
            }
 
            Part anUnfoldedPart = new Part(thePart.Name());
            anUnfoldedPart.SetUuid(thePart.Uuid());
            anUnfoldedPart.AddBody(myCurrentUnfoldedBody);
 
            myUnfoldedModel.AddRoot(anUnfoldedPart);
            myCurrentUnfoldedBody = new SheetBody();
        }
 
        public void Process(MTKConverter_ProcessData theProcessData, SheetMetal_Data theData)
        {
            if (theData.IsEmpty())
            {
                return;
            }
 
            var anSMData = theProcessData as MTKConverter_SheetMetalData;
            anSMData.myIsSheetMetalPart = true;
            anSMData.myFeatureList.Append(theData.FeatureList());
            SheetMetal_FlatPattern aFlatPattern = theData.FlatPattern();
            Shell anUnfoldedShell = !aFlatPattern.IsNull() ? aFlatPattern.UnfoldedShell() : null;
 
            MTKConverter_UnfoldedPartData anUnfoldedData = anSMData.myUnfoldedPartData;
            if (anUnfoldedShell != null)
            {
                myCurrentUnfoldedBody.Append(anUnfoldedShell);
                anUnfoldedData.myFlatPatterns.Add(aFlatPattern);
            }
 
            DFMSheetMetal_Analyzer aDFMAnalyzer = new DFMSheetMetal_Analyzer();
            MTKBase_FeatureList anIssueList = aDFMAnalyzer.Perform(theData);
            for (uint i = 0; i < anIssueList.Size(); ++i)
            {
                MTKBase_Feature anIssue = anIssueList.Feature(i);
                if (anUnfoldedData.IsInit()
                    && (DFMSheetMetal_FlatPatternInterferenceIssue.CompareType(anIssue)
                        || DFMSheetMetal_NonStandardSheetSizeIssue.CompareType(anIssue)
                        || DFMSheetMetal_NonStandardSheetThicknessIssue.CompareType(anIssue)))
                {
                    anUnfoldedData.myIssueList.Append(anIssue);
                }
                else
                {
                    anSMData.myIssueList.Append(anIssue);
                }
            }
        }
    }
}

MTKConverter_Report.cs

// ****************************************************************************
// $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 cadex.Utilities;
using System.Collections.Generic;
using System.IO;
 
using PointPairType = System.Collections.Generic.KeyValuePair<cadex.Geom.Point, cadex.Geom.Point>;
 
namespace mtkconverter
{
    public struct Point
    {
        public Point(double theX, double theY, double theZ)
        {
            X = theX;
            Y = theY;
            Z = theZ;
        }
 
        public double X { get; }
        public double Y { get; }
        public double Z { get; }
 
        public override string ToString() => $"({FormattedString(X)}, {FormattedString(Y)}, {FormattedString(Z)})";
 
        private string FormattedString(double theValue)
        {
            System.Globalization.CultureInfo aCI = new System.Globalization.CultureInfo("en-US");
            return string.Format(aCI, "{0:0.00}", theValue);
        }
    }
 
    class MTKConverter_Report
    {
        public MTKConverter_Report()
        {
            myData = new List<MTKConverter_ProcessData>();
        }
 
        private List<MTKConverter_ProcessData> myData;
 
        public void AddData(MTKConverter_ProcessData theData)
        {
            myData.Add(theData);
        }
 
 
        public bool WriteToJSON(UTF16String thePath)
        {
            string aPath = thePath.ToString();
            if (File.Exists(aPath))
            {
                File.Delete(aPath);
            }
 
            try
            {
                using (StreamWriter aStream = File.CreateText(aPath))
                {
                    JSONWriter aWriter = new JSONWriter(aStream);
                    aWriter.OpenSection();
                    aWriter.WriteData("version", "1");
 
                    if (myData.Count == 0)
                    {
                        aWriter.WriteData("error", "The model doesn't contain any parts.");
                    }
                    else
                    {
                        aWriter.OpenArraySection("parts");
                        foreach (MTKConverter_ProcessData aProcessData in myData)
                        {
                            aWriter.OpenSection();
                            WritePartProcessData(aWriter, aProcessData);
                            aWriter.CloseSection();
                        }
                        aWriter.CloseArraySection();
                    }
                    aWriter.CloseSection();
                }
            }
            catch
            {
                return false;
            }
 
            return true;
        }
 
 
        private bool WriteFeatures(JSONWriter theWriter, string theGroupName, string theSubgroupName,
            MTKBase_FeatureList theFeatures, string theMessageForEmptyList)
        {
            theWriter.OpenSection(theSubgroupName);
            theWriter.WriteData("name", theGroupName);
 
            if (theFeatures.IsEmpty())
            {
                theWriter.WriteData("message", theMessageForEmptyList);
            }
            else
            {
                JSONSerializerParameters aParams = new JSONSerializerParameters();
                aParams.SetStartIndentLevel(theWriter.NestingLevel());
                JSONSerializer aJSONSerializer = new JSONSerializer(aParams);
                var aFeaturesJSON = aJSONSerializer.Serialize(theFeatures);
                theWriter.WriteRawData(aFeaturesJSON);
            }
 
            theWriter.CloseSection();
 
            return true;
        }
 
        private string MachiningProcessName(Machining_OperationType theOperation)
        {
            switch (theOperation)
            {
                case Machining_OperationType.Machining_OT_Milling: return "CNC Machining Milling";
                case Machining_OperationType.Machining_OT_LatheMilling: return "CNC Machining Lathe+Milling";
                default:
                    break;
            }
            return "CNC Machining";
        }
 
        private bool HasShapes(cadex.Collections.BodyList theBodies, ShapeType theType)
        {
            for (int i = 0, n = theBodies.Count; i < n; ++i)
            {
                Body aBody = theBodies[i];
                var aShapeIt = new ShapeIterator(aBody, theType);
                if (aShapeIt.HasNext())
                {
                    return true;
                }
            }
            return false;
        }
 
        private void WriteThicknessNode(JSONWriter theWriter, string theParamName, double theParamValue,
            PointPairType thePoints, string theNodeName)
        {
            cadex.Geom.Point aFirstPoint = thePoints.Key;
            cadex.Geom.Point aSecondPoint = thePoints.Value;
            theWriter.OpenSection(theNodeName);
            theWriter.WriteData("name", theParamName);
            theWriter.WriteData("units", "mm");
            theWriter.WriteData("value", theParamValue);
            theWriter.WriteData("firstPoint", new Point(aFirstPoint.X(), aFirstPoint.Y(), aFirstPoint.Z()));
            theWriter.WriteData("secondPoint", new Point(aSecondPoint.X(), aSecondPoint.Y(), aSecondPoint.Z()));
            theWriter.CloseSection();
        }
 
        private void WriteUnfoldedPartFeatures(JSONWriter theWriter, MTKConverter_UnfoldedPartData theData)
        {
            theWriter.OpenSection("featureRecognitionUnfolded");
            theWriter.WriteData("name", "Feature Recognition");
 
            if (theData.IsInit())
            {
                JSONSerializerParameters aParams = new JSONSerializerParameters();
                aParams.SetStartIndentLevel(4);
                JSONSerializer aJSONSerializer = new JSONSerializer(aParams);
                var aFeaturesJSON = aJSONSerializer.Serialize(theData.myFlatPatterns[0]);
                theWriter.WriteRawData(aFeaturesJSON);
            }
            else
            {
                theWriter.WriteData("message", "Unfolded part wasn't generated.");
            }
 
            theWriter.CloseSection();
        }
 
        private void WritePartProcessData(JSONWriter theWriter, MTKConverter_ProcessData theProcessData)
        {
            bool aRes = false;
            theWriter.WriteData("partId", theProcessData.myPart.Uuid());
 
            string anErrorMsg = "An error occurred while processing the part.";
            if (theProcessData is MTKConverter_MachiningData)
            {
                MTKConverter_MachiningData aMD = (MTKConverter_MachiningData)theProcessData;
                theWriter.WriteData("process", MachiningProcessName(aMD.myOperation));
                cadex.Collections.BodyList aBodies = aMD.myPart.Bodies();
                if (!aMD.myFeatureList.IsEmpty())
                {
                    WriteFeatures(theWriter, "Feature Recognition", "featureRecognition", aMD.myFeatureList, "");
                    WriteFeatures(theWriter, "Design for Manufacturing", "dfm", aMD.myIssueList,
                        "Part contains no DFM improvement suggestions.");
                    aRes = true;
                }
                else if (!HasShapes(aBodies, ShapeType.Solid))
                {
                    anErrorMsg = "The part can't be analyzed due to lack of: BRep representation or solids in BRep representation.";
                }
            }
            else if (theProcessData is MTKConverter_MoldingData)
            {
                MTKConverter_MoldingData aMoldingData = (MTKConverter_MoldingData)theProcessData;
                theWriter.WriteData("process", "Molding Analysis");
                cadex.Collections.BodyList aBodies = aMoldingData.myPart.Bodies();
                if (!aMoldingData.myFeatureList.IsEmpty())
                {
                    WriteFeatures(theWriter, "Feature Recognition", "featureRecognition", aMoldingData.myFeatureList, "");
                    WriteFeatures(theWriter, "Design for Manufacturing", "dfm", aMoldingData.myIssueList,
                        "Part contains no DFM improvement suggestions.");
                    aRes = true;
                }
                else if (!HasShapes(aBodies, ShapeType.Solid))
                {
                    anErrorMsg = "The part can't be analyzed due to lack of: " +
                        "BRep representation, solids in BRep representation or Poly representations.";
                }
            }
            else if (theProcessData is MTKConverter_SheetMetalData)
            {
                MTKConverter_SheetMetalData aSMD = (MTKConverter_SheetMetalData)theProcessData;
                theWriter.WriteData("process", "Sheet Metal");
                cadex.Collections.BodyList aBodies = aSMD.myPart.Bodies();
                if (aSMD.myIsSheetMetalPart)
                {
                    WriteFeatures(theWriter, "Feature Recognition", "featureRecognition", aSMD.myFeatureList,
                                   "Part contains no features.");
                    WriteFeatures(theWriter, "Design for Manufacturing", "dfm", aSMD.myIssueList,
                        "Part contains no DFM improvement suggestions.");
 
                    MTKConverter_UnfoldedPartData anUnfoldedPartData = aSMD.myUnfoldedPartData;
                    WriteUnfoldedPartFeatures(theWriter, anUnfoldedPartData);
                    if (anUnfoldedPartData.IsInit())
                    {
                        WriteFeatures(theWriter, "Design for Manufacturing", "dfmUnfolded", anUnfoldedPartData.myIssueList,
                                       "Unfolded part contains no DFM improvement suggestions.");
                    }
                    aRes = true;
                }
                else if (!HasShapes(aBodies, ShapeType.Solid) && !HasShapes(aBodies, ShapeType.Shell))
                {
                    anErrorMsg = "The part can't be analyzed due to lack of: BRep representation, solids and shells in BRep representation.";
                }
                else
                {
                    anErrorMsg = "The part wasn't recognized as a sheet metal part.";
                }
            }
            else if (theProcessData is MTKConverter_WallThicknessData)
            {
                MTKConverter_WallThicknessData aWTD = (MTKConverter_WallThicknessData)theProcessData;
                theWriter.WriteData("process", "Wall Thickness Analysis");
                cadex.Collections.BodyList aBodies = aWTD.myPart.Bodies();
                if (aWTD.myIsInit)
                {
                    WriteThicknessNode(theWriter, "Minimum Thickness", aWTD.myMinThickness, aWTD.myMinThicknessPoints, "minThickness");
                    WriteThicknessNode(theWriter, "Maximum Thickness", aWTD.myMaxThickness, aWTD.myMaxThicknessPoints, "maxThickness");
                    aRes = true;
                }
                else if (!HasShapes(aBodies, ShapeType.Solid))
                {
                    anErrorMsg = "The part can't be analyzed due to lack of: " +
                        "BRep representation, solids in BRep representation.";
                }
            }
            else
            {
                anErrorMsg = "Unrecognized process";
            }
 
            if (!aRes)
            {
                theWriter.WriteData("error", anErrorMsg);
            }
        }
    }
}

MTKConverter_Application.cs

// ****************************************************************************
// $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 cadex.View;
using System;
using System.Collections.Generic;
using System.IO;
 
namespace mtkconverter
{
    enum MTKConverter_ReturnCode
    {
        // General codes
        MTKConverter_RC_OK = 0,
        MTKConverter_RC_UnknownError = 1,
        MTKConverter_RC_GeneralException = 2,
        MTKConverter_RC_NoValidLicense = 3,
        MTKConverter_RC_InvalidArgumentsNumber = 4,
        MTKConverter_RC_InvalidArgument = 5,
 
        // Import errors
        MTKConverter_RC_UnsupportedVersion = 100,
        MTKConverter_RC_UnexpectedFormat = 101,
        MTKConverter_RC_UnsupportedFileVariant = 102,
        MTKConverter_RC_ImportError = 103,
 
        // Process errors
        MTKConverter_RC_ProcessError = 200,
 
        // Export errors
        MTKConverter_RC_ExportError = 300,
    }
 
    enum MTKConverter_ProcessType
    {
        MTKConverter_PT_Undefined = -1,
        MTKConverter_PT_WallThickness = 0,
        MTKConverter_PT_MachiningMilling,
        MTKConverter_PT_MachiningTurning,
        MTKConverter_PT_Molding,
        MTKConverter_PT_SheetMetal
    }
 
    //parse and execute command line
    enum Mode { NeutralMode, ImportMode, ProcessMode, ExportMode }
 
    class MTKConverter_Application
    {
        public MTKConverter_Application()
        {
        }
 
        public MTKConverter_ReturnCode Run(string[] args)
        {
            if (args.Length == 0 ||
                (args[0] == "-?") || (args[0] == "/?") ||
                (args[0] == "-h") || (args[0] == "--help"))
            {
                PrintUsage();
                return MTKConverter_ReturnCode.MTKConverter_RC_OK;
            }
 
            if (args.Length < 6)
            {
                Console.WriteLine("Invalid number of arguments. Please use \"-h\" or \"--help\" for usage information.");
                return MTKConverter_ReturnCode.MTKConverter_RC_InvalidArgumentsNumber;
            }
 
            Model aModel = new Model();
            Model aProcessModel = new Model();
 
            Mode aMode = Mode.NeutralMode;
            MTKConverter_Report aReport = new MTKConverter_Report();
 
            MTKConverter_ReturnCode aRes = MTKConverter_ReturnCode.MTKConverter_RC_OK;
            bool aToGenerateScreenshot = true;
 
            for (int i = 0; (i < args.Length) && (aRes == MTKConverter_ReturnCode.MTKConverter_RC_OK); ++i)
            {
                string anArgument = args[i];
                if (anArgument == "--no-screenshot")
                {
                    aToGenerateScreenshot = false;
                }
                else if (anArgument == "-i")
                {
                    aMode = Mode.ImportMode;
                }
                else if (anArgument == "-p")
                {
                    aMode = Mode.ProcessMode;
                }
                else if (anArgument == "-e")
                {
                    aMode = Mode.ExportMode;
                }
                else
                {
                    try
                    {
                        if (aMode == Mode.ImportMode)
                        {
                            aRes = Import(anArgument, aModel);
                        }
                        else if (aMode == Mode.ProcessMode)
                        {
                            aRes = Process(anArgument, aModel, aReport, aProcessModel);
                        }
                        else if (aMode == Mode.ExportMode)
                        {
                            aRes = Export(anArgument, aModel, aToGenerateScreenshot, aReport, aProcessModel);
                        }
                        else
                        {
                            Console.WriteLine($"ERROR!: Invalid argument {anArgument}. Exiting");
                            Console.WriteLine($"Type {System.Reflection.Assembly.GetExecutingAssembly().Location} -h for help.");
                            return MTKConverter_ReturnCode.MTKConverter_RC_InvalidArgument;
                        }
                        Console.WriteLine("Done.");
                    }
                    catch (Exception anE)
                    {
                        Console.WriteLine($"Failed.\nERROR: {anE.Message}");
                        return MTKConverter_ReturnCode.MTKConverter_RC_GeneralException;
                    }
                }
            }
            return aRes;
        }
 
        public void PrintUsage()
        {
            Console.WriteLine("Usage:");
            Console.WriteLine("MTKConverter -i <import_file> -p <process> --no-screenshot -e <export_folder>\n");
            Console.WriteLine("Arguments:");
            Console.WriteLine("  <import_file> - import file name");
            Console.WriteLine("  <process> - manufacturing process or algorithm name");
            Console.WriteLine("  <export_folder> - export folder name");
            Console.WriteLine("  --no-screenshot - disable screenshot generation (optional)");
            Console.WriteLine("Example:");
            Console.WriteLine("MTKConverter -i C:\\models\\test.step -p machining_milling -e C:\\models\\test");
 
            Console.WriteLine("\nRecognized processes:");
            Console.WriteLine("  wall_thickness   :\t Wall Thickness analysis");
            Console.WriteLine("  machining_milling:\t CNC Machining Milling feature recognition and DFM analysis");
            Console.WriteLine("  machining_turning:\t CNC Machining Lathe+Milling feature recognition and DFM analysis");
            Console.WriteLine("  molding          :\t Molding feature recognition and DFM analysis");
            Console.WriteLine("  sheet_metal      :\t Sheet Metal feature recognition, unfolding and DFM analysis");
        }
 
        private MTKConverter_ProcessType ProcessType(string theProcessName)
        {
            var aProcessDictionary = new Dictionary<string, MTKConverter_ProcessType>()
            {
                { "wall_thickness", MTKConverter_ProcessType.MTKConverter_PT_WallThickness},
                { "machining_milling", MTKConverter_ProcessType.MTKConverter_PT_MachiningMilling},
                { "machining_turning", MTKConverter_ProcessType.MTKConverter_PT_MachiningTurning},
                { "molding", MTKConverter_ProcessType.MTKConverter_PT_Molding},
                { "sheet_metal", MTKConverter_ProcessType.MTKConverter_PT_SheetMetal}
            };
 
            MTKConverter_ProcessType aProcess = MTKConverter_ProcessType.MTKConverter_PT_Undefined;
            bool aRes = aProcessDictionary.TryGetValue(theProcessName, out aProcess);
            if (aRes)
            {
                return aProcess;
            }
 
            return MTKConverter_ProcessType.MTKConverter_PT_Undefined;
        }
 
        private MTKConverter_ReturnCode Import(string theFilePath, Model theModel)
        {
            UTF16String aFilePath = new UTF16String(theFilePath);
            Console.Write($"Importing {theFilePath}...");
 
            ModelReader aReader = new ModelReader();
            if (!aReader.Read(aFilePath, theModel))
            {
                Console.WriteLine($"\nERROR: Failed to import {theFilePath}. Exiting");
                return MTKConverter_ReturnCode.MTKConverter_RC_ImportError;
            }
            return MTKConverter_ReturnCode.MTKConverter_RC_OK;
        }
 
        private bool CreateOriginModelThumbnail(UTF16String theFilePath, Model theModel)
        {
            ImageWriter aWriter = new ImageWriter();
            ImageWriterParameters aParameters = aWriter.Parameters();
            aParameters.SetImageHeight(800);
            aParameters.SetImageWidth(600);
            aParameters.SetViewCameraProjection(CameraProjectionType.Perspective);
            aParameters.SetViewCameraPosition(CameraPositionType.Default);
            aParameters.SetViewIsFitAll(true);
            aParameters.SetViewAntialiasing(AntialiasingMode.High);
            aParameters.SetViewBackground(new ColorBackgroundStyle(new Color(255, 255, 255)));
            aWriter.SetParameters(aParameters);
 
            bool aRes = aWriter.WriteFile(theModel, theFilePath);
            return aRes;
        }
 
        private void ApplyProcessorToModel(Model theModel, MTKConverter_Report theReport, MTKConverter_PartProcessor theProcessor)
        {
            ModelElementUniqueVisitor aVisitor = new ModelElementUniqueVisitor(theProcessor);
            theModel.Accept(aVisitor);
            foreach (MTKConverter_ProcessData i in theProcessor.myData)
            {
                theReport.AddData(i);
            }
        }
 
        private MTKConverter_ReturnCode Process(string theProcess, Model theModel,
            MTKConverter_Report theReport, Model theProcessModel)
        {
            Console.Write($"Processing {theProcess}...");
 
            theModel.AssignUuids();
 
            MTKConverter_ProcessType aProcessType = ProcessType(theProcess);
            switch (aProcessType)
            {
                case MTKConverter_ProcessType.MTKConverter_PT_WallThickness:
                    {
                        MTKConverter_WallThicknessProcessor aProcessor = new MTKConverter_WallThicknessProcessor(800);
                        ApplyProcessorToModel(theModel, theReport, aProcessor);
                        break;
                    }
                case MTKConverter_ProcessType.MTKConverter_PT_MachiningMilling:
                    {
                        MTKConverter_MachiningProcessor aProcessor = new MTKConverter_MachiningProcessor(Machining_OperationType.Machining_OT_Milling);
                        ApplyProcessorToModel(theModel, theReport, aProcessor);
                        break;
                    }
                case MTKConverter_ProcessType.MTKConverter_PT_MachiningTurning:
                    {
                        MTKConverter_MachiningProcessor aProcessor = new MTKConverter_MachiningProcessor(Machining_OperationType.Machining_OT_LatheMilling);
                        ApplyProcessorToModel(theModel, theReport, aProcessor);
                        break;
                    }
                case MTKConverter_ProcessType.MTKConverter_PT_Molding:
                    {
                        UTF16String aProcessModelName = new UTF16String(theModel.Name() + "_extra");
                        theProcessModel.SetName(aProcessModelName);
                        MTKConverter_MoldingProcessor aProcessor = new MTKConverter_MoldingProcessor(theProcessModel);
                        ApplyProcessorToModel(theModel, theReport, aProcessor);
                        break;
                    }
                case MTKConverter_ProcessType.MTKConverter_PT_SheetMetal:
                    {
                        UTF16String aProcessModelName = new UTF16String(theModel.Name() + "_unfolded");
                        theProcessModel.SetName(aProcessModelName);
                        MTKConverter_SheetMetalProcessor aProcessor = new MTKConverter_SheetMetalProcessor(theProcessModel);
                        ApplyProcessorToModel(theModel, theReport, aProcessor);
                        break;
                    }
                case MTKConverter_ProcessType.MTKConverter_PT_Undefined:
                default: return MTKConverter_ReturnCode.MTKConverter_RC_InvalidArgument;
            }
 
            return MTKConverter_ReturnCode.MTKConverter_RC_OK;
        }
 
        private MTKConverter_ReturnCode Export(string theFolderPath, Model theModel,
            bool theToGenerateScreenshot, MTKConverter_Report theReport, Model theProcessModel)
        {
            Console.Write($"Exporting {theFolderPath}...");
 
            UTF16String aModelPath = new UTF16String(theFolderPath + "/" + theModel.Name() + ".mtkweb" + "/scenegraph.mtkweb");
            if (!theModel.Save(aModelPath, Model.FileFormatType.MTKWEB))
            {
                Console.WriteLine($"\nERROR: Failed to export {aModelPath}. Exiting");
                return MTKConverter_ReturnCode.MTKConverter_RC_ExportError;
            }
 
            UTF16String aThumbnailPath = new UTF16String(theFolderPath + "/thumbnail.png");
            if (theToGenerateScreenshot && !CreateOriginModelThumbnail(aThumbnailPath, theModel))
            {
                Console.WriteLine($"\nERROR: Failed to create thumbnail {aThumbnailPath}. Exiting");
                return MTKConverter_ReturnCode.MTKConverter_RC_ExportError;
            }
 
            if (!theProcessModel.IsEmpty())
            {
                UTF16String aProcessModelPath = new UTF16String(theFolderPath + "/" + theProcessModel.Name() + ".mtkweb" + "/scenegraph.mtkweb");
                if (!theProcessModel.Save(aProcessModelPath, Model.FileFormatType.MTKWEB))
                {
                    Console.WriteLine($"\nERROR: Failed to export {aProcessModelPath}. Exiting");
                    return MTKConverter_ReturnCode.MTKConverter_RC_ExportError;
                }
            }
 
            Directory.CreateDirectory(theFolderPath);
            UTF16String aJsonPath = new UTF16String(theFolderPath + "/process_data.json");
            if (!theReport.WriteToJSON(aJsonPath))
            {
                Console.WriteLine($"\nERROR: Failed to create JSON file {aJsonPath}. Exiting");
                return MTKConverter_ReturnCode.MTKConverter_RC_ExportError;
            }
 
            return MTKConverter_ReturnCode.MTKConverter_RC_OK;
        }
    }
}

Program.cs

// ****************************************************************************
// $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 System;
 
namespace mtkconverter
{
    class Program
    {
        static int Main(string[] args)
        {
            string aKey = MTKLicenseKey.Value();
 
            // Activate the license (aKey should be defined in mtk_license.cs)
            if (!LicenseManager.Activate(aKey))
            {
                Console.WriteLine("Failed to activate Manufacturing Toolkit license.");
                return 1;
            }
 
            MTKConverter_Application anApp = new MTKConverter_Application();
            return (int)anApp.Run(args);
        }
    }
}