helpers/shape_processor.hxx

Refer to the Model Explore Helper Implementation

// ****************************************************************************
// $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.
//
// ****************************************************************************
 
 
#ifndef _ShapeProcessor_HeaderFile
#define _ShapeProcessor_HeaderFile
 
#include <cadex/Base/UTF16String.hxx>
#include <cadex/ModelData/Body.hxx>
#include <cadex/ModelData/MeshBody.hxx>
#include <cadex/ModelData/Model.hxx>
#include <cadex/ModelData/Part.hxx>
#include <cadex/ModelData/Shell.hxx>
#include <cadex/ModelData/Solid.hxx>
#include <cadex/ModelData/SolidBody.hxx>
#include <cadex/ModelData/IndexedTriangleSet.hxx>
#include <cadex/WallThickness_Data.hxx>
 
#include <iostream>
 
 
using namespace cadex;
using namespace std;
 
static void PrintShapeHeader (size_t thePartIndex,
    const UTF16String& thePartName,
    const UTF16String& theShapeType,
    std::size_t theShapeIndex)
{
    cout << "Part #" << thePartIndex << "[\"" << thePartName << "\"] - "
        << theShapeType << " #" << theShapeIndex << " has:\n";
}
 
class ShapeProcessor : public ModelData::ModelElementVoidVisitor
{
public:
    void operator() (const ModelData::Part& thePart) override
    {
        auto aPartName = thePart.Name().IsEmpty() ? "noname" : thePart.Name();
 
        size_t aBodyNumber = 0;
        const auto& aBodies = thePart.Bodies();
        for (const auto& aBody : aBodies) {
            ModelData::ShapeIterator aShapeIt (aBody);
            while (aShapeIt.HasNext()) {
                const auto& aShape = aShapeIt.Next();
                if (aShape.Type() == ModelData::ShapeType::Solid) {
                    PrintShapeHeader (myPartIndex, aPartName, "solid", aBodyNumber);
                    ProcessSolid (ModelData::Solid::Cast (aShape));
                } else if (aShape.Type() == ModelData::ShapeType::Shell) {
                    PrintShapeHeader (myPartIndex, aPartName, "shell", aBodyNumber);
                    ProcessShell (ModelData::Shell::Cast (aShape));
                }
            }
            ++aBodyNumber;
        }
        ++myPartIndex;
    }
 
    virtual void ProcessSolid (const ModelData::Solid& theSolid) = 0;
 
    virtual void ProcessShell (const ModelData::Shell& theShell) = 0;
 
private:
    size_t myPartIndex = 0;
};
 
class SolidProcessor : public ModelData::ModelElementVoidVisitor
{
public:
    void operator() (const ModelData::Part& thePart) override
    {
        auto aPartName = thePart.Name().IsEmpty() ? "noname" : thePart.Name();
 
        size_t aBodyNumber = 0;
        const auto& aBodies = thePart.Bodies();
        for (const auto& aBody : aBodies) {
            ModelData::ShapeIterator aShapeIt (aBody);
            while (aShapeIt.HasNext()) {
                const auto& aShape = aShapeIt.Next();
                if (aShape.Type() == ModelData::ShapeType::Solid) {
                    PrintShapeHeader (myPartIndex, aPartName, "solid", aBodyNumber);
                    ProcessSolid (ModelData::Solid::Cast (aShape));
                }
            }
        }
 
        ++myPartIndex;
    }
 
    virtual void ProcessSolid (const ModelData::Solid& theSolid) = 0;
 
private:
    size_t myPartIndex = 0;
};
 
class SolidAndMeshProcessor : public ModelData::ModelElementVoidVisitor
{
public:
    void operator() (const ModelData::Part& thePart) override
    {
        auto aPartName = thePart.Name().IsEmpty() ? "noname" : thePart.Name();
 
        size_t aShapeIndex = 0;
        const auto& aBodies = thePart.Bodies();
        for (const auto& aBody : aBodies) {
            if (aBody.IsOfType<ModelData::MeshBody>()) {
                const auto& aMeshBody = static_cast<const ModelData::MeshBody&> (aBody);
                ProcessMeshBody (aMeshBody, aPartName, aShapeIndex);
            } else if (aBody.IsOfType<ModelData::SolidBody>()) {
                const auto& aSolidBody = static_cast<const ModelData::SolidBody&> (aBody);
                PrintShapeHeader (myPartIndex, aPartName, "solid", aShapeIndex);
                ProcessSolid (aSolidBody.Solid(), aPartName, aShapeIndex++);
            }
        }
        ++myPartIndex;
    }
 
    virtual void ProcessSolid (
        const ModelData::Solid& theSolid,
        const UTF16String& thePartName,
        size_t theShapeIndex) = 0;
 
    virtual void ProcessITS (
        const ModelData::IndexedTriangleSet& theITS,
        const UTF16String& thePartName,
        size_t theShapeIndex) = 0;
 
protected:
    size_t myPartIndex = 0;
 
private:
    void ProcessMeshBody (const ModelData::MeshBody& theMeshBody, const UTF16String& thePartName, size_t& theShapeIndex)
    {
        const auto& aMeshShapes = theMeshBody.Shapes();
        for (const auto& aMeshShape : aMeshShapes) {
            if (aMeshShape.IsOfType<ModelData::IndexedTriangleSet>()) {
                PrintShapeHeader (myPartIndex, thePartName, "ITS", theShapeIndex);
                const auto& anITS = static_cast<const ModelData::IndexedTriangleSet&> (aMeshShape);
                ProcessITS (anITS, thePartName, theShapeIndex++);
            }
        }
    }
};
 
#endif