machining/dfm_analyzer/Program.cs

Refer to the CNC Machining DFM Analyzer Example

feature_group.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;
using System.Collections.Generic;
 
using FeatureMapType = System.Collections.Generic.SortedDictionary<cadex.MTKBase_Feature, uint>;
 
namespace feature_group
{
    class FeatureComparer : IComparer<MTKBase_Feature>
    {
        public int Compare(MTKBase_Feature theA, MTKBase_Feature theB)
        {
            MTKBase_FeatureComparator aComparator = new MTKBase_FeatureComparator();
            bool anALessThanB = aComparator.Apply(theA, theB);
            if (anALessThanB)
            {
                return -1;
            }
            bool aBLessThanA = aComparator.Apply(theB, theA);
            if (aBLessThanA)
            {
                return 1;
            }
            return 0;
        }
    }
 
    public struct Pair
    {
        public Pair(double theFirst, double theSecond)
        {
            First = theFirst;
            Second = theSecond;
        }
 
        public double First { get; }
        public double Second { get; }
 
        public override string ToString() => $"{First} x {Second}";
    }
 
    public struct Dimension
    {
        public Dimension(double theL, double theW, double theD)
        {
            L = theL;
            W = theW;
            D = theD;
        }
 
        public double L { get; }
        public double W { get; }
        public double D { get; }
 
        public override string ToString() => $"{L} x {W} x {D}";
    }
 
    public struct Direction
    {
        public Direction(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 FeatureGroupManager
    {
        public FeatureGroupManager()
        {
            myGroups = new List<FeatureGroup>();
        }
 
        private class FeatureGroup
        {
            public FeatureGroup(string theName, string theSubgroupName, bool theHasParameters)
            {
                myName = theName;
                mySubgroupName = theSubgroupName;
                myHasParameters = theHasParameters;
                myFeatureSubgroups = new FeatureMapType(new FeatureComparer());
            }
 
            public uint FeatureCount()
            {
                uint aCount = 0;
                foreach (var i in myFeatureSubgroups)
                {
                    aCount += i.Value;
                }
                return aCount;
            }
 
            public string myName;
            public string mySubgroupName;
            public bool myHasParameters;
            public FeatureMapType myFeatureSubgroups;
        }
 
        private class FeatureGroupComparer : IComparer<FeatureGroup>
        {
            public int Compare(FeatureGroup theA, FeatureGroup theB)
            {
                string anAName = theA.myName;
                string aBName = theB.myName;
                if (anAName == aBName)
                {
                    return 0;
                }
 
                FeatureMapType anAFeatureSubgroups = theA.myFeatureSubgroups;
                FeatureMapType aBFeatureSubgroups = theB.myFeatureSubgroups;
                if (anAFeatureSubgroups.Count == 0 || aBFeatureSubgroups.Count == 0)
                {
                    return anAName.CompareTo(aBName);
                }
 
                MTKBase_Feature anAFeature = new MTKBase_Feature();
                MTKBase_Feature aBFeature = new MTKBase_Feature();
                foreach (var i in anAFeatureSubgroups)
                {
                    anAFeature = i.Key;
                    break;
                }
                foreach (var i in aBFeatureSubgroups)
                {
                    aBFeature = i.Key;
                    break;
                }
 
                FeatureComparer aFeatureComparator = new FeatureComparer();
                return aFeatureComparator.Compare(anAFeature, aBFeature);
            }
        }
 
        private List<FeatureGroup> myGroups;
 
        public void AddFeature(string theGroupName, string theSubgroupName, bool theHasParameters, MTKBase_Feature theFeature)
        {
            //find or create
            int aRes = myGroups.FindIndex(theGroup => theGroup.myName == theGroupName);
            if (aRes == -1)
            {
                myGroups.Add(new FeatureGroup(theGroupName, theSubgroupName, theHasParameters));
                aRes = myGroups.Count - 1;
            }
 
            //update
            FeatureGroup aGroup = myGroups[aRes];
            FeatureMapType aSubgroups = aGroup.myFeatureSubgroups;
            if (aSubgroups.ContainsKey(theFeature))
            {
                ++aSubgroups[theFeature];
            }
            else
            {
                aSubgroups[theFeature] = 1;
            }
        }
 
        public void Print(string theFeatureType, Action<MTKBase_Feature> thePrintFeatureParameters)
        {
            myGroups.Sort(new FeatureGroupComparer());
 
            uint aTotalCount = 0;
            foreach (var i in myGroups)
            {
                uint aFeatureCount = i.FeatureCount();
                aTotalCount += aFeatureCount;
 
                Console.WriteLine($"    {i.myName}: {aFeatureCount}");
 
                if (!i.myHasParameters)
                {
                    continue;
                }
 
                string aSubgroupName = i.mySubgroupName;
                foreach (var j in i.myFeatureSubgroups)
                {
                    Console.WriteLine($"        {j.Value} {aSubgroupName} with");
                    thePrintFeatureParameters(j.Key);
                }
            }
 
            Console.WriteLine($"\n    Total {theFeatureType}: {aTotalCount}\n");
        }
 
        public static void PrintFeatureParameter<T>(string theName, T theValue, string theUnits)
        {
            Console.WriteLine($"          {theName}: {theValue} {theUnits}");
        }
    }
}

shape_processor.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 System;
using cadex;
using cadex.ModelData;
 
namespace shape_processor
{
    abstract class ShapeProcessor : ModelElementVoidVisitor
    {
        public override void Apply(Part thePart)
        {
            var aPartName = thePart.Name().IsEmpty() ? new UTF16String("noname") : thePart.Name();
 
            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));
                        }
                        else if (aShape.Type() == ShapeType.Shell)
                        {
                            Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - shell #{i} has:\n");
                            ProcessShell(Shell.Cast(aShape));
                        }
                    }
 
                    ++myPartIndex;
                }
            }
        }
 
        public abstract void ProcessSolid(Solid theSolid);
 
        public abstract void ProcessShell(Shell theShell);
 
        private uint myPartIndex = 0;
    }
 
    abstract class SolidProcessor : ModelElementVoidVisitor
    {
        public override void Apply(Part thePart)
        {
            var aPartName = thePart.Name().IsEmpty() ? new UTF16String ("noname") : thePart.Name();
 
            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));
                        }
                    }
 
                    ++myPartIndex;
                }
            }
        }
 
        public abstract void ProcessSolid(Solid theSolid);
 
        private uint myPartIndex = 0;
    }
}

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 cadex.ModelData;
using feature_group;
using shape_processor;
using System;
using System.Collections.Generic;
 
namespace dfm_analyzer
{
    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> <operation>, where:");
                Console.WriteLine($"    <input_file> is a name of the file to be read");
                Console.WriteLine($"    <operation> is a name of desired machining operation");
                Console.WriteLine($"");
                PrintSupportedOperations();
                return 1;
            }
 
            string aSource = args[0];
 
            var 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");
 
            string anOperationStr = args[1];
            Machining_OperationType anOperation = OperationType(anOperationStr);
            if (anOperation == Machining_OperationType.Machining_OT_Undefined)
            {
                Console.WriteLine($"Unsupported operation - {anOperationStr}");
                Console.WriteLine($"Please use one of the following.");
                PrintSupportedOperations();
                return 1;
            }
 
            var aPartProcessor = new PartProcessor(anOperation);
            var aVisitor = new ModelElementUniqueVisitor(aPartProcessor);
            aModel.Accept(aVisitor);
 
            return 0;
        }
 
        class PartProcessor : SolidProcessor
        {
            public PartProcessor(Machining_OperationType theOperation)
            {
                myOperation = theOperation;
            }
 
            public override void ProcessSolid(Solid theSolid)
            {
                // Find features
                var aData = new Machining_Data();
                var aParam = new Machining_FeatureRecognizerParameters();
                aParam.SetOperation(myOperation);
                var aRecognizer = new Machining_FeatureRecognizer(aParam);
                aRecognizer.Perform(theSolid, aData);
 
                // Run drilling analyzer for found features
                var aDrillingParameters = new DFMMachining_DrillingAnalyzerParameters();
                var aDrillingAnalyzer = new DFMMachining_Analyzer(aDrillingParameters);
                var anIssueList = aDrillingAnalyzer.Perform(theSolid, aData);
 
                // Run milling analyzer for found features
                var aMillingParameters = new DFMMachining_MillingAnalyzerParameters();
                var aMillingAnalyzer = new DFMMachining_Analyzer(aMillingParameters);
                var aMillingIssueList = aMillingAnalyzer.Perform(theSolid, aData);
                // Combine issue lists
                CombineFeatureLists(anIssueList, aMillingIssueList);
 
                var aTurningIssueList = new MTKBase_FeatureList();
                if (myOperation == Machining_OperationType.Machining_OT_LatheMilling)
                {
                    // Run turning analyzer for found features
                    var aTurninigParameters = new DFMMachining_TurningAnalyzerParameters();
                    var aTurningAnalyzer = new DFMMachining_Analyzer(aTurninigParameters);
                    aTurningIssueList = aTurningAnalyzer.Perform(theSolid, aData);
 
                    // Combine issue lists
                    CombineFeatureLists(anIssueList, aTurningIssueList);
                }
 
                PrintIssues(anIssueList);
            }
 
            private void CombineFeatureLists(MTKBase_FeatureList theFirst, MTKBase_FeatureList theSecond)
            {
                for (uint i = 0; i < theSecond.Size(); ++i) {
                    MTKBase_Feature aFeature = theSecond.Feature(i);
                    if (myOperation == Machining_OperationType.Machining_OT_LatheMilling
                        && DFMMachining_MillingIssue.CompareType(aFeature)
                        && !DFMMachining_DeepPocketIssue.CompareType(aFeature))
                    {
                        continue;
                    }
                    theFirst.Append(aFeature);
                }
            }
 
            private Machining_OperationType myOperation = Machining_OperationType.Machining_OT_Undefined;
        }
 
        static void PrintSupportedOperations()
        {
            Console.WriteLine($"Supported operations:");
            Console.WriteLine($"    milling:\t CNC Machining Milling feature recognition");
            Console.WriteLine($"    turning:\t CNC Machining Lathe+Milling feature recognition");
        }
 
        static Machining_OperationType OperationType(string theOperationStr)
        {
            var aProcessDictionary = new Dictionary<string, Machining_OperationType>()
            {
                { "milling", Machining_OperationType.Machining_OT_Milling},
                { "turning", Machining_OperationType.Machining_OT_LatheMilling}
            };
 
            Machining_OperationType aProcess = Machining_OperationType.Machining_OT_Undefined;
            bool aRes = aProcessDictionary.TryGetValue(theOperationStr, out aProcess);
            if (aRes)
            {
                return aProcess;
            }
 
            return Machining_OperationType.Machining_OT_Undefined;
        }
 
        static void PrintIssues (MTKBase_FeatureList theIssueList)
        {
            FeatureGroupManager aManager = new FeatureGroupManager();
 
            //group by parameters to provide more compact information about issues
            for (uint i = 0; i < theIssueList.Size(); ++i)
            {
                MTKBase_Feature anIssue = theIssueList.Feature (i);
 
                //drilling
                if (DFMMachining_SmallDiameterHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Small Diameter Hole Issue(s)", "Hole(s)", true, anIssue);
                }
                else if (DFMMachining_DeepHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Deep Hole Issue(s)", "Hole(s)", true, anIssue);
                }
                else if (DFMMachining_NonStandardDiameterHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Non Standard Diameter Hole Issue(s)", "Hole(s)", true, anIssue);
                }
                else if (DFMMachining_NonStandardDrillPointAngleBlindHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Non Standard Drill Point Angle Blind Hole Issue(s)", "Hole(s)", true, anIssue);
                }
                else if (DFMMachining_FlatBottomHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Flat Bottom Hole Issue(s)", "", false, anIssue);
                }
                else if (DFMMachining_NonPerpendicularHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Non Perpendicular Hole Issue(s)", "", false, anIssue);
                }
                else if (DFMMachining_IntersectingCavityHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Intersecting Cavity Hole Issue(s)", "", false, anIssue);
                }
                else if (DFMMachining_PartialHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Partial Hole Issue(s)", "Hole(s)", true, anIssue);
                }
                //milling
                else if (DFMMachining_NonStandardRadiusMilledPartFloorFilletIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Non Standard Radius Milled Part Floor Fillet Issue(s)", "Floor Fillet(s)", true, anIssue);
                }
                else if (DFMMachining_DeepPocketIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Deep Pocket Issue(s)", "Pocket(s)", true, anIssue);
                }
                else if (DFMMachining_HighBossIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("High Boss Issue(s)", "Boss(es)", true, anIssue);
                }
                else if (DFMMachining_LargeMilledPartIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Large Milled Part Issue(s)", "Part(s)", true, anIssue);
                }
                else if (DFMMachining_SmallRadiusMilledPartInternalCornerIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Small Radius Milled Part Internal Corner Issue(s)", "Internal Corner(s)", true, anIssue);
                }
                else if (DFMMachining_NonPerpendicularMilledPartShapeIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Non Perpendicular Milled Part Shape Issue(s)", "Shape(s)", true, anIssue);
                }
                else if (DFMMachining_MilledPartExternalEdgeFilletIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Milled Part External Edge Fillet Issue(s)", "", false, anIssue);
                }
                else if (DFMMachining_InconsistentRadiusMilledPartFloorFilletIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Inconsistent Radius Milled Part Floor Fillet Issue(s)", "Floor Fillet(s)", true, anIssue);
                }
                else if (DFMMachining_NarrowRegionInPocketIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Narrow Region In Pocket Issue(s)", "Region(s)", true, anIssue);
                }
                else if (DFMMachining_LargeDifferenceRegionsSizeInPocketIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Large Difference Regions Size In Pocket Issue(s)", "Region Size(s)", true, anIssue);
                }
                else if (DFMMachining_SmallWallThicknessIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Small Wall Thickness Issue(s)", "Wall(s)", true, anIssue);
                }
                //turning
                else if (DFMMachining_IrregularTurnedPartOuterDiameterProfileReliefIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Irregular Turned Part Outer Diameter Profile Relief Issue(s)", "Outer Diameter Profile Relief(s)", true, anIssue);
                }
                else if (DFMMachining_SmallRadiusTurnedPartInternalCornerIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Small Radius Turned Part Internal Corner Issue(s)", "Internal Corner(s)", true, anIssue);
                }
                else if (DFMMachining_LargeTurnedPartIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Large Turned Part Issue(s)", "Part(s)", true, anIssue);
                }
                else if (DFMMachining_LongSlenderTurnedPartIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Long Slender Turned Part Issue(s)", "Part(s)", true, anIssue);
                }
                else if (DFMMachining_SmallDepthBlindBoredHoleReliefIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Small Depth Blind Bored Hole Relief Issue(s)", "Blind Bored Hole(s)", true, anIssue);
                }
                else if (DFMMachining_DeepBoredHoleIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Deep Bored Hole Issue(s)", "Bored Hole(s)", true, anIssue);
                }
                else if (DFMMachining_SquareEndKeywayIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Square End Keyway Issue(s)", "", false, anIssue);
                }
                else if (DFMMachining_NonSymmetricalAxialSlotIssue.CompareType(anIssue))
                {
                    aManager.AddFeature("Non Symmetrical Axial Slot Issue(s)", "", false, anIssue);
                }
            }
 
            //print
            Action<MTKBase_Feature> PrintFeatureParameters = theIssue =>
            {
                //drilling
                if (DFMMachining_SmallDiameterHoleIssue.CompareType(theIssue))
                {
                    DFMMachining_SmallDiameterHoleIssue aSDHIssue = DFMMachining_SmallDiameterHoleIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min diameter", aSDHIssue.ExpectedMinDiameter(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual diameter", aSDHIssue.ActualDiameter(), "mm");
                }
                else if (DFMMachining_DeepHoleIssue.CompareType(theIssue))
                {
                    DFMMachining_DeepHoleIssue aDHIssue = DFMMachining_DeepHoleIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected max depth", aDHIssue.ExpectedMaxDepth(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual depth", aDHIssue.ActualDepth(), "mm");
                }
                else if (DFMMachining_NonStandardDiameterHoleIssue.CompareType(theIssue))
                {
                    DFMMachining_NonStandardDiameterHoleIssue aNSDHIssue = DFMMachining_NonStandardDiameterHoleIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("nearest standard diameter", aNSDHIssue.NearestStandardDiameter(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual diameter", aNSDHIssue.ActualDiameter(), "mm");
                }
                else if (DFMMachining_NonStandardDrillPointAngleBlindHoleIssue.CompareType(theIssue))
                {
                    DFMMachining_NonStandardDrillPointAngleBlindHoleIssue aNSDPABHIssue = DFMMachining_NonStandardDrillPointAngleBlindHoleIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("nearest standard angle", ToDegrees(aNSDPABHIssue.NearestStandardAngle()), "deg");
                    FeatureGroupManager.PrintFeatureParameter("actual angle", ToDegrees(aNSDPABHIssue.ActualAngle()), "deg");
                }
                else if (DFMMachining_FlatBottomHoleIssue.CompareType(theIssue))
                {
                    //no parameters
                }
                else if (DFMMachining_NonPerpendicularHoleIssue.CompareType(theIssue))
                {
                    //no parameters
                }
                else if (DFMMachining_IntersectingCavityHoleIssue.CompareType(theIssue))
                {
                    //no parameters
                }
                else if (DFMMachining_PartialHoleIssue.CompareType(theIssue))
                {
                    DFMMachining_PartialHoleIssue aPHIssue = DFMMachining_PartialHoleIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min material percent", aPHIssue.ExpectedMinMaterialPercent(), "");
                    FeatureGroupManager.PrintFeatureParameter("actual material percent", aPHIssue.ActualMaterialPercent(), "");
                }
                //milling
                else if (DFMMachining_NonStandardRadiusMilledPartFloorFilletIssue.CompareType(theIssue))
                {
                    DFMMachining_NonStandardRadiusMilledPartFloorFilletIssue aNSRMPFFIssue = DFMMachining_NonStandardRadiusMilledPartFloorFilletIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("nearest standard radius", aNSRMPFFIssue.NearestStandardRadius(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual radius", aNSRMPFFIssue.ActualRadius(), "mm");
                }
                else if (DFMMachining_DeepPocketIssue.CompareType(theIssue))
                {
                    DFMMachining_DeepPocketIssue aDPIssue = DFMMachining_DeepPocketIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected max depth", aDPIssue.ExpectedMaxDepth(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual depth", aDPIssue.ActualDepth(),            "mm");
                }
                else if (DFMMachining_HighBossIssue.CompareType(theIssue))
                {
                    DFMMachining_HighBossIssue aHBIssue = DFMMachining_HighBossIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected max height", aHBIssue.ExpectedMaxHeight(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual height",       aHBIssue.ActualHeight(),      "mm");
                }
                else if (DFMMachining_LargeMilledPartIssue.CompareType(theIssue))
                {
                    DFMMachining_LargeMilledPartIssue aLMPIssue = DFMMachining_LargeMilledPartIssue.Cast(theIssue);
                    DFMMachining_MilledPartSize anExpectedSize = aLMPIssue.ExpectedMaxMilledPartSize();
                    DFMMachining_MilledPartSize anActualSize = aLMPIssue.ActualMilledPartSize();
                    FeatureGroupManager.PrintFeatureParameter(
                        "expected max size (LxWxH)",
                        new Dimension(anExpectedSize.Length(), anExpectedSize.Width(), anExpectedSize.Height()),
                        "mm");
                    FeatureGroupManager.PrintFeatureParameter(
                        "actual size (LxWxH)",
                        new Dimension(anActualSize.Length(),   anActualSize.Width(),   anActualSize.Height()),
                        "mm");
                }
                else if (DFMMachining_SmallRadiusMilledPartInternalCornerIssue.CompareType(theIssue))
                {
                    DFMMachining_SmallRadiusMilledPartInternalCornerIssue aSRMPICIssue = DFMMachining_SmallRadiusMilledPartInternalCornerIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min radius", aSRMPICIssue.ExpectedMinRadius(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual radius", aSRMPICIssue.ActualRadius(), "mm");
                }
                else if (DFMMachining_NonPerpendicularMilledPartShapeIssue.CompareType(theIssue))
                {
                    DFMMachining_NonPerpendicularMilledPartShapeIssue aNPMPSIssue = DFMMachining_NonPerpendicularMilledPartShapeIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("actual angle", ToDegrees(aNPMPSIssue.ActualAngle()), "deg");
                }
                else if (DFMMachining_MilledPartExternalEdgeFilletIssue.CompareType(theIssue))
                {
                    //no parameters
                }
                else if (DFMMachining_InconsistentRadiusMilledPartFloorFilletIssue.CompareType(theIssue))
                {
                    DFMMachining_InconsistentRadiusMilledPartFloorFilletIssue aIRMPFFIssue =
                        DFMMachining_InconsistentRadiusMilledPartFloorFilletIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected radius", aIRMPFFIssue.ExpectedRadius(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual radius", aIRMPFFIssue.ActualRadius(), "mm");
                }
                else if (DFMMachining_NarrowRegionInPocketIssue.CompareType(theIssue))
                {
                    DFMMachining_NarrowRegionInPocketIssue aSMNRDIssue =
                        DFMMachining_NarrowRegionInPocketIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected minimum region size", aSMNRDIssue.ExpectedMinRegionSize(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual region size", aSMNRDIssue.ActualRegionSize(), "mm");
                }
                else if (DFMMachining_LargeDifferenceRegionsSizeInPocketIssue.CompareType(theIssue))
                {
                    DFMMachining_LargeDifferenceRegionsSizeInPocketIssue aLMNRRIssue =
                        DFMMachining_LargeDifferenceRegionsSizeInPocketIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected regions maximum to minimum size ratio", aLMNRRIssue.ExpectedMaxRegionsMaxToMinSizeRatio(), "");
                    FeatureGroupManager.PrintFeatureParameter("actual regions maximum to minimum size ratio", aLMNRRIssue.ActualMaxRegionsMaxToMinSizeRatio(), "");
                }
                else if (DFMMachining_SmallWallThicknessIssue.CompareType(theIssue))
                {
                    DFMMachining_SmallWallThicknessIssue aSWTIssue =
                        DFMMachining_SmallWallThicknessIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min wall thickness", aSWTIssue.ExpectedMinThickness(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual wall thickness", aSWTIssue.ActualThickness(), "mm");
                }
                //turning
                else if (DFMMachining_IrregularTurnedPartOuterDiameterProfileReliefIssue.CompareType(theIssue))
                {
                    DFMMachining_IrregularTurnedPartOuterDiameterProfileReliefIssue anITPODPRIssue = DFMMachining_IrregularTurnedPartOuterDiameterProfileReliefIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter(
                        "expected max incline angle", ToDegrees(anITPODPRIssue.ExpectedMaxFaceInclineAngle()), "deg");
                    FeatureGroupManager.PrintFeatureParameter(
                        "actual incline angle", ToDegrees(anITPODPRIssue.ActualFaceInclineAngle()), "deg");
                }
                else if (DFMMachining_SmallRadiusTurnedPartInternalCornerIssue.CompareType(theIssue))
                {
                    DFMMachining_SmallRadiusTurnedPartInternalCornerIssue aSRTPICIssue = DFMMachining_SmallRadiusTurnedPartInternalCornerIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min radius", aSRTPICIssue.ExpectedMinRadius(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual radius", aSRTPICIssue.ActualRadius(), "mm");
                }
                else if (DFMMachining_LargeTurnedPartIssue.CompareType(theIssue))
                {
                    DFMMachining_LargeTurnedPartIssue aLTPIssue = DFMMachining_LargeTurnedPartIssue.Cast(theIssue);
                    DFMMachining_TurnedPartSize anExpectedSize = aLTPIssue.ExpectedMaxTurnedPartSize();
                    DFMMachining_TurnedPartSize anActualSize = aLTPIssue.ActualTurnedPartSize();
                    FeatureGroupManager.PrintFeatureParameter(
                        "expected max size (LxR)",
                        new Pair(anExpectedSize.Length(), anExpectedSize.Radius()),
                        "mm");
                    FeatureGroupManager.PrintFeatureParameter(
                        "actual size (LxR)",
                        new Pair(anActualSize.Length(), anActualSize.Radius()),
                        "mm");
                }
                else if (DFMMachining_LongSlenderTurnedPartIssue.CompareType(theIssue))
                {
                    DFMMachining_LongSlenderTurnedPartIssue aLSTPIssue = DFMMachining_LongSlenderTurnedPartIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min length", aLSTPIssue.ExpectedMaxLength(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual length", aLSTPIssue.ActualLength(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual min diameter", aLSTPIssue.ActualMinDiameter(), "mm");
                }
                else if (DFMMachining_SmallDepthBlindBoredHoleReliefIssue.CompareType(theIssue))
                {
                    DFMMachining_SmallDepthBlindBoredHoleReliefIssue aSDBBHRIssue = DFMMachining_SmallDepthBlindBoredHoleReliefIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected min relief depth", aSDBBHRIssue.ExpectedMinReliefDepth(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual relief depth", aSDBBHRIssue.ActualReliefDepth(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual diameter", aSDBBHRIssue.ActualDiameter(), "mm");
                }
                else if (DFMMachining_DeepBoredHoleIssue.CompareType(theIssue))
                {
                    DFMMachining_DeepBoredHoleIssue aDBHIssue = DFMMachining_DeepBoredHoleIssue.Cast(theIssue);
                    FeatureGroupManager.PrintFeatureParameter("expected max depth", aDBHIssue.ExpectedMaxDepth(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual depth", aDBHIssue.ActualDepth(), "mm");
                    FeatureGroupManager.PrintFeatureParameter("actual diameter", aDBHIssue.ActualDiameter(), "mm");
                }
                else if (DFMMachining_SquareEndKeywayIssue.CompareType(theIssue))
                {
                    //no parameters
                }
                else if (DFMMachining_NonSymmetricalAxialSlotIssue.CompareType(theIssue))
                {
                    //no parameters
                }
            };
            aManager.Print("issues", PrintFeatureParameters);
        }
 
        static double ToDegrees(double theAngleRad)
        {
            return theAngleRad * 180 / Math.PI;
        }
    }
}