OBB Class

[SerializableAttribute]
public sealed class OBB : IEquatable<OBB>

<SerializableAttribute>
Public NotInheritable Class OBB
	Implements IEquatable(Of OBB)

using System;
using Tekla.Structures.Geometry3d;
using Tekla.Structures.Model;

public class Example
{
   public void Example1()
   {
        OBB obb = null;

        // In this simplified example, there are two existing beams in the model.
        ModelObjectEnumerator beamsEnumerator =
            TeklaModel.GetModelObjectSelector().GetAllObjectsWithType(ModelObject.ModelObjectEnum.BEAM);

        if (beamsEnumerator != null)
        {
            while (beamsEnumerator.MoveNext())
            {
                Beam beam = beamsEnumerator.Current as Beam;

                if (beam != null)
                {
                    if (obb == null)
                    {
                        obb = CreateOrientedBoundingBox(beam);
                    }
                    else
                    {
                        if (obb.Intersects(CreateOrientedBoundingBox(beam)))
                        {
                            // Boxes intersect.
                        }
                        else
                        {
                            // Boxes did not intersect.
                        }
                    }
                }
            }
        }     
    }

    private Point CalculateCenterPoint(Point min, Point max)
    {
        double x = min.X + ((max.X - min.X) / 2);
        double y = min.Y + ((max.Y - min.Y) / 2);
        double z = min.Z + ((max.Z - min.Z) / 2);

        return new Point(x, y, z);
    }

    private OBB CreateOrientedBoundingBox(Beam beam)
    {
        OBB obb = null;

        if (beam != null)
        {
            WorkPlaneHandler workPlaneHandler = TeklaModel.GetWorkPlaneHandler();
            TransformationPlane originalTransformationPlane = workPlaneHandler.GetCurrentTransformationPlane();

            Solid solid = beam.GetSolid();
            Point minPointInCurrentPlane = solid.MinimumPoint;
            Point maxPointInCurrentPlane = solid.MaximumPoint;

            Point centerPoint = CalculateCenterPoint(minPointInCurrentPlane, maxPointInCurrentPlane);

            CoordinateSystem coordSys = beam.GetCoordinateSystem();
            TransformationPlane localTransformationPlane = new TransformationPlane(coordSys);
            workPlaneHandler.SetCurrentTransformationPlane(localTransformationPlane);

            solid = beam.GetSolid();
            Point minPoint = solid.MinimumPoint;
            Point maxPoint = solid.MaximumPoint;
            double extent0 = (maxPoint.X - minPoint.X) / 2;
            double extent1 = (maxPoint.Y - minPoint.Y) / 2;
            double extent2 = (maxPoint.Z - minPoint.Z) / 2;

            workPlaneHandler.SetCurrentTransformationPlane(originalTransformationPlane);

            obb = new OBB(centerPoint, coordSys.AxisX, coordSys.AxisY,
                            coordSys.AxisX.Cross(coordSys.AxisY), extent0, extent1, extent2);
        }

        return obb;
    }
}