helpers/shape_processor.cs

Refer to the Model Explore Helper Implementation

// ****************************************************************************
//
// 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.
//
// ****************************************************************************
 
using System;
using cadex;
using cadex.mtk;
using cadex.ModelData;
 
namespace shape_processor
{
    abstract class ShapeProcessor : ModelElementVoidVisitor
    {
        public override void Apply(Part thePart)
        {
            var aPartName = thePart.Name().IsEmpty() ? new UTF16String("noname") : thePart.Name();
 
            var aBodyVec = thePart.Bodies();
            if (aBodyVec.Count != 0)
            {
                // Looking for a suitable body
                for (int i = 0; i < aBodyVec.Count; ++i)
                {
                    Body aBody = aBodyVec[i];
 
                    var aShapeIt = new ShapeIterator(aBody);
                    foreach (var aShape in aShapeIt)
                    {
                        if (aShape.Type() == ShapeType.Solid)
                        {
                            Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - solid #{i} has:\n");
                            ProcessSolid(Solid.Cast(aShape));
                        }
                        else if (aShape.Type() == ShapeType.Shell)
                        {
                            Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - shell #{i} has:\n");
                            ProcessShell(Shell.Cast(aShape));
                        }
                    }
 
                }
            }
            ++myPartIndex;
        }
 
        public abstract void ProcessSolid(Solid theSolid);
 
        public abstract void ProcessShell(Shell theShell);
 
        private uint myPartIndex = 0;
    }
 
    abstract class SolidProcessor : ModelElementVoidVisitor
    {
        public override void Apply(Part thePart)
        {
            var aPartName = thePart.Name().IsEmpty() ? new UTF16String("noname") : thePart.Name();
 
            var aBodyVec = thePart.Bodies();
            if (aBodyVec.Count != 0)
            {
                // Looking for a suitable body
                for (int i = 0; i < aBodyVec.Count; ++i)
                {
                    Body aBody = aBodyVec[i];
 
                    var aShapeIt = new ShapeIterator(aBody);
                    foreach (var aShape in aShapeIt)
                    {
                        if (aShape.Type() == ShapeType.Solid)
                        {
                            Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - solid #{i} has:\n");
                            ProcessSolid(Solid.Cast(aShape));
                        }
                    }
 
                }
            }
            ++myPartIndex;
        }
 
        public abstract void ProcessSolid(Solid theSolid);
 
        private uint myPartIndex = 0;
    }
 
    abstract class SolidAndMeshProcessor : ModelElementVoidVisitor
    {
        public override void Apply(Part thePart)
        {
            string aPartName = thePart.Name().IsEmpty() ? "noname" : thePart.Name().ToString();
 
            int aShapeIndex = 0;
            var aBodyVec = thePart.Bodies();
            foreach (var aBody in aBodyVec)
            {
                if(MeshBody.CompareType(aBody))
                {
                    ProcessMeshBody(MeshBody.Cast(aBody), aPartName, ref aShapeIndex);
                } else if(SolidBody.CompareType(aBody))
                {
                    Console.Write($"Part #{myPartIndex} [\"{aPartName}\"] - solid #{aShapeIndex} has:\n");
                    ProcessSolid(SolidBody.Cast(aBody).Solid(), aPartName, aShapeIndex++);
                }
            }
            ++myPartIndex;
        }
 
        public abstract void ProcessSolid(Solid theSolid, string thePartName, int theShapeIndex);
        public abstract void ProcessITS(IndexedTriangleSet theITS, string thePartName, int theShapeIndex);
 
        private void ProcessMeshBody(MeshBody theMeshBody, string thePartName, ref int theShapeIndex)
        {
            var aMeshShapes = theMeshBody.Shapes();
            foreach (var aShape in aMeshShapes)
            {
                if(IndexedTriangleSet.CompareType(aShape))
                {
                    Console.Write($"Part #{myPartIndex} [\"{thePartName}\"]  #{theShapeIndex}:\n");
                    ProcessITS(IndexedTriangleSet.Cast(aShape), thePartName, theShapeIndex++);
                }
            }
        }
 
        protected uint myPartIndex = 0;
    }
}