/***************************************************/ /**** Private Methods ****/ /***************************************************/ private static IBHoMObject _ShallowClone(this IBHoMObject bhomObject, bool newGuid = false) { IBHoMObject clone = DeepClonerExtensions.ShallowClone(bhomObject); if (bhomObject.CustomData != null) { clone.CustomData = new Dictionary <string, object>(bhomObject.CustomData); } else { clone.CustomData = new Dictionary <string, object>(); } if (bhomObject.Tags != null) { clone.Tags = new HashSet <string>(bhomObject.Tags); } else { clone.Tags = new HashSet <string>(); } if (newGuid) { clone.BHoM_Guid = Guid.NewGuid(); } return(clone); }
public static IBHoMObject AddFragment(this IBHoMObject iBHoMObject, IBHoMFragment fragment, bool replace = false) { if (iBHoMObject == null) { return(null); } IBHoMObject o = iBHoMObject.DeepClone(); int index = o.Fragments.FindIndex(x => x.GetType() == fragment.GetType()); if (index >= 0) { if (replace) { o.Fragments[index] = fragment; } else { Reflection.Compute.RecordError("That fragment already exists on this object. If you would like to replace the existing fragment set the 'replace' input to 'true'"); } } else { o.Fragments.Add(fragment); } return(o); }
private static string GetIdFromFragment(this IBHoMObject obj, Type fragmentType, string fragmentIdProperty) { if (!typeof(IFragment).IsAssignableFrom(fragmentType)) { BH.Engine.Reflection.Compute.RecordError("The specified Type must be a fragment Type."); return(null); } // Check on fragmentIdProperty if (string.IsNullOrWhiteSpace(fragmentIdProperty)) { BH.Engine.Reflection.Compute.RecordError($"Invalid {nameof(fragmentIdProperty)} provided."); return(null); } IFragment idFragm = obj.FindFragment <IFragment>(fragmentType); if (idFragm == null) { BH.Engine.Reflection.Compute.RecordWarning($"Object of type {obj.GetType()}, guid {obj.BHoM_Guid} does not contain a fragment of the provided Fragment type {fragmentType}."); return(null); } object value = BH.Engine.Reflection.Query.PropertyValue(idFragm, fragmentIdProperty); if (value == null) { BH.Engine.Reflection.Compute.RecordWarning($"The retrieved fragment for an object of type {obj.GetType()}, guid {obj.BHoM_Guid} has not any value under the property named {fragmentIdProperty}."); return(null); } return(value.ToString()); }
/***************************************************/ public static Element Create(IBHoMObject bHoMObject, Document document, RevitSettings settings, Dictionary <Guid, List <int> > refObjects) { if (bHoMObject == null) { NullObjectCreateError(typeof(IBHoMObject)); return(null); } try { Element element = bHoMObject.IToRevit(document, settings, refObjects); bHoMObject.SetIdentifiers(element); //Assign Tags string tagsParameterName = null; if (settings != null) { tagsParameterName = settings.ParameterSettings?.TagsParameter; } if (!string.IsNullOrEmpty(tagsParameterName)) { element.SetTags(bHoMObject, tagsParameterName); } return(element); } catch (Exception ex) { ObjectNotCreatedError(bHoMObject, ex); return(null); } }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static bool Update(this Element element, IBHoMObject bHoMObject, RevitSettings settings, bool setLocationOnUpdate) { bool isElement = new ElementIsElementTypeFilter(true).PassesFilter(element); if (isElement) { if (element.ISetType(bHoMObject, settings)) { element.Document.Regenerate(); } } element.CopyParameters(bHoMObject, settings); if (!string.IsNullOrWhiteSpace(bHoMObject.Name) && element.Name != bHoMObject.Name) { try { element.Name = bHoMObject.Name; } catch { } } if (setLocationOnUpdate && isElement) { element.ISetLocation(bHoMObject, settings); } return(true); }
// Fallback private static IGeometry GeometricalRepresentation(this IObject obj, RepresentationOptions reprOptions = null) { IGeometry geometricalRepresentation = null; // - Check if the object is a IGeometry, and if it is return itself. geometricalRepresentation = obj as IGeometry; if (geometricalRepresentation != null) { return(geometricalRepresentation); } // - If not, check if the object is a IBHoMObject whose IGeometry can be returned. IBHoMObject bHoMObject = obj as IBHoMObject; if (bHoMObject != null) { geometricalRepresentation = BH.Engine.Base.Query.IGeometry(bHoMObject); } // - Empty CompositeGeometries must not be considered valid. if (geometricalRepresentation != null) { if (geometricalRepresentation is CompositeGeometry && (geometricalRepresentation as CompositeGeometry).Elements.Count < 1) { geometricalRepresentation = null; } } return(geometricalRepresentation); }
public static IBHoMObject AddFragment(this IBHoMObject iBHoMObject, IBHoMFragment fragment, bool replace = false) { if (iBHoMObject == null) { return(null); } IBHoMObject o = iBHoMObject.DeepClone(); o.Fragments = new List <IBHoMFragment>(iBHoMObject.Fragments); if (o.Fragments.Contains(fragment)) { if (replace) { o.Fragments[o.Fragments.IndexOf(fragment)] = fragment; } else { Reflection.Compute.RecordError("That fragment already exists on this object. If you would like to replace the existing fragment set the 'replace' input to 'true'"); } } else { o.Fragments.Add(fragment); } return(o); }
public static ClonedType CloneType(this IBHoMObject sourceRevitObject, string newName) { if (sourceRevitObject == null) { BH.Engine.Reflection.Compute.RecordError("It is impossible to clone a null Revit object."); return null; } RevitIdentifiers identifiers = sourceRevitObject.FindFragment<RevitIdentifiers>(); if (identifiers == null) { BH.Engine.Reflection.Compute.RecordError("The input object is not a valid pulled Revit element."); return null; } ClonedType result = new ClonedType { SourceTypeId = identifiers.FamilyTypeId, Name = newName }; if (identifiers.ElementId == identifiers.FamilyTypeId) { RevitParametersToPush parametersToPush = sourceRevitObject.FindFragment<RevitParametersToPush>(); if (parametersToPush != null) { BH.Engine.Reflection.Compute.RecordWarning("Parameters to push have been cloned from the source Revit type object."); result.AddFragment(parametersToPush.DeepClone()); } } else BH.Engine.Reflection.Compute.RecordWarning("The input object is a pulled Revit element, its type has been cloned."); return result; }
public static Graph UniqueEntities(this Graph graph, Dictionary <Guid, IBHoMObject> replaceMap) { Dictionary <Guid, IBHoMObject> uniqueEntities = new Dictionary <Guid, IBHoMObject>(); foreach (KeyValuePair <Guid, IBHoMObject> kvp in graph.Entities) { IBHoMObject unique = replaceMap[kvp.Key]; if (!uniqueEntities.ContainsKey(unique.BHoM_Guid)) { uniqueEntities.Add(unique.BHoM_Guid, unique); } } graph.Entities = uniqueEntities; List <IRelation> uniqueRelations = new List <IRelation>(); foreach (IRelation relation in graph.Relations) { IRelation relation1 = relation.UniqueEntities(replaceMap); //keep if it does not already exist if (!uniqueRelations.Any(r => r.Source.Equals(relation1.Source) && r.Target.Equals(relation1.Target))) { uniqueRelations.Add(relation1); } } graph.Relations = uniqueRelations; return(graph); }
/***************************************************/ /**** Public methods ****/ /***************************************************/ public static void SetIdentifiers(this IBHoMObject bHoMObject, Element element) { if (bHoMObject != null && element != null) { bHoMObject.Fragments.AddOrReplace(element.IIdentifiers()); } }
private static IBHoMObject SetRendermesh(this IBHoMObject bHoMObject, List <Mesh> representation) { Mesh m = Compute.JoinMeshes(representation); RenderMesh rm = m.ToRenderMesh(); return(bHoMObject.SetRendermesh(m)); }
public static IBHoMObject RemoveFragment(this IBHoMObject iBHoMObject, Type fragmentType = null) { if (fragmentType == null) { return(iBHoMObject); } if (iBHoMObject == null) { return(null); } IBHoMObject o = iBHoMObject.DeepClone(); if (!typeof(IFragment).IsAssignableFrom(fragmentType)) { Reflection.Compute.RecordError("Provided input in fragmentType is not a Fragment type (does not implement IFragment interface)."); return(iBHoMObject); } if (!iBHoMObject.Fragments.Contains(fragmentType)) { Reflection.Compute.RecordWarning($"{iBHoMObject.GetType().Name} does not contain any `{fragmentType.Name}` fragment."); return(iBHoMObject); } o.Fragments.Remove(fragmentType); return(o); }
/***************************************************/ /**** Private Methods ****/ /***************************************************/ private static void SetEntityRepresentation(this IBHoMObject obj, int seqNumber, Boxes component, double xSpace, double ySpace) { double x = 0; double y = 0; double cellX = xSpace - 2 * component.Padding; double cellY = ySpace - 2 * component.Padding; if (component.IsHorizontal) { x = System.Convert.ToDouble(m_Xscale.IScale(seqNumber)); y = System.Convert.ToDouble(m_Yscale.IScale(obj.PropertyValue(component.Group))); } else { x = System.Convert.ToDouble(m_Xscale.IScale(obj.PropertyValue(component.Group))); y = System.Convert.ToDouble(m_Yscale.IScale(seqNumber)); } EntityRepresentation representation = new EntityRepresentation(); Point basePt = SetAnchorPoint(Geometry.Create.Point(x, y, 0), component.Padding, component.Padding, 0); representation.Boundary = Box(basePt, cellX, cellY); representation.Text = obj.PropertyValue(component.Text).ToString(); representation.TextPosition = SetAnchorPoint(basePt, component.Padding, component.Padding, 0); representation.OutgoingRelationPoint = SetAnchorPoint(basePt, cellX, cellY / 2, 0); representation.IncomingRelationPoint = SetAnchorPoint(basePt, 0, cellY / 2, 0); representation.Colour = Convert.ColourFromObject(m_Colourscale.IScale(obj.PropertyValue(component.Colour))); obj.Fragments.AddOrReplace(representation); }
public static string DiffingHash(this object obj, DiffConfig diffConfig = null) { diffConfig = diffConfig == null ? new DiffConfig() : (DiffConfig)diffConfig.DeepClone(); // The following is to consider only the PropertiesToInclude specified in the diffConfig. // Since the SHA hash algorithm can only consider "exceptions", we need to retrieve all the top level properties, // intersect them with the set of PropertiesToInclude, and treat all the properties that remain out as "exceptions" (not to be considered). if (diffConfig.PropertiesToConsider.Any()) { IEnumerable <string> exceptions = BH.Engine.Reflection.Query.PropertyNames(obj).Except(diffConfig.PropertiesToConsider); diffConfig.PropertiesToIgnore.AddRange(exceptions); } // The current Hash must not be considered when computing the hash. Remove HashFragment if present. IBHoMObject bhomobj = obj as IBHoMObject; if (bhomobj != null) { bhomobj = BH.Engine.Base.Query.DeepClone(obj) as IBHoMObject; bhomobj.Fragments.Remove(typeof(HashFragment)); return(Compute.SHA256Hash(bhomobj, diffConfig.PropertiesToIgnore)); } return(Compute.SHA256Hash(obj, diffConfig.PropertiesToIgnore)); }
/***************************************************/ public static void SetTags(this IBHoMObject bHoMObject, Element element, string tagsParameterName) { if (bHoMObject == null || element == null || string.IsNullOrEmpty(tagsParameterName)) { return; } Parameter parameter = element.LookupParameter(tagsParameterName); if (parameter == null || parameter.StorageType != StorageType.String) { return; } string tags = parameter.AsString(); if (string.IsNullOrEmpty(tags)) { return; } if (bHoMObject.Tags == null) { bHoMObject.Tags = new System.Collections.Generic.HashSet <string>(); } string[] values = tags.Split(new string[] { "; " }, StringSplitOptions.None); foreach (string value in values) { bHoMObject.Tags.Add(value); } }
/***************************************************/ private static List <IBHoMObject> RandomNeighbours(List <List <List <IBHoMObject> > > entities, int i, int j, int k) { //from Von Neumann neighborhood randomly select 2 to all neighbours List <IBHoMObject> neighbours = new List <IBHoMObject>(); int left = i - 1; int right = i + 1; int infront = j + 1; int behind = j - 1; int below = k - 1; int above = k + 1; if (left >= 0) { neighbours.Add(entities[k][left][j]); } if (right <= entities[0].Count - 1) { neighbours.Add(entities[k][right][j]); } if (behind >= 0) { neighbours.Add(entities[k][i][behind]); } if (infront <= entities[0][0].Count - 1) { neighbours.Add(entities[k][i][infront]); } if (below >= 0) { neighbours.Add(entities[below][i][j]); } if (above <= entities.Count - 1) { neighbours.Add(entities[above][i][j]); } if (neighbours.Count <= 2) { return(neighbours); } int total = m_Rnd.Next(2, neighbours.Count); List <IBHoMObject> wanted = new List <IBHoMObject>(); while (wanted.Count < total) { IBHoMObject next = neighbours[m_Rnd.Next(0, neighbours.Count)]; if (wanted.Contains(next)) { continue; } wanted.Add(next); } return(wanted); }
/***************************************************/ /**** Public methods ****/ /***************************************************/ public static void SetTags(this Element element, IBHoMObject bHoMObject, string tagsParameterName) { if (bHoMObject == null || element == null || string.IsNullOrEmpty(tagsParameterName)) { return; } Parameter parameter = element.LookupParameter(tagsParameterName); if (parameter == null || parameter.IsReadOnly || parameter.StorageType != StorageType.String) { return; } string newValue = null; if (bHoMObject.Tags != null && bHoMObject.Tags.Count != 0) { newValue = string.Join("; ", bHoMObject.Tags); } string oldValue = parameter.AsString(); if (newValue != oldValue) { parameter.Set(newValue); } }
public static object PropertyValue(this object obj, string propName) { if (obj == null || propName == null) { return(null); } if (propName.Contains(".")) { string[] props = propName.Split('.'); foreach (string innerProp in props) { obj = obj.PropertyValue(innerProp); if (obj == null) { break; } } return(obj); } System.Reflection.PropertyInfo prop = obj.GetType().GetProperty(propName); if (prop != null) { return(prop.GetValue(obj)); } else if (obj is IBHoMObject) { IBHoMObject bhom = obj as IBHoMObject; if (bhom.CustomData.ContainsKey(propName)) { Compute.RecordNote($"{propName} is stored in CustomData"); return(bhom.CustomData[propName]); } else { Compute.RecordWarning($"{bhom} does not contain a property: {propName}, or: CustomData[{propName}]"); return(null); } } else if (obj is IDictionary) { IDictionary dic = obj as IDictionary; if (dic.Contains(propName)) { return(dic[propName]); } else { Compute.RecordWarning($"{dic} does not contain the key: {propName}"); return(null); } } else { Compute.RecordWarning($"This instance of {obj.GetType()} does not contain the property: {propName}"); return(null); } }
protected SpeckleObject ToSpeckle(IBHoMObject bhomObject, SpecklePushConfig config) { // Assign SpeckleStreamId to the Fragments of the IBHoMObjects SetAdapterId(bhomObject, SpeckleClient.Stream.StreamId); // SpeckleObject "container". Top level has geometry representation of BHoM Object, so it can be visualised in the SpeckleViewer. SpeckleObject speckleObject = SpeckleRepresentation(bhomObject, config.RendermeshOptions); // If no Speckle representation is found, it will be sent as an "Abstract" SpeckleObject (no visualisation). if (speckleObject == null) { speckleObject = (SpeckleObject)SpeckleCore.Converter.Serialise(bhomObject); } // Save BHoMObject data inside the speckleObject. Modify.SetBHoMData(speckleObject, bhomObject, config.UseSpeckleSerialiser); speckleObject.SetDiffingHash(bhomObject, config); // If the BHoMObject has a "RevisionName" string field in the Customdata, // use that value to create a Layer for it, and set the SpeckleObject's layer. //object revisionValue = null; //string revisionName = ""; //if (bhomObject.CustomData.TryGetValue("RevisionName", out revisionValue)) //{ // revisionName = revisionValue as string; // if (!string.IsNullOrWhiteSpace(revisionName)) // speckleObject.Properties["revisionName"] = revisionName; //} return(speckleObject); }
/***************************************************/ internal static void CheckIfNullPush(this Element element, IBHoMObject bhomObject) { if (element == null) { BH.Engine.Reflection.Compute.RecordWarning(string.Format("Revit element has not been created due to BHoM/Revit conversion issues. BHoM element Guid: {0}", bhomObject.BHoM_Guid)); } }
private static ConditionResult VerifyCondition(List <object> objects, HasId idCondition) { ConditionResult result = new ConditionResult() { Condition = idCondition }; foreach (var obj in objects) { IBHoMObject bhomObj = obj as IBHoMObject; if (bhomObj == null || idCondition.Ids.Contains(bhomObj.FindFragment <IAdapterId>()?.Id)) { result.PassedObjects.Add(obj); result.Pattern.Add(true); } else { result.FailedObjects.Add(obj); result.FailInfo.Add($"{(string.IsNullOrWhiteSpace(idCondition.Clause) ? "" : idCondition.Clause + " failed: ")}" + $"does not have the requested id."); result.Pattern.Add(false); } } return(result); }
/***************************************************/ /**** Private methods ****/ /***************************************************/ private static T ElementType <T>(this IBHoMObject bHoMObject, Document document, IEnumerable <BuiltInCategory> builtInCategories = null) where T : ElementType { string familyName, familyTypeName; bHoMObject.FamilyAndTypeNames(out familyName, out familyTypeName); return(document.ElementType <T>(familyName, familyTypeName, builtInCategories)); }
/***************************************************/ private static TestResult TestFailedResult(IBHoMObject obj, string message = "") { TestResult result = TestResultFromPushedObject(obj); result.Message = message; result.Status = oM.Test.TestStatus.Error; return(result); }
/***************************************************/ private static TestResult TestResultFromPushedObject(IBHoMObject obj) { return(new TestResult { Description = $"Test object of type {obj.GetType().Name} with name {obj.Name}", ID = obj.Hash(null, true), }); }
/***************************************************/ /**** Interface methods ****/ /***************************************************/ public static bool ISetLocation(this Element element, IBHoMObject bHoMObject, RevitSettings settings) { if (element == null || bHoMObject == null) { return(false); } return(SetLocation(element as dynamic, bHoMObject as dynamic, settings)); }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static IGeometry IGeometry(this IBHoMObject obj) { if (obj == null) { return(null); } return(Geometry(obj as dynamic)); }
public static string DiffingHash(this IBHoMObject obj, List <string> exceptions = null, bool useDefaultExceptions = true) { if (exceptions == null || exceptions.Count == 0 && useDefaultExceptions) { SetDefaultExceptions(ref exceptions); } return(Compute.SHA256Hash(obj, exceptions)); }
public static RevisionFragment RevisionFragment(this IBHoMObject obj) { if (obj == null) { BH.Engine.Reflection.Compute.RecordError("Cannot query the revision fragment from a null object."); return(null); } return(obj.FindFragment <RevisionFragment>()); }
/***************************************************/ internal static void NullRevitElementWarning(this IBHoMObject bhomObject) { string message = "Referenced Revit element could not be found."; if (bhomObject != null) { message = string.Format("{0} BHoM Guid: {1}", message, bhomObject.BHoM_Guid); } BH.Engine.Reflection.Compute.RecordWarning(message); }
/***************************************************/ internal static void ClosedNurbsCurveError(this IBHoMObject iBHoMObject) { string message = "Revit does not support closed nurbs curves."; if (iBHoMObject != null) { message = string.Format("{0} BHoM Guid: {1}", message, iBHoMObject.BHoM_Guid); } BH.Engine.Reflection.Compute.RecordWarning(message); }