helpers/feature_group.hxx

Refer to the Feature Group Helper Implementation

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