예제 #1
0
        /// <summary>
        /// Checks if the IFC type is MEP type.
        /// </summary>
        /// <param name="exportType">IFC Export Type to check</param>
        /// <returns>True for MEP type of elements.</returns>
        public static bool IsMEPType(IFCExportInfoPair exportType)
        {
            bool instanceIsMEPInst = IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportInstance.ToString(), IFCEntityType.IfcDistributionElement.ToString(), strict: false);

            // The Type probably is not needed for check?
            bool typeIsMEPType = IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportType.ToString(), IFCEntityType.IfcDistributionElementType.ToString(), strict: false);

            return(instanceIsMEPInst);
        }
예제 #2
0
 /// <summary>
 /// Constructor for initializing EntityTree
 /// </summary>
 /// <param name="ifcVersion">the selected IFC version. This will "lock" the schema version in the dialog</param>
 /// <param name="excludeFilter">the initial list of the excluded entities. Can be used to initialize the setting</param>
 /// <param name="singleNodeSelection">true if the tree is used for a single node selection</param>
 /// <param name="showTypeNodeOnly">option to show IfcTypeObject tree only</param>
 /// <param name="preSelectItem">preselect an item (works for a single node selection only)</param>
 /// <param name="preSelectPdef">pre-select the predefined type</param>
 public EntityTree(IFCVersion ifcVersion, string excludeFilter, string desc, bool singleNodeSelection = false, bool showTypeNodeOnly = false, string preSelectEntity = null, string preSelectPdef = null)
 {
     m_IfcVersion          = IfcSchemaEntityTree.SchemaName(ifcVersion);
     ExclElementSet        = FillSetFromList(excludeFilter);
     m_SingleNodeSelection = singleNodeSelection;
     TreeSelectionDesc     = desc;
     m_ShowTypeNodeOnly    = showTypeNodeOnly;
     InitializeEntityTree(preSelectEntity, preSelectPdef);
 }
예제 #3
0
        void InitializeEntityTree(string preSelectEntity, string preSelectPDef)
        {
            IfcSchemaEntityTree.GetAllEntityDict();
            InitializeComponent();

            textBox_Search.Focus();

            if (m_SingleNodeSelection)
            {
                label_Show.Visibility         = System.Windows.Visibility.Hidden;
                comboBox_ShowItems.Visibility = System.Windows.Visibility.Hidden;
            }
            else
            {
                HelpRun.Text = Properties.Resources.HelpSelectEntityForExport;
                comboBox_ShowItems.ItemsSource = new List <string>()
                {
                    Properties.Resources.ShowAll, Properties.Resources.ShowChecked, Properties.Resources.ShowUnchecked
                };
                comboBox_ShowItems.SelectedIndex = 0; // Default selection to show All
            }

            // If the IFC schema version is selected for export, the combobox will be disabled for selection
            ComboBox_IFCSchema.IsEnabled = false;
            // Assign default
            if (string.IsNullOrEmpty(m_IfcVersion))
            {
                m_IfcVersion = IFCVersion.IFC4.ToString();
                ComboBox_IFCSchema.IsEnabled = true;
            }

            ComboBox_IFCSchema.ItemsSource  = IfcSchemaEntityTree.GetAllCachedSchemaNames();
            ComboBox_IFCSchema.SelectedItem = m_IfcVersion;
            if (m_SingleNodeSelection)
            {
                Grid_Main.ColumnDefinitions[2].MinWidth = 200;
            }
            else
            {
                // In multi-selection mode, hide the TreView panel for the PredefinedType
                Grid_Main.ColumnDefinitions[2].MinWidth = 0;
                GridLengthConverter grLenConv = new GridLengthConverter();
                GridLength          grLen     = (GridLength)grLenConv.ConvertFrom(0);
                Grid_Main.ColumnDefinitions[2].Width = grLen;
            }

            LoadTreeviewFilterElement();
            PreSelectItem(preSelectEntity, preSelectPDef);
            IfcSchemaEntityTree.GenerateEntityTrie(ref m_EntityTrie);
        }
예제 #4
0
        /// <summary>
        /// Get valid IFC entity type by using the official IFC schema (using the XML schema). It checks the non-abstract valid entity.
        /// If it is found to be abstract, it will try to find its supertype until it finds a non-abstract type.
        /// </summary>
        /// <param name="entityType">the IFC entity type (string) to check</param>
        /// <returns>return the appropriate IFCEntityType enumeration or Unknown</returns>
        public static IFCEntityType GetValidIFCEntityType(string entityType)
        {
            IFCVersion    ifcVersion = ExporterCacheManager.ExportOptionsCache.FileVersion;
            IFCEntityType ret        = IFCEntityType.UnKnown;

            var ifcEntitySchemaTree = IfcSchemaEntityTree.GetEntityDictFor(ExporterCacheManager.ExportOptionsCache.FileVersion);

            if (ifcEntitySchemaTree == null || ifcEntitySchemaTree.IfcEntityDict == null || ifcEntitySchemaTree.IfcEntityDict.Count == 0)
            {
                throw new Exception("Unable to locate IFC Schema xsd file! Make sure the relevant xsd " + ExporterCacheManager.ExportOptionsCache.FileVersion + " exists.");
            }

            IfcSchemaEntityNode node    = ifcEntitySchemaTree.Find(entityType);
            IFCEntityType       ifcType = IFCEntityType.UnKnown;

            if (node != null && !node.isAbstract)
            {
                // Only IfcProduct or IfcTypeProduct can be assigned for export type
                //if (!node.IsSubTypeOf("IfcProduct") && !node.IsSubTypeOf("IfcTypeProduct") && !node.Name.Equals("IfcGroup", StringComparison.InvariantCultureIgnoreCase))
                if ((node.IsSubTypeOf("IfcObject") &&
                     (node.IsSubTypeOf("IfcProduct") || node.IsSubTypeOf("IfcGroup") || node.Name.Equals("IfcGroup", StringComparison.InvariantCultureIgnoreCase))) ||
                    node.IsSubTypeOf("IfcProject") || node.Name.Equals("IfcProject", StringComparison.InvariantCultureIgnoreCase) ||
                    node.IsSubTypeOf("IfcTypeObject"))
                {
                    if (IFCEntityType.TryParse(entityType, true, out ifcType))
                    {
                        ret = ifcType;
                    }
                }
                else
                {
                    ret = ifcType;
                }
            }
            else if (node != null && node.isAbstract)
            {
                node = IfcSchemaEntityTree.FindNonAbsSuperType(ifcVersion, entityType, "IfcProduct", "IfcProductType", "IfcGroup", "IfcProject");
                if (node != null)
                {
                    if (Enum.TryParse <IFCEntityType>(node.Name, true, out ifcType))
                    {
                        ret = ifcType;
                    }
                }
            }

            return(ret);
        }
예제 #5
0
        private void button_supertypeTest_Click(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(textBox_type1.Text) || string.IsNullOrEmpty(textBox_type2.Text))
            {
                return;
            }

            bool res = IfcSchemaEntityTree.IsSuperTypeOf(textBox_type1.Text, textBox_type2.Text);

            if (res)
            {
                checkBox_testResult.IsChecked = true;
            }
            else
            {
                checkBox_testResult.IsChecked = false;
            }
        }
예제 #6
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="handle"></param>
        /// <returns></returns>
        public bool IsSubTypeOfEntityTypes(IFCEntityType ifcEntityType)
        {
            var ifcEntitySchemaTree = IfcSchemaEntityTree.GetEntityDictFor(ExporterCacheManager.ExportOptionsCache.FileVersion);

            if (ifcEntitySchemaTree == null || ifcEntitySchemaTree.Count == 0)
            {
                return(false);
            }

            // Note that although EntityTypes is represented as a set, we still need to go through each item in the last to check for subtypes.
            foreach (IFCEntityType entityType in EntityTypes)
            {
                if (IfcSchemaEntityTree.IsSubTypeOf(ifcEntityType.ToString(), entityType.ToString(), strict: false))
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #7
0
        void InitializePreDefinedTypeSelection(string ifcSchema, string ifcEntitySelected)
        {
            if (string.IsNullOrEmpty(ifcEntitySelected))
            {
                return;
            }

            TreeView            predefinedTypeTreeView = new TreeView();
            IfcSchemaEntityTree ifcEntityTree          = IfcSchemaEntityTree.GetEntityDictFor(ifcSchema);
            IList <string>      predefinedTypeList     = IfcSchemaEntityTree.GetPredefinedTypeList(ifcEntityTree, ifcEntitySelected);

            if (predefinedTypeList != null && predefinedTypeList.Count > 0)
            {
                TreeViewItem ifcEntityViewItem = new TreeViewItem();
                ifcEntityViewItem.Name       = ifcEntitySelected;
                ifcEntityViewItem.Header     = ifcEntitySelected + ".PREDEFINEDTYPE";
                ifcEntityViewItem.IsExpanded = true;
                predefinedTypeTreeView.Items.Add(ifcEntityViewItem);

                foreach (string predefItem in predefinedTypeList)
                {
                    TreeViewItem childNode     = new TreeViewItem();
                    RadioButton  childNodeItem = new RadioButton();
                    childNode.Name           = predefItem;
                    childNodeItem.Name       = predefItem;
                    childNodeItem.Content    = predefItem;
                    childNodeItem.Checked   += new RoutedEventHandler(PredefSelected_Checked);
                    childNodeItem.Unchecked += new RoutedEventHandler(PredefSelected_Unchecked);
                    childNode.Header         = childNodeItem;
                    ifcEntityViewItem.Items.Add(childNode);
                }
            }
            else
            {
                TreeViewItem ifcEntityViewItem = new TreeViewItem();
                ifcEntityViewItem.Name   = ifcEntitySelected;
                ifcEntityViewItem.Header = Properties.Resources.NoPredefinedType;
                predefinedTypeTreeView.Items.Add(ifcEntityViewItem);
            }
            PredefinedTypeTreeView.ItemsSource = predefinedTypeTreeView.Items;
        }
예제 #8
0
        /// <summary>
        /// Procees an IFC schema from the IFCXML schema
        /// </summary>
        /// <param name="f">IFCXML schema file</param>
        private void processSchema(FileInfo f)
        {
            ProcessIFCXMLSchema.ProcessIFCSchema(f);

            string schemaName = f.Name.Replace(".xsd", "");

            if (checkBox_outputSchemaTree.IsChecked == true)
            {
                string treeDump = IfcSchemaEntityTree.DumpTree();
                System.IO.File.WriteAllText(outputFolder + @"\entityTree" + schemaName + ".txt", treeDump);
            }

            if (checkBox_outputSchemaEnum.IsChecked == true)
            {
                string dictDump = IfcSchemaEntityTree.DumpEntityDict(schemaName);
                System.IO.File.WriteAllText(outputFolder + @"\entityEnum" + schemaName + ".cs", dictDump);
            }

            // Add aggregate of the entity list into a set
            foreach (KeyValuePair <string, IfcSchemaEntityNode> entry in IfcSchemaEntityTree.EntityDict)
            {
                aggregateEntities.Add(entry.Key);
            }
        }
예제 #9
0
        void LoadTreeviewFilterElement()
        {
            button_Reset.IsEnabled = true;
            try
            {
                string schemaFile = m_IfcVersion + ".xsd";
                // Process IFCXml schema here, then search for IfcProduct and build TreeView beginning from that node. Allow checks for the tree nodes. Grey out (and Italic) the abstract entity
                schemaFile = System.IO.Path.Combine(DirectoryUtil.IFCSchemaLocation, schemaFile);
                FileInfo      schemaFileInfo = new FileInfo(schemaFile);
                IFCEntityTrie entityTrie     = new IFCEntityTrie();

                IfcSchemaEntityTree ifcEntityTree = IfcSchemaEntityTree.GetEntityDictFor(m_IfcVersion);
                if (ifcEntityTree != null || m_TreeView.Items.Count == 0)
                {
                    m_TreeView.Items.Clear();
                    m_TreeViewItemDict.Clear();

                    if (!m_ShowTypeNodeOnly)
                    {
                        IfcSchemaEntityNode ifcProductNode;
                        if (ifcEntityTree.IfcEntityDict.TryGetValue("IfcProduct", out ifcProductNode))
                        {
                            // From IfcProductNode, recursively get all the children nodes and assign them into the treeview node (they are similar in the form)
                            TreeViewItem prod = new TreeViewItem();
                            prod.Name = "IfcProduct";
                            if (m_SingleNodeSelection)
                            {
                                prod.Header = ifcProductNode.Name + " " + TreeSelectionDesc;
                            }
                            else
                            {
                                ToggleButton prodNode = new CheckBox();
                                prodNode.Name       = prod.Name;
                                prodNode.Content    = prod.Name;
                                prodNode.IsChecked  = true;
                                prod.Header         = prodNode;
                                prodNode.Checked   += new RoutedEventHandler(TreeViewItem_HandleChecked);
                                prodNode.Unchecked += new RoutedEventHandler(TreeViewItem_HandleUnchecked);
                            }
                            prod.IsExpanded = true;
                            prod.FontWeight = FontWeights.Bold;
                            m_TreeView.Items.Add(GetNode(ifcProductNode, prod, ExclElementSet));
                        }
                    }

                    IfcSchemaEntityNode ifcTypeProductNode;
                    if (ifcEntityTree.IfcEntityDict.TryGetValue("IfcTypeProduct", out ifcTypeProductNode))
                    {
                        // From IfcTypeProductNode, recursively get all the children nodes and assign them into the treeview node (they are similar in the form)
                        TreeViewItem typeProd = new TreeViewItem();
                        typeProd.Name   = "IfcTypeProduct";
                        typeProd.Header = ifcTypeProductNode.Name + " " + TreeSelectionDesc;
                        if (m_SingleNodeSelection)
                        {
                            typeProd.Header = ifcTypeProductNode.Name + " " + TreeSelectionDesc;
                        }
                        else
                        {
                            ToggleButton typeProdNode = new CheckBox();
                            typeProdNode.Name       = typeProd.Name;
                            typeProdNode.Content    = typeProd.Name;
                            typeProdNode.IsChecked  = true;
                            typeProd.Header         = typeProdNode;
                            typeProdNode.Checked   += new RoutedEventHandler(TreeViewItem_HandleChecked);
                            typeProdNode.Unchecked += new RoutedEventHandler(TreeViewItem_HandleUnchecked);
                        }
                        typeProd.IsExpanded = true;
                        typeProd.FontWeight = FontWeights.Bold;
                        m_TreeView.Items.Add(GetNode(ifcTypeProductNode, typeProd, ExclElementSet));
                    }

                    if (!m_ShowTypeNodeOnly)
                    {
                        IfcSchemaEntityNode ifcGroupNode;
                        if (ifcEntityTree.IfcEntityDict.TryGetValue("IfcGroup", out ifcGroupNode))
                        {
                            // For IfcGroup, a header is neaded because the IfcGroup itself is not a Abstract entity
                            TreeViewItem groupHeader = new TreeViewItem();
                            groupHeader.Name = "IfcGroup";
                            if (m_SingleNodeSelection)
                            {
                                groupHeader.Header = "IfcGroup" + " " + TreeSelectionDesc;
                            }
                            else
                            {
                                ToggleButton groupHeaderNode = new CheckBox();
                                groupHeaderNode.Name       = groupHeader.Name;
                                groupHeaderNode.Content    = groupHeader.Name;
                                groupHeaderNode.IsChecked  = true;
                                groupHeader.Header         = groupHeaderNode;
                                groupHeaderNode.Checked   += new RoutedEventHandler(TreeViewItem_HandleChecked);
                                groupHeaderNode.Unchecked += new RoutedEventHandler(TreeViewItem_HandleUnchecked);
                            }
                            groupHeader.IsExpanded = true;
                            groupHeader.FontWeight = FontWeights.Bold;
                            m_TreeView.Items.Add(groupHeader);

                            // From IfcGroup Node, recursively get all the children nodes and assign them into the treeview node (they are similar in the form)
                            TreeViewItem groupNode = new TreeViewItem();
                            ToggleButton groupNodeItem;
                            if (m_SingleNodeSelection)
                            {
                                groupNodeItem = new RadioButton();
                            }
                            else
                            {
                                groupNodeItem = new CheckBox();
                            }
                            groupNode.Name       = "IfcGroup";
                            groupNode.Header     = groupNodeItem;
                            groupNode.IsExpanded = true;
                            m_TreeViewItemDict.Add(groupNode.Name, groupNode);
                            m_EntityTrie.AddIFCEntityToDict(groupNode.Name);

                            groupNodeItem.Name       = "IfcGroup";
                            groupNodeItem.Content    = "IfcGroup";
                            groupNodeItem.FontWeight = FontWeights.Normal;
                            groupNodeItem.IsChecked  = true; // Default is always Checked
                            if (ExclElementSet.Contains(groupNode.Name) || m_SingleNodeSelection)
                            {
                                groupNodeItem.IsChecked = false; // if the name is inside the excluded element hashset, UNcheck the checkbox (= remember the earlier choice)
                            }
                            groupNodeItem.Checked   += new RoutedEventHandler(TreeViewItem_HandleChecked);
                            groupNodeItem.Unchecked += new RoutedEventHandler(TreeViewItem_HandleUnchecked);

                            groupHeader.Items.Add(GetNode(ifcGroupNode, groupNode, ExclElementSet));
                        }
                    }
                }
                else
                {
                    // Check all elements that have been excluded before for this configuration
                    foreach (TreeViewItem tvItem in m_TreeView.Items)
                    {
                        UnCheckSelectedNode(tvItem, ExclElementSet);
                    }
                }
            }
            catch
            {
                // Error above in processing - disable the tree view.
                m_TreeView.IsEnabled = false;
            }
            IFCEntityTreeView.ItemsSource = m_TreeView.Items;
        }
예제 #10
0
 /// <summary>
 /// Checks if export type is conversion device.
 /// </summary>
 /// <param name="exportType">
 /// The export type.
 /// </param>
 /// <returns>
 /// True if it is conversion device, false otherwise.
 /// </returns>
 public static bool IsEnergyConversionDeviceSubType(IFCExportInfoPair exportType)
 {
     return(IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportInstance.ToString(), IFCEntityType.IfcEnergyConversionDevice.ToString(), strict: false) ||
            IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportType.ToString(), IFCEntityType.IfcEnergyConversionDeviceType.ToString(), strict: false));
 }
예제 #11
0
 /// <summary>
 /// Checks if export type is flow fitting.
 /// </summary>
 /// <param name="exportType">
 /// The export type.
 /// </param>
 /// <returns>
 /// True if it is flow fitting, false otherwise.
 /// </returns>
 public static bool IsFlowFittingSubType(IFCExportInfoPair exportType)
 {
     return(IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportInstance.ToString(), IFCEntityType.IfcFlowFitting.ToString(), strict: false) ||
            IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportType.ToString(), IFCEntityType.IfcFlowFittingType.ToString(), strict: false));
 }
        /// <summary>
        /// Initialization for the class for PredefinedType selection
        /// </summary>
        /// <param name="ifcVersion">the IFC version selected. If it is specific, it will be locked</param>
        /// <param name="ifcEntitySelected">the ifc entity to find the predefinedtype</param>
        public PredefinedTypeSelection(IFCVersion ifcVersion, string ifcEntitySelected)
        {
            string ifcSchema = IfcSchemaEntityTree.SchemaName(ifcVersion);

            InitializePreDefinedTypeSelection(ifcSchema, ifcEntitySelected);
        }
예제 #13
0
 /// <summary>
 /// Checks if export type is distribution control element.
 /// </summary>
 /// <param name="exportType">
 /// The export type.
 /// </param>
 /// <returns>
 /// True if it is distribution control element, false otherwise.
 /// </returns>
 public static bool IsDistributionControlElementSubType(IFCExportInfoPair exportType)
 {
     return(IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportInstance.ToString(), IFCEntityType.IfcDistributionControlElement.ToString(), strict: false) ||
            IfcSchemaEntityTree.IsSubTypeOf(ExporterCacheManager.ExportOptionsCache.FileVersion, exportType.ExportType.ToString(), IFCEntityType.IfcDistributionControlElementType.ToString(), strict: false));
 }
예제 #14
0
        /// <summary>
        /// Set the pair information using only either the entity or the type
        /// </summary>
        /// <param name="entityTypeStr">the entity or type string</param>
        /// <param name="predefineType">predefinedtype string</param>
        public void SetValueWithPair(string entityTypeStr, string predefineType = null)
        {
            int  typeLen = 4;
            bool isType  = entityTypeStr.Substring(entityTypeStr.Length - 4, 4).Equals("Type", StringComparison.CurrentCultureIgnoreCase);

            if (!isType)
            {
                if (entityTypeStr.Equals("IfcDoorStyle", StringComparison.InvariantCultureIgnoreCase) ||
                    entityTypeStr.Equals("IfcWindowStyle", StringComparison.InvariantCultureIgnoreCase))
                {
                    isType  = true;
                    typeLen = 5;
                }
            }

            if (isType)
            {
                // Get the instance
                string instName          = entityTypeStr.Substring(0, entityTypeStr.Length - typeLen);
                IfcSchemaEntityNode node = IfcSchemaEntityTree.Find(instName);
                if (node != null && !node.isAbstract)
                {
                    IFCEntityType instType = IFCEntityType.UnKnown;
                    if (IFCEntityType.TryParse(instName, true, out instType))
                    {
                        m_ExportInstance = instType;
                    }
                }
                else
                {
                    // If not found, try non-abstract supertype derived from the type
                    node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(instName);
                    if (node != null)
                    {
                        IFCEntityType instType = IFCEntityType.UnKnown;
                        if (IFCEntityType.TryParse(node.Name, true, out instType))
                        {
                            m_ExportInstance = instType;
                        }
                    }
                }

                // set the type
                IFCEntityType entityType = ElementFilteringUtil.GetValidIFCEntityType(entityTypeStr);
                if (entityType != IFCEntityType.UnKnown)
                {
                    m_ExportType = entityType;
                }
                else
                {
                    node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(entityTypeStr);
                    if (node != null)
                    {
                        IFCEntityType instType = IFCEntityType.UnKnown;
                        if (IFCEntityType.TryParse(node.Name, true, out instType))
                        {
                            m_ExportType = instType;
                        }
                    }
                }
            }
            else
            {
                // set the instance
                IFCEntityType instType = ElementFilteringUtil.GetValidIFCEntityType(entityTypeStr);
                if (instType != IFCEntityType.UnKnown)
                {
                    m_ExportInstance = instType;
                }
                else
                {
                    // If not found, try non-abstract supertype derived from the type
                    IfcSchemaEntityNode node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(entityTypeStr);
                    if (node != null)
                    {
                        instType = IFCEntityType.UnKnown;
                        if (IFCEntityType.TryParse(node.Name, true, out instType))
                        {
                            m_ExportInstance = instType;
                        }
                    }
                }

                // set the type pair
                string typeName = entityTypeStr;
                if (ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4 &&
                    (entityTypeStr.Equals("IfcDoor", StringComparison.InvariantCultureIgnoreCase) ||
                     entityTypeStr.Equals("IfcWindow", StringComparison.InvariantCultureIgnoreCase)))
                {
                    typeName += "Style";
                }
                else
                {
                    typeName += "Type";
                }

                IFCEntityType entityType = ElementFilteringUtil.GetValidIFCEntityType(typeName);
                if (entityType != IFCEntityType.UnKnown)
                {
                    m_ExportType = entityType;
                }
                else
                {
                    // If the type name is not found, likely it does not have the pair at this level, needs to get the supertype of the instance to get the type pair
                    IList <IfcSchemaEntityNode> instNodes = IfcSchemaEntityTree.FindAllSuperTypes(entityTypeStr, "IfcProduct", "IfcGroup");
                    foreach (IfcSchemaEntityNode instNode in instNodes)
                    {
                        typeName = instNode.Name + "Type";
                        IfcSchemaEntityNode node = IfcSchemaEntityTree.Find(typeName);
                        if (node == null)
                        {
                            node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(typeName);
                        }

                        if (node != null && !node.isAbstract)
                        {
                            instType = IFCEntityType.UnKnown;
                            if (IFCEntityType.TryParse(node.Name, true, out instType))
                            {
                                m_ExportType = instType;
                                break;
                            }
                        }
                    }
                }
            }

            ValidatedPredefinedType = predefineType;
        }
예제 #15
0
        /// <summary>
        /// Gets export type from IFC class name.
        /// </summary>
        /// <param name="ifcClassName">The IFC class name.</param>
        /// <returns>The export type.</returns>
        public static IFCExportInfoPair GetExportTypeFromClassName(String ifcClassName)
        {
            IFCExportInfoPair exportInfoPair = new IFCExportInfoPair();

            if (ifcClassName.StartsWith("Ifc", true, null))
            {
                // Here we try to catch any possible types that are missing above by checking both the class name or the type name
                // Unless there is any special treatment needed most of the above check can be done here
                string clName = ifcClassName.Substring(ifcClassName.Length - 4, 4).Equals("Type", StringComparison.CurrentCultureIgnoreCase) ? ifcClassName.Substring(0, ifcClassName.Length - 4) : ifcClassName;
                string tyName = null;
                if (((ExporterCacheManager.ExportOptionsCache.ExportAs2x2 || ExporterCacheManager.ExportOptionsCache.ExportAs2x3)) &&
                    (clName.Equals("IfcDoor", StringComparison.InvariantCultureIgnoreCase) || clName.Equals("ifcWindow", StringComparison.InvariantCultureIgnoreCase)))
                {
                    // Prior to IFC4 Door and Window types are not "Ifc..Type", but "Ifc.. Style"
                    tyName = clName + "Style";
                }
                else
                {
                    tyName = clName + "Type";
                }
                IFCEntityType theGenExportClass;
                IFCEntityType theGenExportType;
                var           ifcEntitySchemaTree = IfcSchemaEntityTree.GetEntityDictFor(ExporterCacheManager.ExportOptionsCache.FileVersion);
                if (ifcEntitySchemaTree == null || ifcEntitySchemaTree.Count == 0)
                {
                    throw new Exception("Unable to locate IFC Schema xsd file! Make sure the relevant xsd " + ExporterCacheManager.ExportOptionsCache.FileVersion + " exists.");
                }

                bool clNameValid = false;
                bool tyNameValid = false;

                IfcSchemaEntityNode clNode = IfcSchemaEntityTree.Find(clName);
                if (clNode != null)
                {
                    clNameValid = IfcSchemaEntityTree.IsSubTypeOf(clName, "IfcProduct") && !clNode.isAbstract;
                }

                IfcSchemaEntityNode tyNode = IfcSchemaEntityTree.Find(tyName);
                if (tyNode != null)
                {
                    tyNameValid = IfcSchemaEntityTree.IsSubTypeOf(tyName, "IfcTypeProduct") && !tyNode.isAbstract;
                }

                if (tyNameValid)
                {
                    if (IFCEntityType.TryParse(tyName, out theGenExportType))
                    {
                        exportInfoPair.ExportType = theGenExportType;
                    }
                }

                if (clNameValid)
                {
                    if (IFCEntityType.TryParse(clName, out theGenExportClass))
                    {
                        exportInfoPair.ExportInstance = theGenExportClass;
                    }
                }
                // If the instance is not valid, but the type is valid, try find the paired instance supertype that is not Abstract type
                else if (tyNameValid)
                {
                    IfcSchemaEntityNode compatibleInstance = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(tyName);
                    if (compatibleInstance != null)
                    {
                        if (IFCEntityType.TryParse(compatibleInstance.Name, out theGenExportClass))
                        {
                            exportInfoPair.ExportInstance = theGenExportClass;
                        }
                    }
                }

                // This used to throw an exception, but this could abort export if the user enters a bad IFC class name
                // in the ExportLayerOptions table.  In the future, we should log this.
                //throw new Exception("IFC: Unknown IFC type in getExportTypeFromClassName: " + ifcClassName);
                //return IFCExportType.IfcBuildingElementProxyType;

                if (exportInfoPair.ExportInstance == IFCEntityType.UnKnown)
                {
                    exportInfoPair.ExportInstance = IFCEntityType.IfcBuildingElementProxy;
                }
            }

            //return IFCExportType.DontExport;
            return(exportInfoPair);
        }
예제 #16
0
        /// <summary>
        /// Set the pair information using only either the entity or the type
        /// </summary>
        /// <param name="entityType">the entity or type</param>
        public void SetValueWithPair(IFCEntityType entityType)
        {
            string entityTypeStr = entityType.ToString();
            bool   isType        = entityTypeStr.Substring(entityTypeStr.Length - 4, 4).Equals("Type", StringComparison.CurrentCultureIgnoreCase);

            if (isType)
            {
                // Get the instance
                string instName          = entityTypeStr.Substring(0, entityTypeStr.Length - 4);
                IfcSchemaEntityNode node = IfcSchemaEntityTree.Find(instName);
                if (node != null && !node.isAbstract)
                {
                    IFCEntityType instType = IFCEntityType.UnKnown;
                    if (IFCEntityType.TryParse(instName, out instType))
                    {
                        ExportInstance = instType;
                    }
                }
                // If not found, try non-abstract supertype derived from the type
                node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(instName);
                if (node != null)
                {
                    IFCEntityType instType = IFCEntityType.UnKnown;
                    if (IFCEntityType.TryParse(node.Name, out instType))
                    {
                        ExportInstance = instType;
                    }
                }

                // set the type
                entityType = ElementFilteringUtil.GetValidIFCEntityType(entityType);
                if (entityType != IFCEntityType.UnKnown)
                {
                    ExportType = entityType;
                }
                else
                {
                    node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(entityTypeStr);
                    if (node != null)
                    {
                        IFCEntityType instType = IFCEntityType.UnKnown;
                        if (IFCEntityType.TryParse(node.Name, out instType))
                        {
                            ExportType = instType;
                        }
                    }
                }
            }
            else
            {
                // set the instance
                entityType = ElementFilteringUtil.GetValidIFCEntityType(entityType);
                if (entityType != IFCEntityType.UnKnown)
                {
                    ExportInstance = entityType;
                }
                else
                {
                    // If not found, try non-abstract supertype derived from the type
                    IfcSchemaEntityNode node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(entityTypeStr);
                    if (node != null)
                    {
                        IFCEntityType instType = IFCEntityType.UnKnown;
                        if (IFCEntityType.TryParse(node.Name, out instType))
                        {
                            ExportInstance = instType;
                        }
                    }
                }

                // set the type pair
                string typeName = entityType.ToString() + "Type";
                entityType = ElementFilteringUtil.GetValidIFCEntityType(typeName);
                if (entityType != IFCEntityType.UnKnown)
                {
                    ExportType = entityType;
                }
                else
                {
                    IfcSchemaEntityNode node = IfcSchemaEntityTree.FindNonAbsInstanceSuperType(typeName);
                    if (node != null)
                    {
                        IFCEntityType instType = IFCEntityType.UnKnown;
                        if (IFCEntityType.TryParse(node.Name, out instType))
                        {
                            ExportType = instType;
                        }
                    }
                }
            }
        }
예제 #17
0
        TreeViewItem GetNode(IfcSchemaEntityNode ifcNode, TreeViewItem thisNode, HashSet <string> exclSet)
        {
            foreach (IfcSchemaEntityNode ifcNodeChild in ifcNode.GetChildren())
            {
                // Skip deprecated entity
                if (IfcSchemaEntityTree.IsDeprecatedOrUnsupported(m_IfcVersion, ifcNodeChild.Name))
                {
                    continue;
                }

                TreeViewItem childNode = new TreeViewItem();
                if (m_SingleNodeSelection)
                {
                    childNode.Name = ifcNodeChild.Name;
                    m_TreeViewItemDict.Add(childNode.Name, childNode);
                    m_EntityTrie.AddIFCEntityToDict(ifcNodeChild.Name);

                    if (ifcNodeChild.isAbstract)
                    {
                        childNode.Header     = ifcNodeChild.Name;
                        childNode.FontWeight = FontWeights.Normal;
                    }
                    else
                    {
                        ToggleButton childNodeItem;
                        childNodeItem            = new RadioButton();
                        childNodeItem.Name       = ifcNodeChild.Name;
                        childNodeItem.Content    = ifcNodeChild.Name;
                        childNodeItem.FontWeight = FontWeights.Normal;
                        childNodeItem.IsChecked  = false;
                        childNodeItem.Checked   += new RoutedEventHandler(TreeViewItem_HandleChecked);
                        childNodeItem.Unchecked += new RoutedEventHandler(TreeViewItem_HandleUnchecked);
                        childNode.Header         = childNodeItem;
                    }
                }
                else
                {
                    childNode.Name = ifcNodeChild.Name;
                    m_TreeViewItemDict.Add(childNode.Name, childNode);
                    m_EntityTrie.AddIFCEntityToDict(ifcNodeChild.Name);

                    ToggleButton childNodeItem;
                    childNodeItem            = new CheckBox();
                    childNodeItem.Name       = ifcNodeChild.Name;
                    childNodeItem.Content    = ifcNodeChild.Name;
                    childNodeItem.FontWeight = FontWeights.Normal;
                    childNodeItem.IsChecked  = true;   // Default is always Checked
                    if (exclSet.Contains(ifcNodeChild.Name))
                    {
                        childNodeItem.IsChecked = false; // if the name is inside the excluded element hashset, UNcheck the checkbox (= remember the earlier choice)
                    }
                    childNodeItem.Checked   += new RoutedEventHandler(TreeViewItem_HandleChecked);
                    childNodeItem.Unchecked += new RoutedEventHandler(TreeViewItem_HandleUnchecked);
                    childNode.Header         = childNodeItem;
                }

                childNode.IsExpanded = true;
                childNode            = GetNode(ifcNodeChild, childNode, exclSet);
                thisNode.Items.Add(childNode);
            }
            return(thisNode);
        }
예제 #18
0
        private void button_Go_Click(object sender, RoutedEventArgs e)
        {
            if (listBox_schemaList.SelectedItems.Count == 0)
            {
                return;
            }

            DirectoryInfo dInfo = new DirectoryInfo(textBox_folderLocation.Text);

            if (dInfo == null)
            {
                return;
            }

            if (aggregateEntities == null)
            {
                aggregateEntities = new SortedSet <string>();
            }
            aggregateEntities.Clear();

            if (!Directory.Exists(textBox_outputFolder.Text))
            {
                textBox_outputFolder.Text = "";
                return;
            }

            logF = new StreamWriter(System.IO.Path.Combine(outputFolder, "entityList.log"));

            IList <IFCEntityAndPsetList> fxEntityNPsetList = new List <IFCEntityAndPsetList>();

            string jsonFile = outputFolder + @"\IFCEntityAndPsetDefs.json";

            if (File.Exists(jsonFile))
            {
                File.Delete(jsonFile);
            }
            FileStream fs = File.Create(jsonFile);
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(List <IFCEntityAndPsetList>));

            foreach (string fileName in listBox_schemaList.SelectedItems)
            {
                FileInfo f = dInfo.GetFiles(fileName).First();
                processSchema(f);

                ProcessPsetDefinition procPdef = new ProcessPsetDefinition(logF);

                string schemaName = f.Name.Replace(".xsd", "");
                IDictionary <string, IfcSchemaEntityNode> entDict = IfcSchemaEntityTree.GetEntityDictFor(f.Name);
                IFCEntityAndPsetList schemaEntities = new IFCEntityAndPsetList();
                schemaEntities.Version     = schemaName;
                schemaEntities.EntityList  = new HashSet <IFCEntityInfo>();
                schemaEntities.PsetDefList = new HashSet <IFCPropertySetDef>();

                DirectoryInfo[] psdFolders      = new DirectoryInfo(System.IO.Path.Combine(textBox_folderLocation.Text, schemaName)).GetDirectories("psd", SearchOption.AllDirectories);
                DirectoryInfo[] underpsdFolders = psdFolders[0].GetDirectories();
                if (underpsdFolders.Count() > 0)
                {
                    foreach (DirectoryInfo subDir in psdFolders[0].GetDirectories())
                    {
                        procPdef.ProcessSchemaPsetDef(schemaName, subDir);
                    }
                }
                else
                {
                    procPdef.ProcessSchemaPsetDef(schemaName, psdFolders[0]);
                }

                //Collect information on applicable Psets for Entity
                IDictionary <string, HashSet <string> > entPsetDict = new Dictionary <string, HashSet <string> >();
                foreach (KeyValuePair <string, IList <VersionSpecificPropertyDef> > pdefEntry in procPdef.allPDefDict)
                {
                    foreach (VersionSpecificPropertyDef vPdef in pdefEntry.Value)
                    {
                        //if (vPdef.IfcVersion.Equals(schemaName, StringComparison.InvariantCultureIgnoreCase))
                        {
                            IFCPropertySetDef psetDef = new IFCPropertySetDef();
                            psetDef.PsetName = vPdef.PropertySetDef.Name;
                            IList <string> props = new List <string>();
                            foreach (PropertySet.PsetProperty property in vPdef.PropertySetDef.properties)
                            {
                                props.Add(property.Name);
                            }
                            psetDef.Properties = props;
                            schemaEntities.PsetDefList.Add(psetDef);

                            // TODO: to check the appl classes either a type or not and check whether the pair (type or without) exists in entDict, if there is add
                            foreach (string applEntity in vPdef.PropertySetDef.ApplicableClasses)
                            {
                                if (entPsetDict.ContainsKey(applEntity))
                                {
                                    entPsetDict[applEntity].Add(vPdef.PropertySetDef.Name);
                                }
                                else
                                {
                                    entPsetDict.Add(applEntity, new HashSet <string>()
                                    {
                                        vPdef.PropertySetDef.Name
                                    });
                                }

                                // The Pset will be valid for both the Instance and the Type. Check for that here and add if found
                                string entOrTypePair;
                                if (applEntity.Length > 4 && applEntity.EndsWith("Type"))
                                {
                                    entOrTypePair = applEntity.Substring(0, applEntity.Length - 4);
                                }
                                else
                                {
                                    entOrTypePair = applEntity + "Type";
                                }

                                if (aggregateEntities.Contains(entOrTypePair))
                                {
                                    if (entPsetDict.ContainsKey(entOrTypePair))
                                    {
                                        entPsetDict[entOrTypePair].Add(vPdef.PropertySetDef.Name);
                                    }
                                    else
                                    {
                                        entPsetDict.Add(entOrTypePair, new HashSet <string>()
                                        {
                                            vPdef.PropertySetDef.Name
                                        });
                                    }
                                }
                            }
                        }
                    }
                }

                // For every entity of the schema, collect the list of PredefinedType (obtained from the xsd), and collect all applicable
                //  Pset Definitions collected above
                foreach (KeyValuePair <string, IfcSchemaEntityNode> ent in entDict)
                {
                    IFCEntityInfo entInfo = new IFCEntityInfo();

                    // The abstract entity type is not going to be listed here as they can never be created
                    if (ent.Value.isAbstract)
                    {
                        continue;
                    }

                    // Collect only the IfcProducts or IfcGroup
                    if (!ent.Value.IsSubTypeOf("IfcProduct") && !ent.Value.IsSubTypeOf("IfcGroup") && !ent.Value.IsSubTypeOf("IfcTypeProduct"))
                    {
                        continue;
                    }

                    entInfo.Entity = ent.Key;
                    if (!string.IsNullOrEmpty(ent.Value.PredefinedType))
                    {
                        if (IfcSchemaEntityTree.PredefinedTypeEnumDict.ContainsKey(ent.Value.PredefinedType))
                        {
                            entInfo.PredefinedType = IfcSchemaEntityTree.PredefinedTypeEnumDict[ent.Value.PredefinedType];
                        }
                    }

                    // Get Pset list that is applicable to this entity type
                    if (entPsetDict.ContainsKey(entInfo.Entity))
                    {
                        entInfo.PropertySets = entPsetDict[entInfo.Entity].ToList();
                    }
                    // Collect Pset that is applicable to the supertype of this entity
                    IList <IfcSchemaEntityNode> supertypeList = IfcSchemaEntityTree.FindAllSuperTypes(entInfo.Entity,
                                                                                                      "IfcProduct", "IfcTypeProduct", "IfcGroup");
                    if (supertypeList != null && supertypeList.Count > 0)
                    {
                        foreach (IfcSchemaEntityNode superType in supertypeList)
                        {
                            if (entPsetDict.ContainsKey(superType.Name))
                            {
                                if (entInfo.PropertySets == null)
                                {
                                    entInfo.PropertySets = new List <string>();
                                }

                                foreach (string pset in entPsetDict[superType.Name])
                                {
                                    entInfo.PropertySets.Add(pset);
                                }
                            }
                        }
                    }

                    schemaEntities.EntityList.Add(entInfo);
                }
                fxEntityNPsetList.Add(schemaEntities);
            }
            ser.WriteObject(fs, fxEntityNPsetList);
            fs.Close();

            if (aggregateEntities.Count > 0)
            {
                string entityList;
                entityList = "using System;"
                             + "\r\nusing System.Collections.Generic;"
                             + "\r\nusing System.Linq;"
                             + "\r\nusing System.Text;"
                             + "\r\n"
                             + "\r\nnamespace Revit.IFC.Common.Enums"
                             + "\r\n{"
                             + "\r\n   /// <summary>"
                             + "\r\n   /// IFC entity types. Combining IFC2x3 and IFC4 (Add2) entities."
                             + "\r\n   /// List of Entities for IFC2x is found in IFC2xEntityType.cs"
                             + "\r\n   /// List of Entities for IFC4 is found in IFC4EntityType.cs"
                             + "\r\n   /// </summary>"
                             + "\r\n   public enum IFCEntityType"
                             + "\r\n   {";

                foreach (string ent in aggregateEntities)
                {
                    entityList += "\r\n      /// <summary>"
                                  + "\r\n      /// IFC Entity " + ent + " enumeration"
                                  + "\r\n      /// </summary>"
                                  + "\r\n      " + ent + ",\n";
                }
                entityList += "\r\n      Unknown,"
                              + "\r\n      DontExport"
                              + "\r\n   }"
                              + "\r\n}";
                System.IO.File.WriteAllText(outputFolder + @"\IFCEntityType.cs", entityList);
            }

            foreach (IFCEntityAndPsetList fxEntityNPset in fxEntityNPsetList)
            {
                string entityList;
                entityList = "using System;"
                             + "\r\nusing System.Collections.Generic;"
                             + "\r\nusing System.Linq;"
                             + "\r\nusing System.Text;"
                             + "\r\n"
                             + "\r\nnamespace Revit.IFC.Common.Enums." + fxEntityNPset.Version
                             + "\r\n{"
                             + "\r\n   /// <summary>"
                             + "\r\n   /// List of Entities for " + fxEntityNPset.Version
                             + "\r\n   /// </summary>"
                             + "\r\n   public enum EntityType"
                             + "\r\n   {";

                foreach (IFCEntityInfo entInfo in fxEntityNPset.EntityList)
                {
                    entityList += "\r\n      /// <summary>"
                                  + "\r\n      /// IFC Entity " + entInfo.Entity + " enumeration"
                                  + "\r\n      /// </summary>"
                                  + "\r\n      " + entInfo.Entity + ",\r\n";
                }
                entityList += "\r\n      Unknown,"
                              + "\r\n      DontExport"
                              + "\r\n   }"
                              + "\r\n}";
                System.IO.File.WriteAllText(outputFolder + @"\" + fxEntityNPset.Version + "EntityType.cs", entityList);
            }

            // Only allows test when only one schema is selected
            if (listBox_schemaList.SelectedItems.Count == 1)
            {
                button_subtypeTest.IsEnabled    = true;
                button_supertypeTest.IsEnabled  = true;
                button_ExportInfoPair.IsEnabled = true;
            }
            else
            {
                button_subtypeTest.IsEnabled    = false;
                button_supertypeTest.IsEnabled  = false;
                button_ExportInfoPair.IsEnabled = false;
            }

            if (logF != null)
            {
                logF.Close();
            }
        }