diff --git a/Revit_Core_Engine/Convert/FromRevit.cs b/Revit_Core_Engine/Convert/FromRevit.cs index 66f80fe35..715afb7da 100644 --- a/Revit_Core_Engine/Convert/FromRevit.cs +++ b/Revit_Core_Engine/Convert/FromRevit.cs @@ -70,6 +70,28 @@ public static IGeometry IFromRevit(this Location location) /**** Convert Revit elements to BHoM ****/ /***************************************************/ + [Description("Converts a Revit ParameterFilterElement to a BHoM object based on the requested engineering discipline.")] + [Input("parameterFilterElement", "Revit ParameterFilterElement to be converted.")] + [Input("discipline", "Engineering discipline based on the BHoM discipline classification.")] + [Input("transform", "Optional, a transform to apply to the converted object.")] + [Input("settings", "Revit adapter settings to be used while performing the convert.")] + [Input("refObjects", "Optional, a collection of objects already processed in the current adapter action, stored to avoid processing the same object more than once.")] + [Output("fromRevit", "Resulted BHoM object converted from a Revit ParameterFilterElement.")] + public static List FromRevit(this ParameterFilterElement parameterFilterElement, Discipline discipline, Transform transform = null, RevitSettings settings = null, Dictionary> refObjects = null) + { + if (parameterFilterElement == null) + { + BH.Engine.Base.Compute.RecordWarning("BHoM object could not be read because Revit Parameter Filter Element is null."); + return null; + } + else + { + return new List { ViewFilterFromRevit(parameterFilterElement, settings, refObjects) }; + } + } + + /***************************************************/ + [Description("Converts a Revit EnergyAnalysisDetailModel to a BHoM object based on the requested engineering discipline.")] [Input("energyAnalysisModel", "Revit EnergyAnalysisDetailModel to be converted.")] [Input("discipline", "Engineering discipline based on the BHoM discipline classification.")] diff --git a/Revit_Core_Engine/Convert/Revit/FromRevit/DraftingInstance.cs b/Revit_Core_Engine/Convert/Revit/FromRevit/DraftingInstance.cs index 48dc7599a..94b46db32 100644 --- a/Revit_Core_Engine/Convert/Revit/FromRevit/DraftingInstance.cs +++ b/Revit_Core_Engine/Convert/Revit/FromRevit/DraftingInstance.cs @@ -53,7 +53,7 @@ public static DraftingInstance DraftingInstanceFromRevit(this FilledRegion fille if (draftingInstance != null) return draftingInstance; - View view = filledRegion.Document.GetElement(filledRegion.OwnerViewId) as View; + Autodesk.Revit.DB.View view = filledRegion.Document.GetElement(filledRegion.OwnerViewId) as Autodesk.Revit.DB.View; if (view == null) return null; diff --git a/Revit_Core_Engine/Convert/Revit/FromRevit/IInstance.cs b/Revit_Core_Engine/Convert/Revit/FromRevit/IInstance.cs index b9d53b2f7..7627a5388 100644 --- a/Revit_Core_Engine/Convert/Revit/FromRevit/IInstance.cs +++ b/Revit_Core_Engine/Convert/Revit/FromRevit/IInstance.cs @@ -55,7 +55,7 @@ public static IInstance InstanceFromRevit(this CurveElement curveElement, RevitS if (curveElement.ViewSpecific) { - View view = curveElement.Document.GetElement(curveElement.OwnerViewId) as View; + Autodesk.Revit.DB.View view = curveElement.Document.GetElement(curveElement.OwnerViewId) as Autodesk.Revit.DB.View; if (view == null) return null; diff --git a/Revit_Core_Engine/Convert/Revit/FromRevit/View.cs b/Revit_Core_Engine/Convert/Revit/FromRevit/View.cs new file mode 100644 index 000000000..72d0ef8f3 --- /dev/null +++ b/Revit_Core_Engine/Convert/Revit/FromRevit/View.cs @@ -0,0 +1,157 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2024, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using Autodesk.Revit.DB; +using BH.Engine.Adapters.Revit; +using BH.oM.Adapters.Revit.Elements; +using BH.oM.Adapters.Revit.Settings; +using BH.oM.Base; +using BH.oM.Base.Attributes; +using BH.oM.Revit.Enums; +using BH.oM.Revit.Views; +using BH.Revit.Engine.Core; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Linq; +using System.Security.Policy; +using System.Xml.Linq; +using FilterRule = BH.oM.Revit.FilterRules.FilterRule; +using OverrideGraphicSettings = BH.oM.Adapters.Revit.Elements.OverrideGraphicSettings; +using View = Autodesk.Revit.DB.View; + +namespace BH.Revit.Engine.Core +{ + public static partial class Convert + { + /***************************************************/ + /**** Public Methods ****/ + /***************************************************/ + + [Description("Converts a Revit View to BH.oM.Adapters.Revit.Elements.View.")] + [Input("revitView", "Revit View to be converted.")] + [Input("settings", "Revit adapter settings to be used while performing the convert.")] + [Input("refObjects", "Optional, a collection of objects already processed in the current adapter action, stored to avoid processing the same object more than once.")] + [Output("view", "BH.oM.Adapters.Revit.Elements.View resulting from converting the input Revit View.")] + public static oM.Adapters.Revit.Elements.View ViewFromRevit(this View revitView, RevitSettings settings = null, Dictionary> refObjects = null) + { + settings = settings.DefaultIfNull(); + + oM.Adapters.Revit.Elements.View view = refObjects.GetValue(revitView.Id.IntegerValue); + if (view != null) + return view; + + if (revitView.AreGraphicsOverridesAllowed()) { + /*1. Transfer ViewFilters and corresponding OverrideGraphicSettings into ViewFilterWithOverrides Objects - via STREAMS */ + List filtersWithOverrides = revitView.GetFilters().ToDictionary + (elId => Convert.ViewFilterFromRevit((ParameterFilterElement)revitView.Document.GetElement(elId)), + elId => OverrideGraphicSettingsFromRevit(revitView, revitView.GetFilterOverrides(elId))).ToList() + .Select(kvp => new ViewFilterWithOverrides { Filter = kvp.Key, Overrides = kvp.Value }).ToList(); + /*2. Create BHoM View Object with Name and FilterWithOverrides objects */ + view = new oM.Adapters.Revit.Elements.View { Name = revitView.Name, FiltersWithOverrides = filtersWithOverrides };} + else { view = new oM.Adapters.Revit.Elements.View { Name=revitView.Name };} + + //Set identifiers, parameters & custom data + view.SetIdentifiers(revitView); + view.CopyParameters(revitView, settings.MappingSettings); + view.SetProperties(revitView, settings.MappingSettings); + + refObjects.AddOrReplace(revitView.Id, view); + return view; + } + + /***************************************************/ + + private static OverrideGraphicSettings OverrideGraphicSettingsFromRevit(this View element, Autodesk.Revit.DB.OverrideGraphicSettings revitOverrides) + { + // Initialize BHoM OverrideGraphicsSettings object + OverrideGraphicSettings overrideGraphicsSettings = new OverrideGraphicSettings(); + + + // Convert COLORS + if (revitOverrides.CutLineColor.IsValid) overrideGraphicsSettings.LineColor = System.Drawing.Color.FromArgb(revitOverrides.CutLineColor.Red, revitOverrides.CutLineColor.Green, revitOverrides.CutLineColor.Blue); + if (revitOverrides.CutForegroundPatternColor.IsValid) overrideGraphicsSettings.CutColor = System.Drawing.Color.FromArgb(revitOverrides.CutBackgroundPatternColor.Red, revitOverrides.CutBackgroundPatternColor.Green, revitOverrides.CutBackgroundPatternColor.Blue); + if (revitOverrides.SurfaceBackgroundPatternColor.IsValid) overrideGraphicsSettings.SurfaceColor = System.Drawing.Color.FromArgb(revitOverrides.SurfaceBackgroundPatternColor.Red, revitOverrides.SurfaceBackgroundPatternColor.Green, revitOverrides.SurfaceBackgroundPatternColor.Blue); + + + // Convert LINE PATTERNS + + if (revitOverrides.CutLinePatternId.IntegerValue==-1) + { + String linePatternName = element.Document.GetElement(revitOverrides.CutLinePatternId).Name; + + if (linePatternName.Replace(" ","").ToUpper().Contains("DASHDOTDOT")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.DashDotDot; } + else if (linePatternName.ToUpper().Replace(" ","").Contains("DASHDOT")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.DashDot; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("DOUBLEDASH")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.DoubleDash; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("LONGDASH")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.LongDash; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("LOOSEDASH")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.LooseDash; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("TRIPLEDASH")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.TripleDash; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("DASH")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.Dash; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("DOT")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.Dot; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("HIDDEN")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.Hidden; } + else if (linePatternName.ToUpper().Replace(" ", "").Contains("SOLID")) { overrideGraphicsSettings.LinePattern = oM.Revit.Enums.LinePattern.Solid; } + else { BH.Engine.Base.Compute.RecordWarning($"The Revit Line Pattern {linePatternName} is not implemented yet in the BHoM.\n By default, the Line Pattern {linePatternName} will be set to SOLID."); } + } else { BH.Engine.Base.Compute.RecordWarning($"The Revit Line Pattern for the Revit OverrideGraphicSettings {revitOverrides.ToString()} is not defined.");} + + + // Convert CUT PATTERNS + + if (revitOverrides.CutBackgroundPatternId.IntegerValue == -1) + { + String cutPatternName = element.Document.GetElement(revitOverrides.CutBackgroundPatternId).Name; + + if (cutPatternName.ToUpper().Contains("CROSSHATCH") && !cutPatternName.ToUpper().Contains("DIAGONAL")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.CrossHatch; } + else if (cutPatternName.ToUpper().Contains("CROSSHATCH") && cutPatternName.ToUpper().Contains("DIAGONAL")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.DiagonalCrossHatch; } + else if (cutPatternName.ToUpper().Contains("DIAGONAL") && cutPatternName.ToUpper().Contains("DOWN")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.DiagonalDown; } + else if (cutPatternName.ToUpper().Contains("DIAGONAL") && cutPatternName.ToUpper().Contains("UP")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.DiagonalUp; } + else if (cutPatternName.ToUpper().Contains("HORIZONTAL")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.Horizontal; } + else if (cutPatternName.ToUpper().Contains("STEEL")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.Steel; } + else if (cutPatternName.ToUpper().Contains("SOLID")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.Solid; } + else if (cutPatternName.ToUpper().Contains("VERTICAL")) { overrideGraphicsSettings.CutPattern = oM.Revit.Enums.FillPattern.Vertical; } + else { BH.Engine.Base.Compute.RecordWarning($"The Revit Fill Pattern {cutPatternName} is not implemented yet in the BHoM.\n By default, the Fill Pattern {cutPatternName} will be set to SOLID."); } + } else {BH.Engine.Base.Compute.RecordWarning($"The Revit Fill Pattern for the Revit OverrideGraphicSettings {revitOverrides.ToString()} is not defined.");} + + + // Convert SURFACE PATTERNS + + if (revitOverrides.SurfaceBackgroundPatternId.IntegerValue == -1) + { + String surfacePatternName = element.Document.GetElement(revitOverrides.SurfaceBackgroundPatternId).Name; + + if (surfacePatternName.ToUpper().Contains("CROSSHATCH") && !surfacePatternName.ToUpper().Contains("DIAGONAL")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.CrossHatch; } + else if (surfacePatternName.ToUpper().Contains("CROSSHATCH") && surfacePatternName.ToUpper().Contains("DIAGONAL")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.DiagonalCrossHatch; } + else if (surfacePatternName.ToUpper().Contains("DIAGONAL") && surfacePatternName.ToUpper().Contains("DOWN")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.DiagonalDown; } + else if (surfacePatternName.ToUpper().Contains("DIAGONAL") && surfacePatternName.ToUpper().Contains("UP")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.DiagonalUp; } + else if (surfacePatternName.ToUpper().Contains("HORIZONTAL")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.Horizontal; } + else if (surfacePatternName.ToUpper().Contains("STEEL")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.Steel; } + else if (surfacePatternName.ToUpper().Contains("SOLID")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.Solid; } + else if (surfacePatternName.ToUpper().Contains("VERTICAL")) { overrideGraphicsSettings.SurfacePattern = oM.Revit.Enums.FillPattern.Vertical; } + else { BH.Engine.Base.Compute.RecordWarning($"The Revit Fill Pattern {surfacePatternName} is not implemented yet in the BHoM.\n By default, the Fill Pattern {surfacePatternName} will be set to SOLID."); } + + } else { BH.Engine.Base.Compute.RecordWarning($"The Revit Fill Pattern for the Revit OverrideGraphicSettings {revitOverrides.ToString()} is not defined.");} + + return overrideGraphicsSettings; + } + + } +} \ No newline at end of file diff --git a/Revit_Core_Engine/Convert/Revit/FromRevit/ViewFilter.cs b/Revit_Core_Engine/Convert/Revit/FromRevit/ViewFilter.cs new file mode 100644 index 000000000..ef75eaa89 --- /dev/null +++ b/Revit_Core_Engine/Convert/Revit/FromRevit/ViewFilter.cs @@ -0,0 +1,474 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2024, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using Autodesk.Revit.DB; +using BH.Engine.Adapters.Revit; +using BH.oM.Adapters.Revit.Settings; +using BH.oM.Base; +using BH.oM.Base.Attributes; +using BH.oM.Revit.Views; +using BH.oM.Adapters.Revit.Enums; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.CodeDom; +using System; +using Autodesk.Revit.DB.Architecture; +using Autodesk.Revit.Creation; +using BH.oM.Revit.Enums; + +namespace BH.Revit.Engine.Core +{ + public static partial class Convert + { + /***************************************************/ + /**** Public Methods ****/ + /***************************************************/ + + [Description("Converts a Revit ParameterFilterElement to BH.oM.Adapters.Revit.Elements.ViewFilter.")] + [Input("revitViewFilter", "Revit ParameterFilterElement to be converted.")] + [Input("settings", "Revit adapter settings to be used while performing the convert.")] + [Input("refObjects", "Optional, a collection of objects already processed in the current adapter action, stored to avoid processing the same object more than once.")] + [Output("viewFilter", "BH.oM.Adapters.Revit.Elements.ViewFilter resulting from converting the input Revit ParameterFilterElement.")] + public static oM.Adapters.Revit.Elements.ViewFilter ViewFilterFromRevit(this ParameterFilterElement revitViewFilter, RevitSettings settings = null, Dictionary> refObjects = null) + { + settings = settings.DefaultIfNull(); + + oM.Adapters.Revit.Elements.ViewFilter viewFilter = refObjects.GetValue(revitViewFilter.Id.IntegerValue); + if (viewFilter != null) + return viewFilter; + + /* 1. Transfer Filter NAME */ + viewFilter = new oM.Adapters.Revit.Elements.ViewFilter { Name = revitViewFilter.Name }; + + /* 2. Transfer List of CATEGORY NAMES */ + List categories = new List(); + foreach (Autodesk.Revit.DB.Category cat in revitViewFilter.Document.Settings.Categories) { categories.Add(cat); } + + List values = Enum.GetValues(typeof(BH.oM.Revit.Enums.Category)).Cast().ToList(); + + viewFilter.Categories = revitViewFilter.GetCategories().Select(catId => categories.Where(cat => cat.Id == catId).First()) + .Select(cat => Enum.GetValues(typeof(BH.oM.Revit.Enums.Category)) + .Cast() + .ToList() + .Where(enumValue => ((int)enumValue).ToString()==cat.Id.ToString()) + .First()) + .ToList(); + + /* 3. Transfer List of FILTER RULES */ + // If the Filter is assigned with any rules..... + if (revitViewFilter.GetElementFilter()!=null) + { + //Extract the name of all the parameters affected by the rules of the Revit View Filter object (ElementParameterFilter) - via STREAMS + List filterRules = ((ElementLogicalFilter)revitViewFilter.GetElementFilter()).GetFilters() + .Select(filter => ((ElementParameterFilter)filter).GetRules()) + .SelectMany(list => list) + .ToList(); + //Extract the Revit Filter Rule objects defined in the Revit View Filter object (ElementParameterFilter) + List revitFilterRules = (filterRules); + //Convert the Revit Filter Rule objects into corresponding BHoM FilterRule objects and assign them to the BHoM ViewFilter objects + viewFilter.Rules = FilterRulesFromRevit(revitViewFilter, revitFilterRules); + } + + //Set identifiers, parameters & custom data + viewFilter.SetIdentifiers(revitViewFilter); + viewFilter.CopyParameters(revitViewFilter, settings.MappingSettings); + viewFilter.SetProperties(revitViewFilter, settings.MappingSettings); + refObjects.AddOrReplace(revitViewFilter.Id, viewFilter); + return viewFilter; + } + + /***************************************************/ + + //Convert the Revit Filter Rule objects into corresponding BHoM FilterRule objects and store them in a List - via STREAMS + private static List FilterRulesFromRevit(this ParameterFilterElement revitViewFilter, List revitFilterRules) + { + List bhomFilterRules = revitFilterRules.Select(revitRule => FilterRuleFromRevit(revitViewFilter, revitRule as dynamic)) + .Cast< oM.Revit.FilterRules.FilterRule >().ToList(); + return bhomFilterRules; + } + + + + + private static oM.Revit.FilterRules.FilterStringRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, + Autodesk.Revit.DB.FilterStringRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + + // Extract name and value assigned to the parameter of the FilterStringRule obj + string paramName = GetParameterById(revitViewFilter.Document, revitRule.GetRuleParameter()).Definition.Name; + string paramValue = revitRule.RuleString; + // Get the RuleEvaluator of the FilterStringRule (Class defining the way the string value + // assigned to the parameter is compared with the one assigned by the filter) + FilterStringRuleEvaluator stringEvaluator = revitRule.GetEvaluator(); + + // Convert the REVIT FilterStringEvaluator type into the BHOM TextComparisonType Enum + TextComparisonType bhomTextEvaluator = TextComparisonTypeFromRevit(stringEvaluator.GetType().Name); + + + // 2. BUILD the BHOM FILTERRULE object + + oM.Revit.FilterRules.FilterStringRule bhomFilterStringRule; + bhomFilterStringRule = new oM.Revit.FilterRules.FilterStringRule(); + bhomFilterStringRule.ParameterName = paramName; + bhomFilterStringRule.Value = paramValue; + bhomFilterStringRule.ComparisonType = bhomTextEvaluator; + + return bhomFilterStringRule; + } + + + private static oM.Revit.FilterRules.FilterDoubleRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, + Autodesk.Revit.DB.FilterDoubleRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + + // Extract name and value assigned to the parameter of the FilterDoubleRule obj + string paramName = GetParameterById(revitViewFilter.Document,revitRule.GetRuleParameter()).Definition.Name; + ForgeTypeId paramTypeId = GetParameterById(revitViewFilter.Document, revitRule.GetRuleParameter()).GetUnitTypeId(); + string paramValue = UnitUtils.ConvertFromInternalUnits(revitRule.RuleValue,paramTypeId).ToString(); + // Get the RuleEvaluator of the FilterDoubleRule (Class defining the way the string value + // assigned to the parameter is compared with the one assigned by the filter) + FilterNumericRuleEvaluator numericEvaluator = revitRule.GetEvaluator(); + + // Convert the REVIT FilterNumericEvaluator type into the BHOM NumberComparisonType Enum + NumberComparisonType bhomNumericEvaluator = NumberComparisonTypeFromRevit(numericEvaluator.GetType().Name); + + + // 2. BUILD the BHOM FILTERRULE object + + oM.Revit.FilterRules.FilterDoubleRule bhomFilterDoubleRule; + bhomFilterDoubleRule = new BH.oM.Revit.FilterRules.FilterDoubleRule(); + bhomFilterDoubleRule.ParameterName = paramName; + bhomFilterDoubleRule.Value = paramValue; + bhomFilterDoubleRule.ComparisonType = bhomNumericEvaluator; + + return bhomFilterDoubleRule; + } + + + private static oM.Revit.FilterRules.FilterIntegerRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, + Autodesk.Revit.DB.FilterIntegerRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + + // Extract name and value assigned to the parameter of the FilterIntegerRule obj + string paramName = GetParameterById(revitViewFilter.Document, revitRule.GetRuleParameter()).Definition.Name; + ForgeTypeId paramTypeId = GetParameterById(revitViewFilter.Document, revitRule.GetRuleParameter()).GetUnitTypeId(); + string paramValue = UnitUtils.ConvertFromInternalUnits(revitRule.RuleValue, paramTypeId).ToString(); + // Get the RuleEvaluator of the FilterIntegerRule (Class defining the way the string value + // assigned to the parameter is compared with the one assigned by the filter) + FilterNumericRuleEvaluator numericEvaluator = revitRule.GetEvaluator(); + + // Convert the REVIT FilterNumericEvaluator type into the BHOM NumberComparisonType Enum + NumberComparisonType bhomNumericEvaluator=NumberComparisonTypeFromRevit(numericEvaluator.GetType().Name); + + // 2. BUILD the BHOM FILTERRULE object + + oM.Revit.FilterRules.FilterIntegerRule bhomFilterIntegerRule; + bhomFilterIntegerRule = new BH.oM.Revit.FilterRules.FilterIntegerRule(); + bhomFilterIntegerRule.ParameterName = paramName; + bhomFilterIntegerRule.Value = paramValue; + bhomFilterIntegerRule.ComparisonType = bhomNumericEvaluator; + + return bhomFilterIntegerRule; + } + + + private static oM.Revit.FilterRules.FilterElementIdRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, + Autodesk.Revit.DB.FilterElementIdRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + + // Extract name and value assigned to the parameter of the FilterElementIdRule obj + string paramName = GetParameterById(revitViewFilter.Document, revitRule.GetRuleParameter()).Definition.Name; + string paramValue = revitViewFilter.Document.GetElement(revitRule.RuleValue).Name.ToString(); + // Get the RuleEvaluator of the FilterElementIdRule (Class defining the way the string value + // assigned to the parameter is compared with the one assigned by the filter) + FilterNumericRuleEvaluator numericEvaluator = revitRule.GetEvaluator(); + + // Convert the REVIT FilterNumericEvaluator type into the BHOM NumberComparisonType Enum + NumberComparisonType bhomNumericEvaluator = NumberComparisonTypeFromRevit(numericEvaluator.GetType().Name); + + // 2. BUILD the BHOM FILTERRULE object + + oM.Revit.FilterRules.FilterElementIdRule bhomFilterElemIdRule; + bhomFilterElemIdRule = new BH.oM.Revit.FilterRules.FilterElementIdRule(); + bhomFilterElemIdRule.ParameterName = paramName; + bhomFilterElemIdRule.Value = paramValue; + bhomFilterElemIdRule.ComparisonType = bhomNumericEvaluator; + + return bhomFilterElemIdRule; + } + + + private static oM.Revit.FilterRules.FilterCategoryRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, Autodesk.Revit.DB.FilterCategoryRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + + // Extract name and value assigned to the parameter of the FilterElementIdRule obj + List categoryNames = revitRule.GetCategories().Select(elId => revitViewFilter.Document.GetElement(elId).Name).ToList(); + + // 2. BUILD the BHOM FILTERRULE object + + oM.Revit.FilterRules.FilterCategoryRule bhomFilterCategoryRule; + bhomFilterCategoryRule = new BH.oM.Revit.FilterRules.FilterCategoryRule(); + bhomFilterCategoryRule.CategoryNames = categoryNames; + + return bhomFilterCategoryRule; + } + + + private static oM.Revit.FilterRules.ParameterValuePresenceRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, Autodesk.Revit.DB.ParameterValuePresenceRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + oM.Revit.FilterRules.ParameterValuePresenceRule bhomParamValuePresenceRule; + bhomParamValuePresenceRule = new BH.oM.Revit.FilterRules.ParameterValuePresenceRule(); + + // 2. BUILD the BHOM FILTERRULE object + + bhomParamValuePresenceRule.ParameterName = revitViewFilter.Document.GetElement((revitRule).Parameter).Name; + bhomParamValuePresenceRule.IsPresent = (revitRule.GetType() == typeof(HasValueFilterRule)) ? true : false; + + return bhomParamValuePresenceRule; + } + + + private static oM.Revit.FilterRules.FilterRule FilterRuleFromRevit(this ParameterFilterElement revitViewFilter, Autodesk.Revit.DB.FilterInverseRule revitRule) + { + // 1. EXTRACT DATA from the REVIT FILTERRULE object + + // Extract innerRule assigned to the Revit FilterInverseRule obj + Autodesk.Revit.DB.FilterRule innerRule = revitRule.GetInnerRule(); + + // Convert the REVIT InnerRule into the corresponding BHOM FilterRule obj + TextComparisonType bhomTextEvaluator = 0; + NumberComparisonType bhomNumericEvaluator = 0; + + switch (innerRule.GetType().Name) + { + //FilterStringRule + case nameof(Autodesk.Revit.DB.FilterStringRule): + { + bhomTextEvaluator = InverseTextComparisonTypeFromRevit(((Autodesk.Revit.DB.FilterStringRule)innerRule).GetEvaluator().GetType().Name); + oM.Revit.FilterRules.FilterStringRule bhomFilterStringRule = new BH.oM.Revit.FilterRules.FilterStringRule(); + bhomFilterStringRule.ParameterName = GetParameterById(revitViewFilter.Document, innerRule.GetRuleParameter()).Definition.Name; + bhomFilterStringRule.Value = ((Autodesk.Revit.DB.FilterStringRule)innerRule).RuleString; + bhomFilterStringRule.ComparisonType = bhomTextEvaluator; + return (oM.Revit.FilterRules.FilterRule)bhomFilterStringRule; + } + // FilterDoubleRule + case nameof(Autodesk.Revit.DB.FilterDoubleRule): + { + bhomNumericEvaluator = InverseNumberComparisonTypeFromRevit(((Autodesk.Revit.DB.FilterNumericValueRule)innerRule).GetEvaluator().GetType().Name); + oM.Revit.FilterRules.FilterDoubleRule bhomFilterDoubleRule = new BH.oM.Revit.FilterRules.FilterDoubleRule(); + bhomFilterDoubleRule.ParameterName = GetParameterById(revitViewFilter.Document, innerRule.GetRuleParameter()).Definition.Name; + bhomFilterDoubleRule.Value = ((Autodesk.Revit.DB.FilterDoubleRule)innerRule).RuleValue.ToString(); + bhomFilterDoubleRule.ComparisonType = bhomNumericEvaluator; + return (oM.Revit.FilterRules.FilterRule)bhomFilterDoubleRule; + } + // FilterIntegerRule + case nameof(Autodesk.Revit.DB.FilterIntegerRule): + { + bhomNumericEvaluator = InverseNumberComparisonTypeFromRevit(((Autodesk.Revit.DB.FilterNumericValueRule)innerRule).GetEvaluator().GetType().Name); + oM.Revit.FilterRules.FilterIntegerRule bhomFilterIntegerRule = new BH.oM.Revit.FilterRules.FilterIntegerRule(); + bhomFilterIntegerRule.ParameterName = GetParameterById(revitViewFilter.Document, innerRule.GetRuleParameter()).Definition.Name; + bhomFilterIntegerRule.Value = ((Autodesk.Revit.DB.FilterIntegerRule)innerRule).RuleValue.ToString(); + bhomFilterIntegerRule.ComparisonType = bhomNumericEvaluator; + return (oM.Revit.FilterRules.FilterRule)bhomFilterIntegerRule; + } + // FilterElementIdRule + case nameof(Autodesk.Revit.DB.FilterElementIdRule): + { + + oM.Revit.FilterRules.FilterElementIdRule bhomFilterElementIdRule = new BH.oM.Revit.FilterRules.FilterElementIdRule(); + bhomFilterElementIdRule.ParameterName = GetParameterById(revitViewFilter.Document, innerRule.GetRuleParameter()).Definition.Name; + bhomFilterElementIdRule.Value = ((Autodesk.Revit.DB.FilterElementIdRule)innerRule).RuleValue.ToString(); + bhomFilterElementIdRule.ComparisonType = bhomNumericEvaluator; + return (oM.Revit.FilterRules.FilterRule)bhomFilterElementIdRule; + } + default: + { return null; } + + } + } + + + /* UTILITY METHODS */ + + private static Parameter GetParameterById(Autodesk.Revit.DB.Document doc, ElementId parameterId) + { + // Get all elements in the document + FilteredElementCollector collector = new FilteredElementCollector(doc); + collector.WhereElementIsNotElementType(); + + // Iterate through all elements + foreach (Element element in collector) + { + // Get the parameter by its own Id + List matchingParams=element.Parameters().Where(prm => prm.Id == parameterId).ToList(); + + if (matchingParams.Count!=0) + {return matchingParams.First();} + + } + + // If the parameter is not found, return InvalidElementId + return null; + } + + + private static NumberComparisonType NumberComparisonTypeFromRevit(string innerRuleName) + { + NumberComparisonType? output = null; + + switch (innerRuleName) + { + case (nameof(Autodesk.Revit.DB.FilterNumericEquals)): + return NumberComparisonType.Equal; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericGreater)): + return NumberComparisonType.Greater; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericGreaterOrEqual)): + return NumberComparisonType.GreaterOrEqual; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericLess)): + return NumberComparisonType.Less; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericLessOrEqual)): + return NumberComparisonType.LessOrEqual; + break; + default: + break; + } + + return (NumberComparisonType)output; + + } + + + private static NumberComparisonType InverseNumberComparisonTypeFromRevit(string innerRuleName) + { + NumberComparisonType? output = null; + + switch (innerRuleName) + { + case (nameof(Autodesk.Revit.DB.FilterNumericEquals)): + return NumberComparisonType.NotEqual; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericGreater)): + return NumberComparisonType.Less; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericGreaterOrEqual)): + return NumberComparisonType.NotEqual; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericLess)): + return NumberComparisonType.Greater; + break; + case (nameof(Autodesk.Revit.DB.FilterNumericLessOrEqual)): + return NumberComparisonType.GreaterOrEqual; + break; + default: + break; + } + + return (NumberComparisonType)output; + + } + + + + private static TextComparisonType TextComparisonTypeFromRevit(string innerRuleName) + { + TextComparisonType? output = null; + + switch (innerRuleName) + { + case (nameof(Autodesk.Revit.DB.FilterStringEquals)): + return TextComparisonType.Equal; + break; + case (nameof(Autodesk.Revit.DB.FilterStringBeginsWith)): + return TextComparisonType.StartsWith; + break; + case (nameof(Autodesk.Revit.DB.FilterStringEndsWith)): + return TextComparisonType.EndsWith; + break; + case (nameof(Autodesk.Revit.DB.FilterStringContains)): + return TextComparisonType.Contains; + break; + case nameof(Autodesk.Revit.DB.FilterStringGreater): + return TextComparisonType.Greater; + break; + case nameof(Autodesk.Revit.DB.FilterStringGreaterOrEqual): + return TextComparisonType.GreaterOrEqual; + break; + case nameof(Autodesk.Revit.DB.FilterStringLess): + return TextComparisonType.Less; + break; + case nameof(Autodesk.Revit.DB.FilterStringLessOrEqual): + return TextComparisonType.LessOrEqual; + break; + default: + break; + } + + return (TextComparisonType)output; + + } + + + private static TextComparisonType InverseTextComparisonTypeFromRevit(string innerRuleName) + { + TextComparisonType? output = null; + + switch (innerRuleName) + { + case (nameof(Autodesk.Revit.DB.FilterStringEquals)): + return TextComparisonType.NotEqual; + break; + case (nameof(Autodesk.Revit.DB.FilterStringBeginsWith)): + return TextComparisonType.NotStartsWith; + break; + case (nameof(Autodesk.Revit.DB.FilterStringEndsWith)): + return TextComparisonType.NotEndsWith; + break; + case (nameof(Autodesk.Revit.DB.FilterStringContains)): + return TextComparisonType.ContainsNot; + break; + default: + break; + } + + return (TextComparisonType)output; + + } + + + } +} + + + + + diff --git a/Revit_Core_Engine/Convert/Revit/ToRevit/CurveElement.cs b/Revit_Core_Engine/Convert/Revit/ToRevit/CurveElement.cs index 11b0c63b8..8a36b24ab 100644 --- a/Revit_Core_Engine/Convert/Revit/ToRevit/CurveElement.cs +++ b/Revit_Core_Engine/Convert/Revit/ToRevit/CurveElement.cs @@ -128,7 +128,7 @@ public static CurveElement ToCurveElement(this DraftingInstance draftingInstance if (!BH.Engine.Geometry.Query.IsPlanar(curve as dynamic)) return null; - View view = Query.View(draftingInstance, document); + Autodesk.Revit.DB.View view = Query.View(draftingInstance, document); if (view == null) return null; diff --git a/Revit_Core_Engine/Convert/Revit/ToRevit/Element.cs b/Revit_Core_Engine/Convert/Revit/ToRevit/Element.cs index 7b5a7db83..27b467068 100644 --- a/Revit_Core_Engine/Convert/Revit/ToRevit/Element.cs +++ b/Revit_Core_Engine/Convert/Revit/ToRevit/Element.cs @@ -119,7 +119,7 @@ public static Element ToRevitElement(this DraftingInstance draftingInstance, Doc settings = settings.DefaultIfNull(); - View view = draftingInstance.View(document); + Autodesk.Revit.DB.View view = draftingInstance.View(document); if (view == null) return null; @@ -256,7 +256,7 @@ private static Element ToRevitElement(this ModelInstance modelInstance, FamilySy /**** Private Methods - Drafting Instances ****/ /***************************************************/ - private static Element IToRevitElement(this DraftingInstance draftingInstance, ElementType elementType, View view, RevitSettings settings) + private static Element IToRevitElement(this DraftingInstance draftingInstance, ElementType elementType, Autodesk.Revit.DB.View view, RevitSettings settings) { if (elementType == null) { @@ -269,7 +269,7 @@ private static Element IToRevitElement(this DraftingInstance draftingInstance, E /***************************************************/ - private static Element ToRevitElement(this DraftingInstance draftingInstance, FilledRegionType regionType, View view, RevitSettings settings) + private static Element ToRevitElement(this DraftingInstance draftingInstance, FilledRegionType regionType, Autodesk.Revit.DB.View view, RevitSettings settings) { ISurface location = draftingInstance.Location as ISurface; @@ -310,7 +310,7 @@ private static Element ToRevitElement(this DraftingInstance draftingInstance, Fi /***************************************************/ - private static Element ToRevitElement(this DraftingInstance draftingInstance, FamilySymbol familySymbol, View view, RevitSettings settings) + private static Element ToRevitElement(this DraftingInstance draftingInstance, FamilySymbol familySymbol, Autodesk.Revit.DB.View view, RevitSettings settings) { if (draftingInstance?.Location == null) return null; @@ -328,7 +328,7 @@ private static Element ToRevitElement(this DraftingInstance draftingInstance, Fa /**** Fallback Methods ****/ /***************************************************/ - private static Element ToRevitElement(this DraftingInstance draftingInstance, ElementType elementType, View view, RevitSettings settings) + private static Element ToRevitElement(this DraftingInstance draftingInstance, ElementType elementType, Autodesk.Revit.DB.View view, RevitSettings settings) { return null; } diff --git a/Revit_Core_Engine/Convert/Revit/ToRevit/ParameterFilterElement.cs b/Revit_Core_Engine/Convert/Revit/ToRevit/ParameterFilterElement.cs new file mode 100644 index 000000000..572442b31 --- /dev/null +++ b/Revit_Core_Engine/Convert/Revit/ToRevit/ParameterFilterElement.cs @@ -0,0 +1,580 @@ +/* + * This file is part of the Buildings and Habitats object Model (BHoM) + * Copyright (c) 2015 - 2024, the respective contributors. All rights reserved. + * + * Each contributor holds copyright over their respective contributions. + * The project versioning (Git) records all such contribution source information. + * + * + * The BHoM is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3.0 of the License, or + * (at your option) any later version. + * + * The BHoM is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this code. If not, see . + */ + +using Autodesk.Revit.Creation; +using Autodesk.Revit.DB; +using BH.Engine.Base; +using BH.Engine.Data; +using BH.oM.Adapters.Revit.Enums; +using BH.oM.Adapters.Revit.Settings; +using BH.oM.Base; +using BH.oM.Base.Attributes; +using BH.oM.MEP.Equipment.Parts; +using BH.oM.Physical.Elements; +using BH.oM.Revit.Enums; +using BH.oM.Revit.FilterRules; +using System; +using System.CodeDom; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Runtime.CompilerServices; +using Document = Autodesk.Revit.DB.Document; +using FilterRule = BH.oM.Revit.FilterRules.FilterRule; +using FilterStringRule = BH.oM.Revit.FilterRules.FilterStringRule; + +namespace BH.Revit.Engine.Core +{ + public static partial class Convert + { + /***************************************************/ + /**** Public Methods ****/ + /***************************************************/ + + [Description("Converts BH.oM.Adapters.Revit.Elements.ViewFilter to a Revit ParameterFilterElement." + + "\nThe Filter Rules are assigned after its creation due to Revit API limitations.")] + [Input("filter", "BH.oM.Adapters.Revit.Elements.ViewFilter to be converted.")] + [Input("document", "Revit document, in which the output of the convert will be created.")] + [Input("settings", "Revit adapter settings to be used while performing the convert.")] + [Input("refObjects", "Optional, a collection of objects already processed in the current adapter action, stored to avoid processing the same object more than once.")] + [Output("filter", "Revit ParameterFilterElement resulting from converting the input BH.oM.Adapters.Revit.Elements.ViewFilter.")] + public static ParameterFilterElement ToRevitParameterFilterElement(this oM.Adapters.Revit.Elements.ViewFilter filter, Document document, RevitSettings settings = null, Dictionary> refObjects = null) + { + ParameterFilterElement revitFilter = refObjects.GetValue(document, filter.BHoM_Guid); + if (revitFilter != null) + return revitFilter; + + // 1. CREATE PARAMETERFILTERELEMENT with ASSIGNED CATEGORIES LIST + + /* 1.1 Turn list of Category Names into List of Category ElementIds via use of Streams */ + + List categoryIdsList = filter.Categories + // Format the string name of the categories + .Select(catObj => catObj.ToString().ToUpper().Replace(" ", "")) + // Get the corresponding BuiltInCategories + .Select(catName => { List builtInCatNames = Enum.GetNames(typeof(BuiltInCategory)) + .Select(builtInCategoryName => builtInCategoryName.ToUpper().Replace(" ", "")) + .ToList(); + return (BuiltInCategory)(((BuiltInCategory[])Enum.GetValues(typeof(BuiltInCategory)))[builtInCatNames.IndexOf(catName)]); }) + // Get the ElementIds of the BuiltInCategories + .Select(builtInCat => new ElementId(builtInCat)) + // Turn the Stream into a List of ElementIds + .ToList(); + + /* 1.2 Create the ParameterFilterElement in the current Revit Document */ + revitFilter = ParameterFilterElement.Create(document, filter.Name, categoryIdsList); + + + // 2. BUILD THE REVIT FILTER RULES and ASSIGN THEM TO THE PARAMETERFILTERELEMENT + + /* Via use of Streams*/ + if (filter.Rules.Count != 0) + { + ElementFilter elFilter = new LogicalAndFilter(filter.Rules + .GroupBy(rule => rule.GetType()) + .ToDictionary(grp => grp.Key, grp => grp.ToList()) + .ToList() + .Select(kvp => + { + + List filterRules = new List(); + + if (kvp.Key.Name == "FilterCategoryRule") + { + filterRules = kvp.Value.Cast() + .Select(filterCategoryRule => filterCategoryRuleToRevit(document, filterCategoryRule)) + .ToList(); + } + else if (kvp.Key.Name == "FilterLevelRule") + { + filterRules = kvp.Value.Cast() + .Select(filterLevelRule => filterLevelRuleToRevit(document, filterLevelRule)) + .ToList(); + } + else if (kvp.Key.Name == "FilterMaterialRule") + { + filterRules = kvp.Value.Cast() + .Select(filterMaterialRule => filterMaterialRuleToRevit(document, filterMaterialRule)) + .ToList(); + } + else if (kvp.Key.Name == "FilterStringRule" || kvp.Key.Name == "FilterDoubleRule" || + kvp.Key.Name == "FilterIntegerRule" || kvp.Key.Name == "FilterElementIdRule") + { + filterRules = kvp.Value.Cast() + .Select(filterValueRule => filterValueRuleToRevit(document, filterValueRule)) + .ToList(); + } + return filterRules; + }) + .Select(filterRulesList => new ElementParameterFilter(filterRulesList)) + .Cast() + .ToList()); + + revitFilter.SetElementFilter(elFilter); + } + + revitFilter.CopyParameters(filter, settings); + refObjects.AddOrReplace(filter, revitFilter); + return revitFilter; + } + + + /***************************************************/ + + + public static Autodesk.Revit.DB.FilterRule filterRuleToRevit(Document document, oM.Revit.FilterRules.FilterRule filterRule) + { + + /* 1. CONVERT BHOM FILTERRULE INTO REVIT FILTERRULE */ + + // FilterCategoryRule + if (filterRule.GetType() == typeof(oM.Revit.FilterRules.FilterCategoryRule)) + { return filterCategoryRuleToRevit(document, (oM.Revit.FilterRules.FilterCategoryRule)filterRule); } + // FilterMaterialRule + else if (filterRule.GetType() == typeof(oM.Revit.FilterRules.FilterMaterialRule)) + { return filterMaterialRuleToRevit(document, (oM.Revit.FilterRules.FilterMaterialRule)filterRule); } + // FilterLevelRule + else if (filterRule.GetType() == typeof(oM.Revit.FilterRules.FilterLevelRule)) + { return filterLevelRuleToRevit(document, (oM.Revit.FilterRules.FilterLevelRule)filterRule); } + // FilterValueRule + else if (filterRule.GetType().IsSubclassOf(typeof(oM.Revit.FilterRules.FilterValueRule))) + { return filterValueRuleToRevit(document, (oM.Revit.FilterRules.FilterValueRule)filterRule); } + + return null; + + } + + + private static Autodesk.Revit.DB.FilterRule filterCategoryRuleToRevit(Document document, oM.Revit.FilterRules.FilterCategoryRule filterCategoryRule) + { + /* 1. INITIALIZE FILTERRULE */ + Autodesk.Revit.DB.FilterRule revitFilterRule = null; + + /* 2. EXTRACT CATEGORIES */ + List categories = new List(); + foreach (Autodesk.Revit.DB.Category cat in document.Settings.Categories) { categories.Add(cat); } + + /* 2. GET THE ELEMENT IDS OF THE CATEGORIES STORED IN THE FILTERCATEGORYRULE */ + List categoryIds = categories + // Retain only the Categories having name appearing in the filter's list (INTERMEDIATE OPERATION) + .Where(elem => filterCategoryRule.CategoryNames.Contains(elem.Name)) + // Cast down to Category Class Instances (INTERMEDIATE OPERATION) + .Cast() + // Get the ids of the retain categories (INTERMEDIATE OPERATION) + .Select(cat => cat.Id) + // Turn the Stream into a List (TERMINAL OPERATION) + .ToList(); + + /* 3. CREATE THE FILTER RULE */ + revitFilterRule = new Autodesk.Revit.DB.FilterCategoryRule(categoryIds); + + return revitFilterRule; + } + + /***************************************************/ + + private static Autodesk.Revit.DB.FilterRule filterMaterialRuleToRevit(Document document, FilterMaterialRule filterMaterialRule) + { + /* 1. INITIALIZE FILTERRULE AND BUILTINPARAMETER INSTANCES */ + Autodesk.Revit.DB.FilterRule revitFilterRule = null; + BuiltInParameter parameter = BuiltInParameter.STRUCTURAL_MATERIAL_PARAM; + + /* 2. CREATE THE FILTER RULE */ + + //ParameterValueProvider provider = new ParameterValueProvider(new ElementId(parameter)); + //revitFilterRule = ParameterFilterRuleFactory.CreateEqualsRule(new ElementId(parameter), filterMaterialRule.MaterialName, true); + + FilteredElementCollector collector = new FilteredElementCollector(document); + Element mat = collector.OfClass(typeof(Material)).Where(material => material.Name == filterMaterialRule.MaterialName).First(); + revitFilterRule = ParameterFilterRuleFactory.CreateEqualsRule(new ElementId(parameter), mat.Id); + + return revitFilterRule; + } + + /***************************************************/ + + private static Autodesk.Revit.DB.FilterRule filterLevelRuleToRevit(Document document, FilterLevelRule filterLevelRule) + { + /* 1. INITIALIZE FILTERRULE AND BUILTINPARAMETER INSTANCES */ + Autodesk.Revit.DB.FilterRule revitFilterRule = null; + BuiltInParameter levParam = BuiltInParameter.SCHEDULE_LEVEL_PARAM; + ElementId levParamId = new ElementId(levParam); + ElementId levelId; + + /* 2. GET ELEVATION OF LEVEL CORRESPONDING TO INPUT LEVEL NAME */ + // Via Streams and withing a Try-Catch statement to make sure the code is compact and if the level is not found, we prevent any error + // being thrown when executing .First() while returning null instead. + try + { + levelId = new FilteredElementCollector(document) + .OfCategory(BuiltInCategory.OST_Levels) + .WhereElementIsNotElementType() + .Where(level => level.Name.ToUpper() == filterLevelRule.LevelName.ToUpper()) + .Cast() + .Select(level => level.Id) + .First(); + } + catch (Exception ex) + { + return null; + } + + + + /* 3. CREATE FILTERS RULE */ + + // Based on level's elevation and LevelComparisonType... + switch (filterLevelRule.ComparisonType) + { + case LevelComparisonType.Equal: + revitFilterRule = ParameterFilterRuleFactory + .CreateEqualsRule(levParamId, levelId); + break; + case LevelComparisonType.NotEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotEqualsRule(levParamId, levelId); + break; + case LevelComparisonType.Above: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterRule(levParamId, levelId); + break; + case LevelComparisonType.AtOrAbove: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterOrEqualRule(levParamId, levelId); + break; + case LevelComparisonType.Below: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessRule(levParamId, levelId); + break; + case LevelComparisonType.AtOrBelow: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessOrEqualRule(levParamId, levelId); + break; + default: + break; + } + + return revitFilterRule; + } + + + /***************************************************/ + + private static Autodesk.Revit.DB.FilterRule filterValueRuleToRevit(Document document, oM.Revit.FilterRules.FilterValueRule filterValueRule) { + + /* 1. INITIALIZE FILTERRULE AND LOGICALFILTER CLASS INSTANCES */ + Autodesk.Revit.DB.FilterRule revitFilterRule = null; + + /* 2. GET the PARAMETER OBJECT and the ELEMENT ID of the PARAMETER OBJECT */ + ElementId parameterId = GetParameterIdByName(document, filterValueRule.ParameterName); + Parameter parameter = GetParameterByName(document, filterValueRule.ParameterName); + + /* 3. CREATE FILTER-RULE */ + + // Based on FilterStringRule... + if (filterValueRule.GetType() == typeof(FilterStringRule) || + filterValueRule.GetType().IsSubclassOf(typeof(FilterStringRule))) + { + FilterStringRule filterStringValueRule = (FilterStringRule)filterValueRule; + + switch (filterStringValueRule.ComparisonType) + { + case TextComparisonType.Equal: + revitFilterRule = ParameterFilterRuleFactory + .CreateEqualsRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.NotEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotEqualsRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.Contains: + revitFilterRule = ParameterFilterRuleFactory + .CreateContainsRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.ContainsNot: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotContainsRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.StartsWith: + revitFilterRule = ParameterFilterRuleFactory + .CreateBeginsWithRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.NotStartsWith: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotBeginsWithRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.EndsWith: + revitFilterRule = ParameterFilterRuleFactory + .CreateEndsWithRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.NotEndsWith: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotEndsWithRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.Greater: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.GreaterOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterOrEqualRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.Less: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessRule(parameterId, (string)filterStringValueRule.Value, false); + break; + case TextComparisonType.LessOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessOrEqualRule(parameterId, (string)filterStringValueRule.Value, false); + break; + default: + break; + } + + // Based on FilterNumericValueRule... + } else if (filterValueRule.GetType() == typeof(oM.Revit.FilterRules.FilterNumericValueRule) || + filterValueRule.GetType().IsSubclassOf(typeof(oM.Revit.FilterRules.FilterNumericValueRule))) + { + + if ((filterValueRule.GetType() == typeof(oM.Revit.FilterRules.FilterDoubleRule))) + { + /* 1. Downcast to subclass */ + oM.Revit.FilterRules.FilterDoubleRule filterDoubleRule = (oM.Revit.FilterRules.FilterDoubleRule)filterValueRule; + + /* 2. Convert input value to target data type */ + Double doubleValue = 0.0; + Boolean boolParam = Double.TryParse(filterDoubleRule.Value, out doubleValue); + + if (!boolParam) + { + BH.Engine.Base.Compute.RecordError("The Input Value of the FilterDoubleRule is not a Double Type value."); + } + + /* 3. Convert units of input value to internal units */ + double convertedValue = UnitUtils.ConvertToInternalUnits(doubleValue, parameter.GetUnitTypeId()); + + /* 4. Convert Evaluator from Revit to BHoM */ + switch (filterDoubleRule.ComparisonType) + { + case NumberComparisonType.Equal: + revitFilterRule = ParameterFilterRuleFactory + .CreateEqualsRule(parameterId, convertedValue, 0.01); + break; + case NumberComparisonType.NotEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotEqualsRule(parameterId, convertedValue, 0.01); + break; + case NumberComparisonType.Greater: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterRule(parameterId, convertedValue, 0.01); + break; + case NumberComparisonType.GreaterOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterOrEqualRule(parameterId, convertedValue, 0.01); + break; + case NumberComparisonType.Less: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessRule(parameterId, convertedValue, 0.01); + break; + case NumberComparisonType.LessOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessOrEqualRule(parameterId, convertedValue, 0.01); + break; + default: + break; + } + } + else if (filterValueRule.GetType() == typeof(oM.Revit.FilterRules.FilterIntegerRule)) + { + /* 1. Downcast to subclass */ + oM.Revit.FilterRules.FilterIntegerRule filterIntegerRule = (oM.Revit.FilterRules.FilterIntegerRule)filterValueRule; + + /* 2. Convert input value to target data type */ + int intValue = 0; + Boolean boolParam = int.TryParse(filterIntegerRule.Value, out intValue); + + if (!boolParam) + { + BH.Engine.Base.Compute.RecordError("The Input Value of the FilterIntegerRule is not an Integer Type value."); + } + + /* 3. Convert units of input value to internal units */ + int convertedValue = (int)UnitUtils.ConvertToInternalUnits((Double)intValue, parameter.GetUnitTypeId()); + + /* 4. Convert Evaluator from Revit to BHoM */ + switch (filterIntegerRule.ComparisonType) + { + case NumberComparisonType.Equal: + revitFilterRule = ParameterFilterRuleFactory + .CreateEqualsRule(parameterId, convertedValue); + break; + case NumberComparisonType.NotEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotEqualsRule(parameterId, convertedValue); + break; + case NumberComparisonType.Greater: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterRule(parameterId, convertedValue); + break; + case NumberComparisonType.GreaterOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterOrEqualRule(parameterId, convertedValue); + break; + case NumberComparisonType.Less: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessRule(parameterId, convertedValue); + break; + case NumberComparisonType.LessOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessOrEqualRule(parameterId, convertedValue); + break; + default: + break; + } + } + else if (filterValueRule.GetType() == typeof(oM.Revit.FilterRules.FilterElementIdRule)) + { + /* 1. Downcast to subclass */ + oM.Revit.FilterRules.FilterElementIdRule filterElementIdRule = (oM.Revit.FilterRules.FilterElementIdRule)filterValueRule; + + /* 2. Convert input value to target data type */ + Boolean boolParam = int.TryParse(filterElementIdRule.Value, out int intValue); + ElementId elId = new ElementId(intValue); + + if (!boolParam) + { + BH.Engine.Base.Compute.RecordError("The Input Value of the FilterIntegerRule is not an Integer Type value."); + } + + /* 3. Convert Evaluator from Revit to BHoM */ + switch (filterElementIdRule.ComparisonType) + { + case NumberComparisonType.Equal: + revitFilterRule = ParameterFilterRuleFactory + .CreateEqualsRule(parameterId, elId); + break; + case NumberComparisonType.NotEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateNotEqualsRule(parameterId, elId); + break; + case NumberComparisonType.Greater: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterRule(parameterId, elId); + break; + case NumberComparisonType.GreaterOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateGreaterOrEqualRule(parameterId, elId); + break; + case NumberComparisonType.Less: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessRule(parameterId, elId); + break; + case NumberComparisonType.LessOrEqual: + revitFilterRule = ParameterFilterRuleFactory + .CreateLessOrEqualRule(parameterId, elId); + break; + default: + break; + } + } + + } else { return null; } + + return revitFilterRule; + } + + + + + /***************************************************/ + + private static Autodesk.Revit.DB.FilterRule parameterValuePresenceRuleToRevit(Document document, oM.Revit.FilterRules.ParameterValuePresenceRule paramValuePresenceRule) + { + /* 1. INITIALIZE FILTERRULE AND LOGICALFILTER CLASS INSTANCES */ + Autodesk.Revit.DB.FilterRule revitFilterRule = null; + + /* 2. GET the PARAMETER OBJECT and the ELEMENT ID of the PARAMETER OBJECT */ + ElementId parameterId = GetParameterIdByName(document, paramValuePresenceRule.ParameterName); + Parameter parameter = GetParameterByName(document, paramValuePresenceRule.ParameterName); + + if (paramValuePresenceRule.IsPresent) + { + revitFilterRule = ParameterFilterRuleFactory.CreateHasValueParameterRule(parameterId); + } + else + { + revitFilterRule = ParameterFilterRuleFactory.CreateHasNoValueParameterRule(parameterId); + } + + return revitFilterRule; + + } + + private static ElementId GetParameterIdByName(Document doc, string parameterName) + { + // Get all elements in the document + FilteredElementCollector collector = new FilteredElementCollector(doc); + collector.WhereElementIsNotElementType(); + + // Iterate through all elements + foreach (Element element in collector) + { + // Get the parameter by name + Parameter param = element.LookupParameter(parameterName); + if (param != null) + { + // Return the ElementId of the parameter + return param.Id; + } + } + + // If the parameter is not found, return InvalidElementId + return ElementId.InvalidElementId; + } + + + private static Parameter GetParameterByName(Document doc, string parameterName) + { + // Get all elements in the document + FilteredElementCollector collector = new FilteredElementCollector(doc); + collector.WhereElementIsNotElementType(); + + // Iterate through all elements + foreach (Element element in collector) + { + // Get the parameter by name + Parameter param = element.LookupParameter(parameterName); + if (param != null) + { + // Return the ElementId of the parameter + return param; + } + } + + // If the parameter is not found, return InvalidElementId + return null; + } + + } + +} + diff --git a/Revit_Core_Engine/Convert/ToRevit.cs b/Revit_Core_Engine/Convert/ToRevit.cs index dca092351..e97f6164d 100644 --- a/Revit_Core_Engine/Convert/ToRevit.cs +++ b/Revit_Core_Engine/Convert/ToRevit.cs @@ -40,6 +40,19 @@ public static partial class Convert /**** Public methods ****/ /***************************************************/ + [Description("Converts BH.oM.Adapters.Revit.Elements.ViewFilter to a Revit ParameterFilterElement.")] + [Input("filter", "BH.oM.Adapters.Revit.Elements.ViewFilter to be converted.")] + [Input("document", "Revit document, in which the output of the convert will be created.")] + [Input("settings", "Revit adapter settings to be used while performing the convert.")] + [Input("refObjects", "Optional, a collection of objects already processed in the current adapter action, stored to avoid processing the same object more than once.")] + [Output("parameterFilterElement", "Revit ParameterFilterElement resulting from converting the input BH.oM.Adapters.Revit.Elements.ViewFilter.")] + public static Element ToRevit(this BH.oM.Adapters.Revit.Elements.ViewFilter filter, Document document, RevitSettings settings = null, Dictionary> refObjects = null) + { + return filter.ToRevitParameterFilterElement(document, settings, refObjects); + } + + /***************************************************/ + [Description("Converts BH.oM.Spatial.SettingOut.Grid to a Revit Grid or MultiSegmentGrid.")] [Input("grid", "BH.oM.Spatial.SettingOut.Grid to be converted.")] [Input("document", "Revit document, in which the output of the convert will be created.")] diff --git a/Revit_Core_Engine/Modify/SetLocation.cs b/Revit_Core_Engine/Modify/SetLocation.cs index 5684d07a4..b8e628eaa 100644 --- a/Revit_Core_Engine/Modify/SetLocation.cs +++ b/Revit_Core_Engine/Modify/SetLocation.cs @@ -546,7 +546,7 @@ private static bool SetLocation(this FamilyInstance element, BH.oM.Geometry.Poin typeof(Autodesk.Revit.DB.Family), typeof(ElementType), typeof(Material), - typeof(View) + typeof(Autodesk.Revit.DB.View) }; /***************************************************/ diff --git a/Revit_Core_Engine/Modify/Update.cs b/Revit_Core_Engine/Modify/Update.cs index 22ce82abf..8d46440b7 100644 --- a/Revit_Core_Engine/Modify/Update.cs +++ b/Revit_Core_Engine/Modify/Update.cs @@ -20,16 +20,22 @@ * along with this code. If not, see . */ +using Autodesk.Revit.Creation; using Autodesk.Revit.DB; using BH.Engine.Adapters.Revit; using BH.oM.Adapters.Revit.Elements; using BH.oM.Adapters.Revit.Settings; using BH.oM.Base; using BH.oM.Base.Attributes; +using BH.oM.MEP.Equipment.Parts; using System; using System.Collections.Generic; using System.ComponentModel; +using System.Drawing; using System.Linq; +using Color = Autodesk.Revit.DB.Color; +using OverrideGraphicSettings = Autodesk.Revit.DB.OverrideGraphicSettings; +using View = Autodesk.Revit.DB.View; namespace BH.Revit.Engine.Core { @@ -243,6 +249,91 @@ public static bool Update(this AssemblyInstance element, Assembly bHoMObject, Re return true; } + /***************************************************/ + + [Description("Updates the existing Revit View based on the given BHoM View.")] + [Input("element", "Revit View instance to be updated.")] + [Input("bHoMObject", "BHoM View, based on which the Revit View will be updated.")] + [Input("settings", "Revit adapter settings to be used while performing the action.")] + [Input("setLocationOnUpdate", "Revit View instance does not have location property, therefore this parameter is irrelevant.")] + [Output("success", "True if the Revit View instance has been updated successfully based on the input BHoM View.")] + public static bool Update (this View element, BH.oM.Adapters.Revit.Elements.View bHoMObject, RevitSettings settings, bool setLocationOnUpdate) + { + /* ADD FILTERS WITH OVERRIDES TO REVIT VIEW */ + + // Via Streams... + bHoMObject.FiltersWithOverrides + // 1. Turn Filters and Overrides into Keys and Values of a Dictionary + .ToDictionary(x => x.Filter, x => x.Overrides) + // 2. Turn the Dictionary into a List of KeyValue Pairs (to allow use of ForEach() + .ToList>() + // 3. Assign Filters to View and Set their Overrides + .ForEach(kvp => { ParameterFilterElement pfe = kvp.Key.ToRevitParameterFilterElement(element.Document, settings); + // 3.1 Add ViewFilter to the View + element.AddFilter(pfe.Id); + // 3.2 Get the Revit FillPatternElement Objects for CutPattern and SurfacePattern + FillPatternElement revitCutPattern = new FilteredElementCollector(element.Document) + .OfClass(typeof(FillPatternElement)) + .Cast() + .FirstOrDefault(pattern => pattern.Name.Replace(" ", "").ToUpper().Contains(kvp.Value.CutPattern.ToString().Replace(" ","").ToUpper())); + FillPatternElement revitSurfacePattern = new FilteredElementCollector(element.Document) + .OfClass(typeof(FillPatternElement)) + .Cast() + .FirstOrDefault(pattern => pattern.Name.Replace(" ", "").ToUpper().Contains(kvp.Value.SurfacePattern.ToString().Replace(" ", "").ToUpper())); + // 3.3 Create the OverrideGraphics by Properties + OverrideGraphicSettings overrideGraphicsSettings = new OverrideGraphicSettings(); + Color revitLineColor = new Color(kvp.Value.LineColor.R, kvp.Value.LineColor.G, kvp.Value.LineColor.B); + Color revitCutColor = new Color(kvp.Value.CutColor.R, kvp.Value.CutColor.G, kvp.Value.CutColor.B); + Color revitSurfaceColor = new Color(kvp.Value.SurfaceColor.R, kvp.Value.SurfaceColor.G, kvp.Value.SurfaceColor.B); + overrideGraphicsSettings.SetCutLineColor(revitLineColor); + overrideGraphicsSettings.SetProjectionLineColor(revitLineColor); + overrideGraphicsSettings.SetCutBackgroundPatternId(revitCutPattern.Id); + overrideGraphicsSettings.SetCutBackgroundPatternColor(revitCutColor); + overrideGraphicsSettings.SetCutForegroundPatternId(revitCutPattern.Id); + overrideGraphicsSettings.SetCutForegroundPatternColor(revitCutColor); + overrideGraphicsSettings.SetSurfaceBackgroundPatternId(revitSurfacePattern.Id); + overrideGraphicsSettings.SetSurfaceBackgroundPatternColor(revitSurfaceColor); + overrideGraphicsSettings.SetSurfaceForegroundPatternId(revitSurfacePattern.Id); + overrideGraphicsSettings.SetSurfaceForegroundPatternColor(revitSurfaceColor); + // 3.4 Assign Overrides to the ViewFilter + element.SetFilterOverrides(pfe.Id, overrideGraphicsSettings); }); + + element.CopyParameters(bHoMObject, settings); + return true; + } + + /***************************************************/ + + [Description("Updates the existing Revit ParameterFilterElement based on the given BHoM ViewFilter.")] + [Input("element", "Revit ParameterFilterElement to be updated.")] + [Input("bHoMObject", "BHoM ViewFilter, based on which the Revit element will be updated.")] + [Input("settings", "Revit adapter settings to be used while performing the action.")] + [Input("setLocationOnUpdate", "Revit ParameterFilterElement instance does not have location property, therefore this parameter is irrelevant.")] + [Output("success", "True if the Revit ParameterFilterElement instance has been updated successfully based on the input BHoM ViewFilter.")] + public static bool Update(this ParameterFilterElement element, BH.oM.Adapters.Revit.Elements.ViewFilter bHoMObject, RevitSettings settings, bool setLocationOnUpdate) + { + // 1. Collect the ElementIds of the filter's categories - via Streams + List builtInCategoryIds= bHoMObject.Categories.Select(catObj => { BuiltInCategory builtInCat; + Enum.TryParse(catObj.ToString(), out builtInCat); + return builtInCat; }) + .Select(builtInCat=> new ElementId(builtInCat)) + .ToList(); + // 2. Assign Categories' Ids to the ParameterFilterElement + element.SetCategories(builtInCategoryIds); + // 3. Assign Name to the ParameterFilterElement + element.Name = bHoMObject.Name; + // 4. Assign Filter Rules to the ParameterFilterElement - via Streams + element.SetElementFilter(new LogicalAndFilter(bHoMObject.Rules + .Select(filterRule => Convert.filterRuleToRevit(element.Document, filterRule)) + .Select(revitFilterRule => new ElementParameterFilter(revitFilterRule)) + .Cast() + .ToList())); + + // 5. Copy parameters to ParameterElementFilter + element.CopyParameters(bHoMObject, settings); + return true; + } + /***************************************************/ /**** Disallowed Types ****/ diff --git a/Revit_Core_Engine/Query/BHoMType.cs b/Revit_Core_Engine/Query/BHoMType.cs index 0dd6547b1..4d68623e3 100644 --- a/Revit_Core_Engine/Query/BHoMType.cs +++ b/Revit_Core_Engine/Query/BHoMType.cs @@ -53,6 +53,38 @@ public static Type IBHoMType(this Element element, Discipline discipline, RevitS /**** Public Methods ****/ /***************************************************/ + [Description("Finds a suitable BHoM type to convert the given Revit View to, based on the requested engineering discipline and adapter settings.")] + [Input("view", "Revit View to find a correspondent BHoM type.")] + [Input("discipline", "Engineering discipline based on the BHoM discipline classification.")] + [Input("settings", "Revit adapter settings to be used while performing the search for the correspondent type.")] + [Output("bHoMType", "A suitable BHoM type to convert the given Revit View to.")] + public static Type BHoMType(this View view, Discipline discipline, RevitSettings settings = null) + { + switch (discipline) + { + default: + return typeof(BH.oM.Adapters.Revit.Elements.View); + } + } + + /***************************************************/ + + [Description("Finds a suitable BHoM type to convert the given Revit ParameterFilterElement to, based on the requested engineering discipline and adapter settings.")] + [Input("viewFilter", "Revit ParameterFilterElement to find a correspondent BHoM type.")] + [Input("discipline", "Engineering discipline based on the BHoM discipline classification.")] + [Input("settings", "Revit adapter settings to be used while performing the search for the correspondent type.")] + [Output("bHoMType", "A suitable BHoM type to convert the given Revit ParameterFilterElement to.")] + public static Type BHoMType(this ParameterFilterElement viewFilter, Discipline discipline, RevitSettings settings = null) + { + switch (discipline) + { + default: + return typeof(BH.oM.Adapters.Revit.Elements.ViewFilter); + } + } + + /***************************************************/ + [Description("Finds a suitable BHoM type to convert the given Revit ProjectInfo to, based on the requested engineering discipline and adapter settings.")] [Input("projectInfo", "Revit ProjectInfo to find a correspondent BHoM type.")] [Input("discipline", "Engineering discipline based on the BHoM discipline classification.")] diff --git a/Revit_Core_Engine/Query/View.cs b/Revit_Core_Engine/Query/View.cs index d4eba8641..62e4a3d1d 100644 --- a/Revit_Core_Engine/Query/View.cs +++ b/Revit_Core_Engine/Query/View.cs @@ -39,15 +39,15 @@ public static partial class Query [Input("draftingInstance", "BHoM drafting instance to find owner Revit view for.")] [Input("document", "Revit document to parse in view search.")] [Output("view", "Revit view owning the input BHoM drafting instance.")] - public static View View(this DraftingInstance draftingInstance, Document document) + public static Autodesk.Revit.DB.View View(this DraftingInstance draftingInstance, Document document) { if (string.IsNullOrWhiteSpace(draftingInstance.ViewName)) return null; - List views = new FilteredElementCollector(document).OfClass(typeof(View)).Cast().ToList(); + List views = new FilteredElementCollector(document).OfClass(typeof(Autodesk.Revit.DB.View)).Cast().ToList(); views.RemoveAll(x => x.IsTemplate || x is ViewSchedule || x is View3D || x is ViewSheet); - View view = null; + Autodesk.Revit.DB.View view = null; if (views != null && views.Count > 0) view = views.Find(x => x.Name == draftingInstance.ViewName); @@ -55,7 +55,7 @@ public static View View(this DraftingInstance draftingInstance, Document documen if (view != null) return view; - views = new FilteredElementCollector(document).OfClass(typeof(ViewSheet)).Cast().ToList(); + views = new FilteredElementCollector(document).OfClass(typeof(ViewSheet)).Cast().ToList(); string title = draftingInstance.ViewName; if (!title.StartsWith("Sheet: ")) title = string.Format("Sheet: {0}", title); diff --git a/Revit_oM/Elements/OverrideGraphicSettings.cs b/Revit_oM/Elements/OverrideGraphicSettings.cs new file mode 100644 index 000000000..99085dc18 --- /dev/null +++ b/Revit_oM/Elements/OverrideGraphicSettings.cs @@ -0,0 +1,22 @@ +using BH.oM.Base; +using BH.oM.Revit.Enums; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Adapters.Revit.Elements +{ + public class OverrideGraphicSettings : BHoMObject + { + public virtual Color LineColor { get; set; } + public virtual Color CutColor { get; set; } + public virtual Color SurfaceColor { get; set; } + public virtual LinePattern LinePattern { get; set; } + public virtual FillPattern CutPattern { get; set; } + public virtual FillPattern SurfacePattern { get; set; } + + } +} diff --git a/Revit_oM/Elements/View.cs b/Revit_oM/Elements/View.cs new file mode 100644 index 000000000..a251c1811 --- /dev/null +++ b/Revit_oM/Elements/View.cs @@ -0,0 +1,15 @@ +using BH.oM.Base; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using BH.oM.Revit.Views; + +namespace BH.oM.Adapters.Revit.Elements +{ + public class View : BHoMObject + { + public virtual List FiltersWithOverrides { get; set; } + } +} diff --git a/Revit_oM/Elements/ViewFilter.cs b/Revit_oM/Elements/ViewFilter.cs new file mode 100644 index 000000000..13959881d --- /dev/null +++ b/Revit_oM/Elements/ViewFilter.cs @@ -0,0 +1,18 @@ +using BH.oM.Base; +using BH.oM.Adapters.Revit.Elements; +using BH.oM.Revit.FilterRules; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using BH.oM.Revit.Enums; + +namespace BH.oM.Adapters.Revit.Elements +{ + public class ViewFilter : BHoMObject + { + public virtual List Categories { get; set; } + public virtual List Rules { get; set; } + } +} diff --git a/Revit_oM/Enums/FillPattern.cs b/Revit_oM/Enums/FillPattern.cs new file mode 100644 index 000000000..81a9e6948 --- /dev/null +++ b/Revit_oM/Enums/FillPattern.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.Enums +{ + public enum FillPattern + { + CrossHatch, + DiagonalCrossHatch, + DiagonalDown, + DiagonalUp, + Horizontal, + Steel, + Solid, + Vertical + } +} diff --git a/Revit_oM/Enums/LevelComparisonType.cs b/Revit_oM/Enums/LevelComparisonType.cs new file mode 100644 index 000000000..48c61c8ae --- /dev/null +++ b/Revit_oM/Enums/LevelComparisonType.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.Enums +{ + /***************************************************/ + + [Description("Enumerator defining the way in which two levels are compared.")] + public enum LevelComparisonType + { + [Description("Check if input and reference level are at the same elevation.")] + Equal, + [Description("Check if input and reference level are at different elevations.")] + NotEqual, + [Description("Check if the input level is above the reference level.")] + Above, + [Description("Check if the input level is above or at the same elevation of the reference level.")] + AtOrAbove, + [Description("Check if the input level is below the reference level.")] + Below, + [Description("Check if the input level is below or at the same elevation of the reference level.")] + AtOrBelow, + } + + /***************************************************/ +} diff --git a/Revit_oM/Enums/LinePattern.cs b/Revit_oM/Enums/LinePattern.cs new file mode 100644 index 000000000..d0025cc17 --- /dev/null +++ b/Revit_oM/Enums/LinePattern.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.Enums +{ + public enum LinePattern + { + Dash, + DashDot, + DashDotDot, + DoubleDash, + Dot, + Hidden, + LongDash, + LooseDash, + Solid, + TripleDash + } +} diff --git a/Revit_oM/Enums/TextComparisonType.cs b/Revit_oM/Enums/TextComparisonType.cs index d0623cea4..90ba8da6c 100644 --- a/Revit_oM/Enums/TextComparisonType.cs +++ b/Revit_oM/Enums/TextComparisonType.cs @@ -33,14 +33,26 @@ public enum TextComparisonType Equal, [Description("Check if input string and reference string are different.")] NotEqual, - [Description("Check if the input input string contains reference string.")] + [Description("Check if the input string contains the reference string.")] Contains, - [Description("Check if the input input string does not contain reference string.")] + [Description("Check if the input string does not contain the reference string.")] ContainsNot, - [Description("Check if the input input string starts with reference string.")] + [Description("Check if the input string starts with the reference string.")] StartsWith, - [Description("Check if the input input string ends with reference string.")] + [Description("Check if the input string does not start with the reference string ")] + NotStartsWith, + [Description("Check if the input string ends with the reference string.")] EndsWith, + [Description("Check if the input string does not end with the reference string")] + NotEndsWith, + [Description("Check if the input string is greater than the reference string.")] + Greater, + [Description("Check if the input string is greater or equal to the reference string")] + GreaterOrEqual, + [Description("Check if the input string is smaller to the reference string")] + Less, + [Description("Check if the input string is smaller or equal to the reference string")] + LessOrEqual } /***************************************************/ diff --git a/Revit_oM/FilterRules/FilterCategoryRule.cs b/Revit_oM/FilterRules/FilterCategoryRule.cs new file mode 100644 index 000000000..6e96aa1e7 --- /dev/null +++ b/Revit_oM/FilterRules/FilterCategoryRule.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterCategoryRule : FilterRule + { + public virtual List CategoryNames { get; set; } + } +} diff --git a/Revit_oM/FilterRules/FilterDoubleRule.cs b/Revit_oM/FilterRules/FilterDoubleRule.cs new file mode 100644 index 000000000..5a1b38436 --- /dev/null +++ b/Revit_oM/FilterRules/FilterDoubleRule.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterDoubleRule : FilterNumericValueRule + { + + } +} diff --git a/Revit_oM/FilterRules/FilterElementIdRule.cs b/Revit_oM/FilterRules/FilterElementIdRule.cs new file mode 100644 index 000000000..4aff13a04 --- /dev/null +++ b/Revit_oM/FilterRules/FilterElementIdRule.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterElementIdRule : FilterNumericValueRule + { + } +} diff --git a/Revit_oM/FilterRules/FilterIntegerRule.cs b/Revit_oM/FilterRules/FilterIntegerRule.cs new file mode 100644 index 000000000..7de43b6ec --- /dev/null +++ b/Revit_oM/FilterRules/FilterIntegerRule.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterIntegerRule : FilterNumericValueRule + { + + } +} diff --git a/Revit_oM/FilterRules/FilterLevelRule.cs b/Revit_oM/FilterRules/FilterLevelRule.cs new file mode 100644 index 000000000..8f502498c --- /dev/null +++ b/Revit_oM/FilterRules/FilterLevelRule.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using BH.oM.Revit.Enums; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterLevelRule : FilterRule + { + public virtual string LevelName { get; set; } + public virtual LevelComparisonType ComparisonType { get; set; } + + } +} diff --git a/Revit_oM/FilterRules/FilterMaterialRule.cs b/Revit_oM/FilterRules/FilterMaterialRule.cs new file mode 100644 index 000000000..2214b22c7 --- /dev/null +++ b/Revit_oM/FilterRules/FilterMaterialRule.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterMaterialRule : FilterRule + { + public virtual string MaterialName { get; set; } + } +} diff --git a/Revit_oM/FilterRules/FilterNumericValueRule.cs b/Revit_oM/FilterRules/FilterNumericValueRule.cs new file mode 100644 index 000000000..45b16d732 --- /dev/null +++ b/Revit_oM/FilterRules/FilterNumericValueRule.cs @@ -0,0 +1,16 @@ +using BH.oM.Adapters.Revit.Enums; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public abstract class FilterNumericValueRule : FilterValueRule + { + public virtual NumberComparisonType ComparisonType { get; set; } + + + } +} diff --git a/Revit_oM/FilterRules/FilterParameterRule.cs b/Revit_oM/FilterRules/FilterParameterRule.cs new file mode 100644 index 000000000..9ba9c8021 --- /dev/null +++ b/Revit_oM/FilterRules/FilterParameterRule.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public abstract class FilterParameterRule: FilterRule + { + public virtual string ParameterName { get; set; } + } +} diff --git a/Revit_oM/FilterRules/FilterRule.cs b/Revit_oM/FilterRules/FilterRule.cs new file mode 100644 index 000000000..52b0f5fba --- /dev/null +++ b/Revit_oM/FilterRules/FilterRule.cs @@ -0,0 +1,15 @@ +using BH.oM.Base; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public abstract class FilterRule : BHoMObject + { + + } + +} diff --git a/Revit_oM/FilterRules/FilterStringRule.cs b/Revit_oM/FilterRules/FilterStringRule.cs new file mode 100644 index 000000000..9b65a4c26 --- /dev/null +++ b/Revit_oM/FilterRules/FilterStringRule.cs @@ -0,0 +1,14 @@ +using BH.oM.Adapters.Revit.Enums; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class FilterStringRule : FilterValueRule + { + public virtual TextComparisonType ComparisonType { get; set; } + } +} diff --git a/Revit_oM/FilterRules/FilterValueRule.cs b/Revit_oM/FilterRules/FilterValueRule.cs new file mode 100644 index 000000000..46a80d90a --- /dev/null +++ b/Revit_oM/FilterRules/FilterValueRule.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public abstract class FilterValueRule : FilterRule + { + public virtual string ParameterName { get; set; } + public virtual string Value { get; set; } + + } +} diff --git a/Revit_oM/FilterRules/ParameterValuePresenceRule.cs b/Revit_oM/FilterRules/ParameterValuePresenceRule.cs new file mode 100644 index 000000000..30bfe16d2 --- /dev/null +++ b/Revit_oM/FilterRules/ParameterValuePresenceRule.cs @@ -0,0 +1,14 @@ +using BH.oM.Base; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.FilterRules +{ + public class ParameterValuePresenceRule : FilterParameterRule + { + public virtual bool IsPresent { get; set; } + } +} diff --git a/Revit_oM/Views/ViewFilterWithOverrides.cs b/Revit_oM/Views/ViewFilterWithOverrides.cs new file mode 100644 index 000000000..8e9cd7162 --- /dev/null +++ b/Revit_oM/Views/ViewFilterWithOverrides.cs @@ -0,0 +1,16 @@ +using BH.oM.Adapters.Revit.Elements; +using BH.oM.Base; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace BH.oM.Revit.Views +{ + public class ViewFilterWithOverrides: BHoMObject + { + public virtual ViewFilter Filter { get; set; } + public virtual OverrideGraphicSettings Overrides { get; set; } + } +}