sheet_metal/dfm_analyzer/dfm_analyzer.java

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

//

// 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;

}

cadex::mtk
The mtk namespace is intended to become the primary namespace for MTK and replace direct use of the c...

cadex
Contains classes, namespaces, enums, types, and global functions related to Manufacturing Toolkit.