using System;

using System.IO;

using System.Linq;

using System.Threading.Tasks;

using Xbim.Common;

using Xbim.Ifc;

using Xbim.Ifc4.Interfaces;

using Xbim.IO;

using Xbim.Common.Geometry;

using Xbim.ModelGeometry.Scene;

​

​

namespace Example

{

    public static class Program

    {

​

        public static async Task Main()

        {

            await AABBExample.Show();

        }

​

    }

    public static class AABBExample

    {

        public static async Task Show()

        {

            var filename = "https://github.com/xBimTeam/XbimWebUI/files/10173051/ModernDiningRoom.zip";

            //filename = @"\\PC\Home\Downloads\ModernDiningRoom.zip";

            filename = @"https://raw.githubusercontent.com/xBimTeam/XbimSamples/master/BasicCreate/SampleHouse.ifc";

​

            using (var model = await LoadModel(filename))

            {

                PrintBoundingBoxes(model);

            }

        }

        private static void PrintBoundingBoxes(IModel model)

        {

            Xbim3DModelContext context = new Xbim3DModelContext(model);

            if (model.GeometriesCount == 0)

            {       

                context.CreateContext();

            }

            var furnitures = model.Instances.OfType<IIfcFurniture>();

            foreach(var o in furnitures)

            {

                var aabb = GetAxisAlignedBoundingBox(o, context);

                Console.WriteLine(string.Format("{0} [{1}] #{2}", o.Name ?? "-", o.GetType().Name, o.EntityLabel));

            }

        }

        private static Xbim3DRect GetAxisAlignedBoundingBox(IIfcProduct product, Xbim3DModelContext context)

        {

            XbimRect3D prodBox = XbimRect3D.Empty;

            foreach (var shp in context.ShapeInstancesOf(product))

            {

                //bounding boxes are lightweight and are produced when geometry is created at first place

​

                var bb = shp.BoundingBox;

                bb = XbimRect3D.TransformBy(bb, shp.Transformation);

                if (prodBox.IsEmpty) prodBox = bb; else prodBox.Union(bb);

                //add every BBox to the world to get the size and position of the world

            }

            return prodBox;

        }

/*

        private static void PrintHierarchy(IIfcObjectDefinition o, int level)

        {

            // Print this element

            Console.WriteLine(string.Format("{0}{1} [{2}] #{3}", GetIndent(level), o.Name ?? "-", o.GetType().Name, o.EntityLabel));

​

            //only spatial elements can contain building elements

            var spatialElement = o as IIfcSpatialStructureElement;

            if (spatialElement != null)

            {

                // This is a space. Use IfcRelContainedInSpatialElement to get contained elements

                var containedElements = spatialElement.ContainsElements.SelectMany(rel => rel.RelatedElements);

                foreach (var element in containedElements)

                {

                    // Print the elements (Products) in this Spatial element

                    PrintElementHierarchy(element, level);

                }

            }

​

            //using IfcRelAggregates to get spatial decomposition of spatial structure elements

            foreach (var item in o.IsDecomposedBy.SelectMany(r => r.RelatedObjects))

            {

                // Print the next level down in the Spatial Hierarchy

                PrintHierarchy(item, level + 1);

            }

        }

​

        private static void PrintElementHierarchy(IIfcProduct element, int level )

        {

            // Print the product

            Console.WriteLine(string.Format("{0}   -> {1} [{2}] #{3}", GetIndent(level), element.Name, element.GetType().Name, element.EntityLabel));

            // using IfcRelAggregates to get sub-elements in a product

            foreach (var subItem in element.IsDecomposedBy.SelectMany(d => d.RelatedObjects).OfType<IIfcProduct>())

            {

                // Print any child products

                PrintElementHierarchy(subItem, level + 1);

            }

        }

​

        private static string GetIndent(int level)

        {

            var indent = "";

            for (int i = 0; i < level; i++)

                indent += "  ";

            return indent;

        }

*/

        private static async Task<IModel> LoadModel(string source)

        {

            if (source.StartsWith("http"))

            {

                Stream stream = await GetStream(source);

                return IfcStore.Open(stream, StorageType.Ifc, Xbim.Common.Step21.XbimSchemaVersion.Ifc4, XbimModelType.MemoryModel);

            }

            else

            {

                return IfcStore.Open(source);

            }

        }

​

        private static async Task<Stream> GetStream(string source)

        {

            var client = new HttpClient();

            var result = await client.GetAsync(source);

            var stream = await result.Content.ReadAsStreamAsync();

            return stream;

        }

​

​

    }

}

​