sheet_metal/dfm_analyzer/Program.cs

// ****************************************************************************

//

// Copyright (C) 2008-2014, Roman Lygin. All rights reserved.

// Copyright (C) 2014-2026, 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.mtk;

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}");

        }

    }

}

cadex::mtk
The mtk namespace is intended to become the primary namespace for MTK and replace direct use of the c...

cadex
Contains classes, namespaces, enums, types, and global functions related to Manufacturing Toolkit.