exploring/pmi/main.cxx

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