helpers/feature_group.java

Refer to the Feature Group Helper Implementation

// ****************************************************************************
//
// 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.
//
// ****************************************************************************
 
import cadex.*;
import cadex.mtk.*;
 
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Consumer;
 
class FeatureComparator implements Comparator<MTKBase_Feature> {
    @Override
    public int compare(MTKBase_Feature theA, MTKBase_Feature theB) {
        MTKBase_FeatureComparator aComparator = new MTKBase_FeatureComparator();
        boolean anALessThanB = aComparator.Apply(theA, theB);
        if (anALessThanB) {
            return -1;
        }
        boolean aBLessThanA = aComparator.Apply(theB, theA);
        if (aBLessThanA) {
            return 1;
        }
        return 0;
    }
}
 
class Pair {
    public Pair(double theFirst, double theSecond) {
        this.First = theFirst;
        this.Second = theSecond;
    }
 
    public String toString() {
        return String.format("%f x %f", First, Second);
    }
 
    public double First;
    public double Second;
}
 
class Dimension {
    public Dimension(double theL, double theW, double theD) {
        this.L = theL;
        this.W = theW;
        this.D = theD;
    }
 
    public String toString() {
        return String.format("%f x %f x %f", L, W, D);
    }
 
    public double L;
    public double W;
    public double D;
}
 
class Direction {
    public Direction(double theX, double theY, double theZ) {
        this.X = theX;
        this.Y = theY;
        this.Z = theZ;
    }
 
    public String toString() {
        return "(" + FormattedString(X) + ", " + FormattedString(Y) + ", " + FormattedString(Z) + ")";
    }
 
    private String FormattedString(double theValue) {
        DecimalFormat aDF = new DecimalFormat("0.00");
        return aDF.format(theValue);
    }
 
    public double X;
    public double Y;
    public double Z;
}
 
class FeatureMap extends TreeMap<MTKBase_Feature, Long> {
    public FeatureMap() {
        super(new FeatureComparator());
    }
}
 
class FeatureGroupManager {
    public FeatureGroupManager() {
        myGroups = new ArrayList<FeatureGroup>();
    }
 
    public void AddFeature(String theGroupName, String theSubgroupName, boolean theHasParameters, MTKBase_Feature theFeature) {
        //find or create
        int aRes = -1;
        for (int i = 0; i < myGroups.size(); ++i) {
            FeatureGroup aGroup = myGroups.get(i);
            if (aGroup.myName == theGroupName) {
                aRes = i;
                break;
            }
        }
        if (aRes == -1) {
            myGroups.add(new FeatureGroup(theGroupName, theSubgroupName, theHasParameters));
            aRes = myGroups.size() - 1;
        }
 
        //update
        FeatureGroup aGroup = myGroups.get(aRes);
        FeatureMap aSubgroups = aGroup.myFeatureSubgroups;
        if (aSubgroups.containsKey(theFeature)) {
            aSubgroups.put(theFeature, aSubgroups.get(theFeature) + 1);
        } else {
            aSubgroups.put(theFeature, 1L);
        }
    }
 
    public void Print(String theFeatureType, Consumer<MTKBase_Feature> thePrintFeatureParameters) {
        Collections.sort(myGroups, new FeatureGroupComparator());
 
        long aTotalCount = 0;
        for (FeatureGroup aGroup : myGroups) {
            long aFeatureCount = aGroup.FeatureCount();
            aTotalCount += aFeatureCount;
 
            System.out.format("    %s: %d\n", aGroup.myName, aFeatureCount);
 
            if (!aGroup.myHasParameters) {
                continue;
            }
 
            String aSubgroupName = aGroup.mySubgroupName;
            for (Map.Entry<MTKBase_Feature, Long> aFeatureSubgroup : aGroup.myFeatureSubgroups.entrySet()) {
                System.out.format("        %d %s with\n", aFeatureSubgroup.getValue(), aSubgroupName);
                thePrintFeatureParameters.accept(aFeatureSubgroup.getKey());
            }
        }
 
        System.out.format("\n    Total %s: %d\n", theFeatureType, aTotalCount);
    }
 
    public static <T> void PrintFeatureParameter(String theName, T theValue, String theUnits) {
        System.out.format("          %s: %s %s\n", theName, theValue, theUnits);
    }
 
    private class FeatureGroup {
        public FeatureGroup(String theName, String theSubgroupName, boolean theHasParameters) {
            myName = theName;
            mySubgroupName = theSubgroupName;
            myHasParameters = theHasParameters;
            myFeatureSubgroups = new FeatureMap();
        }
 
        public long FeatureCount() {
            long aCount = 0;
            for (Map.Entry<MTKBase_Feature, Long> aFeatureSubgroup : myFeatureSubgroups.entrySet()) {
                aCount += aFeatureSubgroup.getValue();
            }
            return aCount;
        }
 
        public String myName;
        public String mySubgroupName;
        public boolean myHasParameters;
        public FeatureMap myFeatureSubgroups;
    }
 
    private class FeatureGroupComparator implements Comparator<FeatureGroup> {
        @Override
        public int compare(FeatureGroup theA, FeatureGroup theB) {
            String anAName = theA.myName;
            String aBName = theB.myName;
            if (anAName == aBName) {
                return 0;
            }
 
            FeatureMap anAFeatureSubgroups = theA.myFeatureSubgroups;
            FeatureMap aBFeatureSubgroups = theB.myFeatureSubgroups;
            if (anAFeatureSubgroups.isEmpty() || aBFeatureSubgroups.isEmpty()) {
                return anAName.compareTo(aBName);
            }
 
            MTKBase_Feature anAFeature = anAFeatureSubgroups.firstKey();
            MTKBase_Feature aBFeature = aBFeatureSubgroups.firstKey();
 
            FeatureComparator aFeatureComparator = new FeatureComparator();
            return aFeatureComparator.compare(anAFeature, aBFeature);
        }
    }
 
    private ArrayList<FeatureGroup> myGroups;
}