exploring/pmi/Program.cs

Refer to the PMI Example.

// ****************************************************************************
// $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.
//
// ****************************************************************************
 
using cadex;
using cadex.ModelData;
using cadex.PMI;
using System;
 
namespace pmi
{
    class Program
    {
        static int Main(string[] args)
        {
            string aKey = MTKLicenseKey.Value();
 
            // Activate the license (aKey must be defined in mtk_license.cs)
            if (!LicenseManager.Activate(aKey))
            {
                Console.WriteLine("Failed to activate Manufacturing Toolkit license.");
                return 1;
            }
 
            if (args.Length != 1)
            {
                Console.WriteLine("Usage: " +
                    $"{System.Reflection.Assembly.GetExecutingAssembly().Location} <input_file>, where:");
                Console.WriteLine($"    <input_file> is a name of the file to be read");
                Console.WriteLine($"");
                return 1;
            }
 
            string aSource = args[0];
 
            var aModel = new Model();
            var aReader = new ModelReader();
            var aParams = new ModelReaderParameters();
            aParams.SetReadPMI(true);
            aReader.SetParameters(aParams);
 
            // Reading the file
            if (!aReader.Read(new UTF16String(aSource), aModel))
            {
                Console.WriteLine($"Failed to read the file {aSource}");
                return 1;
            }
            Console.WriteLine($"Model: {aModel.Name()}\n");
 
            // Create a PMI visitor
            SceneGraphVisitor aVisitor = new SceneGraphVisitor();
            aModel.Accept(aVisitor);
 
            return 0;
        }
    }
 
    class TabulatedOutput
    {
        public static void WriteLine(Object theObject)
        {
            PrintTabulation();
            Console.WriteLine(theObject);
        }
 
        public static void IncreaseIndent() { ++myNestingLevel; }
        public static void DecreaseIndent() { --myNestingLevel; }
 
        private static void PrintTabulation()
        {
            if (myNestingLevel <= 0)
            {
                return;
            }
            // Emulate tabulation like tree.
            for (int i = 0; i < myNestingLevel - 1; i++)
            {
                if (i < 2 || i == 3)
                {
                    Console.Write("|  ");
                }
                else
                {
                    Console.Write("   ");
                }
            }
            Console.Write("|__");
            if (myNestingLevel > 3)
            {
                Console.Write(" ");
            }
        }
        private static int myNestingLevel = 0;
    }
 
    class SceneGraphVisitor : ModelElementVisitor
    {
        public override void Apply(Part thePart)
        {
            PrintName("Part", thePart.Name());
            ExplorePMI(thePart);
        }
 
        public override bool VisitEnter(Instance theInstance)
        {
            TabulatedOutput.IncreaseIndent();
            PrintName("Instance", theInstance.Name());
            ExplorePMI(theInstance);
            return true;
        }
 
        public override bool VisitEnter(Assembly theAssembly)
        {
            TabulatedOutput.IncreaseIndent();
            PrintName("Assembly", theAssembly.Name());
            ExplorePMI(theAssembly);
            return true;
        }
 
        public override void VisitLeave(Instance theInstance)
        {
            TabulatedOutput.DecreaseIndent();
        }
 
        public override void VisitLeave(Assembly theAssembly)
        {
            TabulatedOutput.DecreaseIndent();
        }
 
        private void ExplorePMI(ModelElement theSGE)
        {
            var aPMIData = theSGE.PMI();
            if (aPMIData != null)
            {
                TabulatedOutput.WriteLine("PMI Data:");
                TabulatedOutput.IncreaseIndent();
 
                if (aPMIData.NumberOfElements() == 0)
                {
                    return;
                }
 
                foreach (var anElement in aPMIData.Elements())
                {
                    TabulatedOutput.WriteLine("PMI Data: " + anElement.Name());
 
                    TabulatedOutput.IncreaseIndent();
 
                    SemanticRepresentation aSemanticRepresentation = anElement.SemanticRepresentation();
                    if (aSemanticRepresentation != null && !aSemanticRepresentation.IsEmpty())
                    {
                        TabulatedOutput.WriteLine("Semantic Representation:");
                        TabulatedOutput.IncreaseIndent();
                        PMISemanticVisitor aVisitor = new PMISemanticVisitor();
                        aSemanticRepresentation.Accept(aVisitor);
                        TabulatedOutput.DecreaseIndent();
                    }
 
                    GraphicalRepresentation aGraphicalRepresentation = anElement.GraphicalRepresentation();
                    if (aGraphicalRepresentation != null && !aGraphicalRepresentation.IsEmpty())
                    {
                        TabulatedOutput.WriteLine("Graphical Representation:");
                        TabulatedOutput.IncreaseIndent();
                        PMIGraphicalVisitor aVisitor = new PMIGraphicalVisitor();
                        aGraphicalRepresentation.Accept(aVisitor);
                        TabulatedOutput.DecreaseIndent();
                    }
 
                    TabulatedOutput.DecreaseIndent();
                }
 
                TabulatedOutput.DecreaseIndent();
            }
        }
 
        private void PrintName(string theSGElement, UTF16String theName)
        {
            if (!theName.IsEmpty())
            {
                TabulatedOutput.WriteLine(theSGElement + ": " + theName);
            }
            else
            {
                TabulatedOutput.WriteLine(theSGElement + ": <noname>");
            }
        }
    }
 
    class PMISemanticVisitor : SemanticComponentVisitor
    {
        public override void Apply(DatumComponent theComponent)
        {
            TabulatedOutput.WriteLine("Datum");
            TabulatedOutput.IncreaseIndent();
            TabulatedOutput.WriteLine("Label: " + theComponent.Label());
            printAttributes(theComponent);
            TabulatedOutput.DecreaseIndent();
        }
 
        public override void Apply(DimensionComponent theComponent)
        {
            TabulatedOutput.WriteLine("Dimension");
            TabulatedOutput.IncreaseIndent();
            TabulatedOutput.WriteLine("Nominal Value: " + theComponent.NominalValue());
            TabulatedOutput.WriteLine("Type of dimension: " + (int)theComponent.TypeOfDimension());
            printAttributes(theComponent);
            TabulatedOutput.DecreaseIndent();
        }
 
        public override void Apply(GeometricToleranceComponent theComponent)
        {
            TabulatedOutput.WriteLine("Geometric tolerance");
            TabulatedOutput.IncreaseIndent();
            TabulatedOutput.WriteLine("Magnitude: " + theComponent.Magnitude());
            TabulatedOutput.WriteLine("Type of tolerance: " + (int)theComponent.TypeOfTolerance());
            TabulatedOutput.WriteLine("Tolerance zone form: " + (int)theComponent.ToleranceZoneForm());
            printAttributes(theComponent);
            TabulatedOutput.DecreaseIndent();
        }
 
        public override void Apply(SurfaceFinishComponent theComponent)
        {
            TabulatedOutput.WriteLine("Surface Finish");
            TabulatedOutput.IncreaseIndent();
            TabulatedOutput.WriteLine("Material removal: " + (int)theComponent.MaterialRemoval());
            TabulatedOutput.WriteLine("Lay direction: " + (int)theComponent.LayDirection());
            TabulatedOutput.WriteLine("All around flag: " + theComponent.IsAllAround());
            TabulatedOutput.WriteLine("Manufacturing method: " + theComponent.ManufacturingMethod());
            printAttributes(theComponent);
            TabulatedOutput.DecreaseIndent();
        }
 
        void printAttributes(SemanticComponent theComponent)
        {
            if (theComponent.HasAttributes())
            {
                PMISemanticAttributeVisitor aVisitor = new PMISemanticAttributeVisitor();
                theComponent.Accept(aVisitor);
            }
        }
    }
 
    class PMISemanticAttributeVisitor : SemanticAttributeVisitor
    {
        public override void Apply(ModifierAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("Modifier: " + theAttribute.Modifier());
        }
        public override void Apply(ModifierWithValueAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("ModifierWithValue: modifier=" + theAttribute.Modifier() + ", value=" + theAttribute.Value());
        }
        public override void Apply(QualifierAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("Qualifier: " + theAttribute.Qualifier());
        }
        public override void Apply(PlusMinusBoundsAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("PlusMinusBounds: (" + theAttribute.LowerBound() + ", " + theAttribute.UpperBound() + ")");
        }
        public override void Apply(RangeAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("Range: [" + theAttribute.LowerLimit() + ", " + theAttribute.UpperLimit() + "]");
        }
        public override void Apply(LimitsAndFitsAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("LimitsAndFits: value=" + theAttribute.Value() + ", type=" + theAttribute.Type());
        }
        public override void Apply(DatumTargetAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("DatumTarget: index=" + theAttribute.Index() + ", description=" + theAttribute.Description());
        }
        public override void Apply(DatumRefAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("DatumRef: precedence=" + theAttribute.Precedence() + ", targetLabel=" + theAttribute.TargetLabel());
        }
        public override void Apply(DatumRefCompartmentAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("DatumRefCompartment:");
 
            TabulatedOutput.IncreaseIndent();
 
            uint aNumberOfReferences = theAttribute.NumberOfReferences();
            if (aNumberOfReferences > 0)
            {
                TabulatedOutput.WriteLine("References:");
                TabulatedOutput.IncreaseIndent();
                for (uint i = 0; i < aNumberOfReferences; i++)
                {
                    theAttribute.Reference(i).Accept(this);
                }
                TabulatedOutput.DecreaseIndent();
            }
 
            uint aNumberOfModifierAttributes = theAttribute.NumberOfModifierAttributes();
            if (aNumberOfModifierAttributes > 0)
            {
                TabulatedOutput.WriteLine("Modifiers:");
                TabulatedOutput.IncreaseIndent();
                for (uint i = 0; i < aNumberOfModifierAttributes; i++)
                {
                    theAttribute.ModifierAttribute(i).Accept(this);
                }
                TabulatedOutput.DecreaseIndent();
            }
 
            TabulatedOutput.DecreaseIndent();
        }
        public override void Apply(MaximumValueAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("MaximumValue: " + theAttribute.MaxValue());
        }
        public override void Apply(DisplacementAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("Displacement: " + theAttribute.Displacement());
        }
        public override void Apply(LengthUnitAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("LengthUnit: " + theAttribute.Unit());
        }
        public override void Apply(AngleUnitAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("AngleUnit: " + theAttribute.Unit());
        }
        public override void Apply(MachiningAllowanceAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("Machining allowance");
            TabulatedOutput.IncreaseIndent();
            TabulatedOutput.WriteLine("Value: " + theAttribute.Value());
            TabulatedOutput.WriteLine("Upper bound: " + theAttribute.UpperBound());
            TabulatedOutput.WriteLine("Lower bound: " + theAttribute.LowerBound());
            TabulatedOutput.DecreaseIndent();
        }
        public override void Apply(SurfaceTextureRequirementAttribute theAttribute)
        {
            TabulatedOutput.WriteLine("Surface texture requirement #" + (int)theAttribute.Precedence());
            TabulatedOutput.IncreaseIndent();
            TabulatedOutput.WriteLine("Specification limit: " + (int)theAttribute.SpecificationLimit());
            TabulatedOutput.WriteLine("Filter name: " + theAttribute.FilterName());
            TabulatedOutput.WriteLine("Short wave filter: " + theAttribute.ShortWaveFilter());
            TabulatedOutput.WriteLine("Long wave filter: " + theAttribute.LongWaveFilter());
            TabulatedOutput.WriteLine("Surface parameter: " + (int)theAttribute.SurfaceParameter());
            TabulatedOutput.WriteLine("Evaluation length: " + theAttribute.EvaluationLength());
            TabulatedOutput.WriteLine("Comparison rule: " + (int)theAttribute.ComparisonRule());
            TabulatedOutput.WriteLine("Limit value: " + theAttribute.LimitValue());
            TabulatedOutput.DecreaseIndent();
        }
    }
 
    class PMIGraphicalVisitor : GraphicalComponentVisitor
    {
        public override void Apply(OutlinedComponent theComponent)
        {
            TabulatedOutput.WriteLine("Outline");
            TabulatedOutput.IncreaseIndent();
            PMIOutlineVisitor aVisitor = new PMIOutlineVisitor();
            theComponent.Outline().Accept(aVisitor);
            TabulatedOutput.DecreaseIndent();
        }
        public override void Apply(TextComponent theComponent)
        {
            TabulatedOutput.WriteLine("Text [" + theComponent.Text() + "]");
        }
        public override void Apply(TriangulatedComponent theComponent)
        {
            TabulatedOutput.WriteLine("Triangulation [" + theComponent.TriangleSet().NumberOfTriangles() + " triangles]");
        }
    }
 
    class PMIOutlineVisitor : OutlineVisitor
    {
        public override void Apply(PolyOutline theOutline)
        {
            TabulatedOutput.WriteLine("PolyLine set [" + theOutline.LineSet().NumberOfPolylines() + " polylines]");
        }
        public override void Apply(Poly2dOutline theOutline)
        {
            TabulatedOutput.WriteLine("PolyLine2d set [" + theOutline.LineSet().NumberOfPolylines() + " polylines]");
        }
        public override void Apply(CurveOutline theOutline)
        {
            TabulatedOutput.WriteLine("Curve set [" + theOutline.NumberOfCurves() + " curves]");
        }
        public override void Apply(Curve2dOutline theOutline)
        {
            TabulatedOutput.WriteLine("Curve2d set [" + theOutline.NumberOfCurves() + " curves]");
        }
        public override bool VisitEnter(CompositeOutline theOutline)
        {
            TabulatedOutput.WriteLine("Outline set:");
            TabulatedOutput.IncreaseIndent();
            return true;
        }
        public override void VisitLeave(CompositeOutline theOutline)
        {
            TabulatedOutput.DecreaseIndent();
        }
    }
}