Model Tree (#102)

Author: codefiesta

Sources/VimKit/Database+Models.swift

@@ -464,11 +464,15 @@ extension Database {
         public var type: String?
         public var familyName: String?
         public var category: Category?
+        public var level: Level?
+        public var room: Room?
+        public var group: Group?
         public var workset: Workset?
         public var parameters: [Parameter]
 
         /// Returns the elements instance type
         public var instanceType: Element? {
+            guard let name, let type else { return nil }
             let predicate = #Predicate<Database.Element>{ $0.name == name && $0.type != type }
             let fetchDescriptor = FetchDescriptor<Database.Element>(predicate: predicate)
             guard let results = try? modelContext?.fetch(fetchDescriptor), results.isNotEmpty else {
@@ -507,6 +511,15 @@ extension Database {
             if let idx = data["Category"] as? Int64, idx != .empty {
                 category = cache.findOrCreate(idx)
             }
+            if let idx = data["Level"] as? Int64, idx != .empty {
+                level = cache.findOrCreate(idx)
+            }
+            if let idx = data["Room"] as? Int64, idx != .empty {
+                room = cache.findOrCreate(idx)
+            }
+            if let idx = data["Group"] as? Int64, idx != .empty {
+                group = cache.findOrCreate(idx)
+            }
             if let idx = data["Workset"] as? Int64, idx != .empty {
                 workset = cache.findOrCreate(idx)
             }
@@ -1050,146 +1063,97 @@ extension Database {
     }
 
     /// Provides an observable model tree
-    @MainActor
-    public class ModelTree: ObservableObject {
-
-        public enum TreeError: Error {
-            case empty
-            case notFound
-        }
-
-        public class Item: Identifiable, Hashable {
+    @Observable @MainActor
+    public class ModelTree {
 
-            public enum ItemType {
-                case category
-                case family
-                case type
-                case instance
-            }
+        /// The title of the bim document
+        public var title: String = .empty
 
-            public var id: Int64
-            public var name: String
-            public var type: ItemType
-            public var children = [Item]()
+        /// The top level categories
+        public var categories = [String]()
 
-            init(id: Int64, name: String, type: ItemType, children: [Item] = []) {
-                self.id = id
-                self.name = name
-                self.type = type
-                self.children = children
-            }
+        /// A hash of unique families as the key and it's corresponding category.
+        public var families = [String: String]()
 
-            func contains(_ text: String) -> Bool {
-                for child in children {
-                    if child.contains(text) {
-                        return true
-                    }
-                }
-                return name.lowercased().contains(text)
-            }
-
-            public func hash(into hasher: inout Hasher) {
-                hasher.combine(id)
-                hasher.combine(name)
-                hasher.combine(type)
-                hasher.combine(children)
-            }
-
-            public static func == (lhs: ModelTree.Item, rhs: ModelTree.Item) -> Bool {
-                lhs.id == rhs.id && lhs.type == rhs.type && lhs.name == rhs.name
-            }
-        }
+        /// A hash of unique types as the key and it's corresponding family.
+        public var types = [String: String]()
 
-        @Published
-        public var results: Result<[Item], TreeError> = .failure(.empty)
+        /// A hash of unique instance ids as the key and it's type name.
+        public var instances = [Int64: String]()
 
-        @Published
-        public var items = [Item]()
+        /// A hash of elementIDs to their corresponding node indices (used for quick lookup back to the geometry).
+        public var elementNodes: [Int64: Int64] = [:]
 
         /// Initializer.
         public init() { }
 
-        /// Loads the tree from the bottom up.
-        /// The Hierarchy `Category > Family > Type > Instance`
-        /// - Parameter familyInstances: the family instances.
-        public func load(_ familyInstances: [Database.FamilyInstance]) async {
-
-            //////////////////////////////////////////
-            /// CATEGORY = type.category.name
-            /// FAMILY = instance.familyName
-            /// TYPE = type.name
-            /// INSTANCE = instance.name + elementID
-            //////////////////////////////////////////
-            struct Holder {
-                let categoryID: Int64
-                let categoryName: String
-                let familyID: Int64
-                let familyName: String
-                let typeID: Int64
-                let typeName: String
-                let instanceID: Int64
-                let instanceName: String
+        /// Loads the model tree with a hierarchy that mirrors the Revit hierarchy of
+        /// `Category > Family > Type > Instance`
+        /// - Parameters:
+        ///   - modelContext: the model context to use
+        public func load(modelContext: ModelContext) async {
+
+            // Fetch the title from the bim document entity
+            var documentDescriptor = FetchDescriptor<Database.BimDocument>(sortBy: [SortDescriptor(\.index)])
+            documentDescriptor.fetchLimit = 1
+            let documents = try? modelContext.fetch(documentDescriptor)
+            title = documents?.first?.title ?? .empty
+
+            // Fetch the nodes to build the tree structure
+            let descriptor = FetchDescriptor<Database.Node>(sortBy: [SortDescriptor(\.index)])
+            let results = try! modelContext.fetch(descriptor)
+
+            // Map the node elementIDs to their index
+            elementNodes = results.reduce(into: [Int64: Int64]()) { result, node in
+                if let element = node.element {
+                    result[element.elementId] = node.index
+                }
             }
 
-            var categories = [String: Item]()
-
-            // Build the tree TODO: This should be reworked - not very efficient
-            for instance in familyInstances {
-
-                guard let element = instance.element,
-                      let instanceName = element.name,
-                      let familyName = element.familyName else { continue }
-
-                guard let typeElement = instance.element?.instanceType,
-                      let typeName = typeElement.name,
-                      let category = typeElement.category else { continue }
+            // Top level categories
+            categories = results.compactMap{ $0.element?.category?.name }.uniqued().sorted{ $0 < $1 }
 
-                let displayName = "\(instanceName) [\(element.elementId)]"
-                let holder = Holder(categoryID: category.index, categoryName: category.name, familyID: element.index, familyName: familyName, typeID: typeElement.index, typeName: typeName, instanceID: element.index, instanceName: displayName)
-
-                // Category
-                if categories[holder.categoryName] == nil {
-                    categories[holder.categoryName] = Item(id: holder.categoryID, name: holder.categoryName, type: .category)
+            // The hash of families and their category
+            families = results.reduce(into: [String: String]()) { result, node in
+                if let categoryName = node.element?.category?.name, let familyName = node.element?.familyName, familyName.isNotEmpty {
+                    result[familyName] = categoryName
                 }
-                guard let category = categories[holder.categoryName] else { continue }
+            }
 
-                // Family
-                if category.children.filter({ $0.name == holder.familyName }).isEmpty {
-                    category.children.append(Item(id: holder.familyID, name: holder.familyName, type: .family))
+            // The hash of types and their family
+            types = results.reduce(into: [String: String]()) { result, node in
+                if let familyName = node.element?.familyName, familyName.isNotEmpty, let name = node.element?.name {
+                    result[name] = familyName
                 }
-                guard let family = category.children.filter({ $0.name == holder.familyName }).first else { continue }
+            }
 
-                // Type
-                if family.children.filter({ $0.name == holder.typeName }).isEmpty {
-                    family.children.append(Item(id: holder.typeID, name: holder.typeName, type: .type))
+            // The hash of instances and their name
+            instances = results.reduce(into: [Int64: String]()) { result, node in
+                if let element = node.element, let name = element.name {
+                    result[element.elementId] = name
                 }
-                guard let type = family.children.filter({ $0.name == holder.typeName }).first else { continue }
-
-                // Instance
-                let instanceItem = Item(id: holder.instanceID, name: holder.instanceName, type: .instance)
-
-                type.children.append(instanceItem)
             }
+        }
 
-            items = Array(categories.values.filter{ $0.children.isNotEmpty }.sorted{ $0.name < $1.name })
-            results = .success(items)
+        /// Returns an array of families for the specified category
+        /// - Parameter category: the category name
+        /// - Returns: a sorted array of unique family names in the specified category
+        public func families(in category: String) -> [String] {
+            families.filter{ $0.value == category }.keys.sorted{ $0 < $1 }
         }
 
-        /// Performs a search for model items that contain the following text.
-        /// - Parameter text: the search text
-        public func search(_ text: String) async {
-            results = .failure(.empty)
-            guard items.isNotEmpty else { return }
-            guard text.isNotEmpty else {
-                results = .success(items)
-                return
-            }
-            let hits = items.filter{ $0.contains(text)}
-            guard hits.isNotEmpty else {
-                results = .failure(.notFound)
-                return
-            }
-            results = .success(hits)
+        /// Returns an array of types for the specified family
+        /// - Parameter family: the family name
+        /// - Returns: a sorted array of unique tyes for the specified family
+        public func types(in family: String) -> [String] {
+            types.filter{ $0.value == family }.keys.sorted{ $0 < $1 }
+        }
+
+        /// Returns an array of instances for the specified type
+        /// - Parameter type: the type name
+        /// - Returns: a sorted array of instance id's for the specified type
+        public func instances(in type: String) -> [Int64] {
+            instances.filter{ $0.value == type }.keys.sorted{ $0 < $1 }
         }
     }
 }

Sources/VimKit/Geometry.swift

@@ -72,12 +72,12 @@ public class Geometry: ObservableObject, @unchecked Sendable {
     /// Returns the combinded buffer of all of the color overrides that can be applied to each instance.
     public private(set) var colorsBuffer: MTLBuffer?
 
+    /// Return the model bounds.
+    public var bounds: MDLAxisAlignedBoundingBox = .zero
+
     /// The Geometry Bounding Volume Hierarchy
     var bvh: BVH?
 
-    /// Return the model bounds.
-    var bounds: MDLAxisAlignedBoundingBox = .zero
-
     /// The data container
     private let bfast: BFast
     private var attributes = [Attribute]()

Sources/VimKit/Vim+Camera.swift

@@ -225,7 +225,8 @@ extension Vim {
             let radius = box.radius
             let fovRadians = fovDegrees.radians
             let distance = radius / sin(fovRadians / 2)
-            let eye = center - distance * forward
+            let dir: SIMD3<Float> = .ypositive
+            let eye = center - distance * dir
             look(at: box.center, from: eye)
         }
 

Tests/VimKitTests/DatabaseTests.swift

@@ -5,6 +5,7 @@
 //  Created by Kevin McKee
 //
 
+import Algorithms
 import Foundation
 import SwiftData
 import Testing
@@ -66,7 +67,7 @@ class DatabaseTests {
 
     @Test("Verify categories imported")
     func verifyCategories() async throws {
-        let descriptor = FetchDescriptor<Database.Category>(sortBy: [SortDescriptor(\.index)])
+        let descriptor = FetchDescriptor<Database.Category>(sortBy: [SortDescriptor(\.name)])
         let results = try! modelContext.fetch(descriptor)
         #expect(results.isNotEmpty)
     }
@@ -80,9 +81,6 @@ class DatabaseTests {
         let descriptor = FetchDescriptor<Database.Family>(predicate: predicate, sortBy: [SortDescriptor(\.index)])
         let results = try! modelContext.fetch(descriptor)
         #expect(results.isNotEmpty)
-        for result in results {
-            #expect(result.isSystemFamily == true)
-        }
     }
 
     @Test("Verify levels imported")
@@ -95,4 +93,17 @@ class DatabaseTests {
             #expect(result.element?.category?.name == "Levels")
         }
     }
+
+    @MainActor
+    @Test("Verify model tree")
+    func verifyModelTree() async throws {
+        let tree: Database.ModelTree = .init()
+        await tree.load(modelContext: modelContext)
+        #expect(tree.title.isNotEmpty)
+        #expect(tree.categories.isNotEmpty)
+        #expect(tree.families.isNotEmpty)
+        #expect(tree.types.isNotEmpty)
+        #expect(tree.instances.isNotEmpty)
+        #expect(tree.elementNodes.isNotEmpty)
+    }
 }