Manufacturing Toolkit: molding/dfm_analyzer/main.cxx

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

// $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.

//

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


#ifndef _FeatureGroup_HeaderFile

#define _FeatureGroup_HeaderFile


#include <cadex/Geom/Direction.hxx>

#include <cadex/MTKBase_Feature.hxx>

#include <cadex/MTKBase_FeatureComparator.hxx>


#include <algorithm>

#include <array>

#include <functional>

#include <iomanip>

#include <iostream>

#include <map>

#include <sstream>

#include <vector>


using namespace cadex;

using namespace std;


typedef std::pair<double, double>   PairType;

typedef std::array<double, 3>       ArrayType;


inline std::ostream& operator<< (std::ostream& theStream, const PairType& thePair)

{

    return theStream << thePair.first << " x " << thePair.second;

}


inline std::ostream& operator<< (std::ostream& theStream, const ArrayType& theArray)

{

    return theStream << theArray[0] << " x " << theArray[1] << " x " << theArray[2];

}


inline std::ostream& operator<< (std::ostream& theStream, const Geom::Direction& theDir)

{

    stringstream aStream;

    aStream << setprecision(2) << fixed << "(" << theDir.X() << ", " << theDir.Y() << ", " << theDir.Z() << ")";

    return theStream << aStream.str();

}


class FeatureGroupManager

{

public:

    void AddFeature (const char* theGroupName,

                     const char* theSubgroupName,

                     bool theHasParameters,

                     const MTKBase_Feature& theFeature)

    {

        //find or create

        auto aRes = std::find_if (myGroups.begin(), myGroups.end(),

            [&] (const FeatureGroup& theGroup) { return theGroup.myName == theGroupName; });

        if (aRes == myGroups.end()) {

            aRes = myGroups.insert (aRes, FeatureGroup (theGroupName, theSubgroupName, theHasParameters));

        }


        //update

        auto& aGroup = *aRes;

        ++aGroup.myFeatureSubgroups[theFeature];

    }


    void Print (const char* theFeatureType, function<void (MTKBase_Feature)> thePrintFeatureParameters)

    {

        sort (myGroups.begin(), myGroups.end(), FeatureGroupComparator());


        cout << setprecision(6);


        size_t aTotalCount = 0;

        for (const auto& aFeatureGroup : myGroups) {

            size_t aFeatureCount = aFeatureGroup.FeatureCount();

            aTotalCount += aFeatureCount;


            cout << "    " << aFeatureGroup.myName << ": " << aFeatureCount << endl;


            if (!aFeatureGroup.myHasParameters) {

                continue;

            }


            const char* aSubgroupName = aFeatureGroup.mySubgroupName.c_str();

            for (const auto& aFeatureSubgroup : aFeatureGroup.myFeatureSubgroups) {

                cout << "        " << aFeatureSubgroup.second << " " << aSubgroupName << " with" << endl;

                thePrintFeatureParameters (aFeatureSubgroup.first);

            }

        }


        cout << "\n    Total " << theFeatureType << ": " << aTotalCount << "\n" << endl;

    }


    template <typename T>

    static void PrintFeatureParameter (const char* theName, const T& theValue, const char* theUnits)

    {

        cout << "          " << theName << ": " << theValue << " " << theUnits << endl;

    }


private:

    class FeatureGroup

    {

    public:

        FeatureGroup (const std::string& theName, const std::string& theSubgroupName, bool theHasParameters) :

            myName (theName), mySubgroupName (theSubgroupName), myHasParameters (theHasParameters)

        {}


        size_t FeatureCount() const

        {

            size_t aCount = 0;

            for (const auto& aFeatureSubgroup : myFeatureSubgroups) {

                aCount += aFeatureSubgroup.second;

            }

            return aCount;

        }


        string                                                     myName;

        string                                                     mySubgroupName;

        bool                                                       myHasParameters;

        map<MTKBase_Feature, size_t, MTKBase_FeatureComparator>    myFeatureSubgroups;

    };


    class FeatureGroupComparator

    {

    public:

        bool operator() (const FeatureGroup& theA, const FeatureGroup& theB) const

        {

            const auto& anAName = theA.myName;

            const auto& aBName = theB.myName;

            if (anAName == aBName) {

                return false;

            }


            const auto& anAFeatureSubgroups = theA.myFeatureSubgroups;

            const auto& aBFeatureSubgroups = theB.myFeatureSubgroups;

            if (anAFeatureSubgroups.empty() || aBFeatureSubgroups.empty()) {

                return anAName < aBName;

            }


            return MTKBase_FeatureComparator() (anAFeatureSubgroups.begin()->first,

                                                aBFeatureSubgroups.begin()->first);

        }

    };


    vector<FeatureGroup>     myGroups;

};


#endif

cadex::Geom::Direction
Defines a 3D Direction.
Definition Direction.hxx:34

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