molding/dfm_analyzer/dfm_analyzer.java

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

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

//

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


import cadex.*;


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;

}

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