Manufacturing Toolkit: molding/dfm_analyzer/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;

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::MTKBase_FeatureComparator
Provides possibility to compare MTK based features depending on their type and parameters.
Definition MTKBase_FeatureComparator.hxx:29

cadex::MTKBase_Feature
Describes a base class of MTK based features.
Definition MTKBase_Feature.hxx:33

cadex
Defines classes, namespaces, enums, types, and global functions related to Manufacturing Toolkit.
Definition LicenseManager_LicenseError.hxx:30