void ReconstructAdaptiveComponentByPoints ( DB.Document doc, ref DB.Element element, IList <Rhino.Geometry.Point3d> points, DB.FamilySymbol type ) { var adaptivePoints = points.ConvertAll(GeometryEncoder.ToXYZ); if (!type.IsActive) { type.Activate(); } // Type ChangeElementTypeId(ref element, type.Id); if (element is DB.FamilyInstance instance && DB.AdaptiveComponentInstanceUtils.IsAdaptiveComponentInstance(instance)) { var adaptivePointIds = DB.AdaptiveComponentInstanceUtils.GetInstancePlacementPointElementRefIds(instance); if (adaptivePointIds.Count == adaptivePoints.Length) { int index = 0; foreach (var vertex in adaptivePointIds.Select(id => doc.GetElement(id)).Cast <DB.ReferencePoint>()) { vertex.Position = adaptivePoints[index++]; } return; } } { var creationData = new List <Autodesk.Revit.Creation.FamilyInstanceCreationData> { Revit.ActiveUIApplication.Application.Create.NewFamilyInstanceCreationData(type, adaptivePoints) }; var newElementIds = doc.IsFamilyDocument ? doc.FamilyCreate.NewFamilyInstances2(creationData) : doc.Create.NewFamilyInstances2(creationData); if (newElementIds.Count != 1) { doc.Delete(newElementIds); throw new InvalidOperationException(); } var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM }; ReplaceElement(ref element, doc.GetElement(newElementIds.First()), parametersMask); } }
protected void PipeHostParameter(IGH_DataAccess DA, DB.Element srcElement, DB.BuiltInParameter srcParam, string paramName) { var param = srcElement.get_Parameter(srcParam); if (param != null) { switch (param.StorageType) { case DB.StorageType.None: break; case DB.StorageType.String: DA.SetData(paramName, param.AsString()); break; case DB.StorageType.Integer: DA.SetData(paramName, param.AsInteger()); break; case DB.StorageType.Double: DA.SetData(paramName, param.AsDoubleInRhinoUnits()); break; case DB.StorageType.ElementId: DA.SetData( paramName, Types.Element.FromElementId(doc: srcElement.Document, Id: param.AsElementId()) ); break; } } }
void ReconstructFloorByOutline ( DB.Document doc, ref DB.Floor element, Rhino.Geometry.Curve boundary, Optional <DB.FloorType> type, Optional <DB.Level> level, [Optional] bool structural ) { var scaleFactor = 1.0 / Revit.ModelUnits; if ( ((boundary = boundary.ChangeUnits(scaleFactor)) is null) || !boundary.IsClosed || !boundary.TryGetPlane(out var boundaryPlane, Revit.VertexTolerance) || boundaryPlane.ZAxis.IsParallelTo(Rhino.Geometry.Vector3d.ZAxis) == 0 ) { ThrowArgumentException(nameof(boundary), "Boundary must be an horizontal planar closed curve."); } SolveOptionalType(ref type, doc, DB.ElementTypeGroup.FloorType, nameof(type)); SolveOptionalLevel(doc, boundary, ref level, out var bbox); var curveArray = boundary.ToHostMultiple().ToCurveArray(); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.LEVEL_PARAM, DB.BuiltInParameter.FLOOR_PARAM_IS_STRUCTURAL }; if (type.Value.IsFoundationSlab) { ReplaceElement(ref element, doc.Create.NewFoundationSlab(curveArray, type.Value, level.Value, structural, DB.XYZ.BasisZ), parametersMask); } else { ReplaceElement(ref element, doc.Create.NewFloor(curveArray, type.Value, level.Value, structural, DB.XYZ.BasisZ), parametersMask); } if (element != null) { var boundaryBBox = boundary.GetBoundingBox(true); element.get_Parameter(DB.BuiltInParameter.FLOOR_HEIGHTABOVELEVEL_PARAM).Set(boundaryBBox.Min.Z - level.Value.Elevation); } }
protected static bool TryGetFilterIntegerParam(DB.BuiltInParameter paramId, int pattern, out DB.ElementFilter filter) { var rule = new DB.FilterIntegerRule ( new DB.ParameterValueProvider(new DB.ElementId(paramId)), new DB.FilterNumericEquals(), pattern ); filter = new DB.ElementParameterFilter(rule, false); return(true); }
protected static bool TryGetFilterLengthParam(DB.BuiltInParameter paramId, double pattern, out DB.ElementFilter filter) { var rule = new DB.FilterDoubleRule ( new DB.ParameterValueProvider(new DB.ElementId(paramId)), new DB.FilterNumericEquals(), pattern, Revit.VertexTolerance ); filter = new DB.ElementParameterFilter(rule, false); return(true); }
void ReconstructRoofByOutline ( DB.Document doc, ref DB.FootPrintRoof element, Rhino.Geometry.Curve boundary, Optional <DB.RoofType> type, Optional <DB.Level> level ) { var scaleFactor = 1.0 / Revit.ModelUnits; if ( ((boundary = boundary.ChangeUnits(scaleFactor)) is null) || boundary.IsShort(Revit.ShortCurveTolerance) || !boundary.IsClosed || !boundary.TryGetPlane(out var boundaryPlane, Revit.VertexTolerance) || boundaryPlane.ZAxis.IsParallelTo(Rhino.Geometry.Vector3d.ZAxis) == 0 ) { ThrowArgumentException(nameof(boundary), "Boundary should be an horizontal planar closed curve."); } SolveOptionalType(ref type, doc, DB.ElementTypeGroup.RoofType, nameof(type)); double minZ = boundary.GetBoundingBox(true).Min.Z; SolveOptionalLevel(ref level, doc, minZ); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.LEVEL_PARAM, DB.BuiltInParameter.ROOF_LEVEL_OFFSET_PARAM }; using (var curveArray = boundary.ToHostMultiple().ToCurveArray()) { var footPrintToModelCurvesMapping = new DB.ModelCurveArray(); ReplaceElement(ref element, doc.Create.NewFootPrintRoof(curveArray, level.Value, type.Value, out footPrintToModelCurvesMapping), parametersMask); } if (element != null) { element.get_Parameter(DB.BuiltInParameter.ROOF_LEVEL_OFFSET_PARAM).Set(minZ - level.Value.Elevation); } }
SetOutputFromPropertySetElementParam(IGH_DataAccess DA, DB.PropertySetElement srcElement, DB.BuiltInParameter srcParam, string paramName) { if (srcElement is null) { DA.SetData(paramName, null); return(false); } bool valueFound = false; var param = srcElement.get_Parameter(srcParam); if (param != null) { valueFound = true; switch (param.StorageType) { case DB.StorageType.None: break; case DB.StorageType.String: DA.SetData(paramName, param.AsString()); break; case DB.StorageType.Integer: if (param.Definition.ParameterType == DB.ParameterType.YesNo) { DA.SetData(paramName, param.AsInteger() != 0); } else { DA.SetData(paramName, param.AsInteger()); } break; case DB.StorageType.Double: DA.SetData(paramName, param.AsDoubleInRhinoUnits()); break; case DB.StorageType.ElementId: DA.SetData( paramName, Types.Element.FromElementId(srcElement.Document, param.AsElementId()) ); break; } } return(valueFound); }
void ReconstructRoofByOutline ( DB.Document doc, ref DB.FootPrintRoof element, Rhino.Geometry.Curve boundary, Optional <DB.RoofType> type, Optional <DB.Level> level ) { if ( boundary.IsShort(Revit.ShortCurveTolerance * Revit.ModelUnits) || !boundary.IsClosed || !boundary.TryGetPlane(out var boundaryPlane, Revit.VertexTolerance * Revit.ModelUnits) || boundaryPlane.ZAxis.IsParallelTo(Rhino.Geometry.Vector3d.ZAxis) == 0 ) { ThrowArgumentException(nameof(boundary), "Boundary should be an horizontal planar closed curve."); } SolveOptionalType(ref type, doc, DB.ElementTypeGroup.RoofType, nameof(type)); SolveOptionalLevel(doc, boundary, ref level, out var bbox); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.ROOF_BASE_LEVEL_PARAM, DB.BuiltInParameter.ROOF_LEVEL_OFFSET_PARAM }; using (var curveArray = boundary.ToCurveArray()) { var footPrintToModelCurvesMapping = new DB.ModelCurveArray(); ReplaceElement(ref element, doc.Create.NewFootPrintRoof(curveArray, level.Value, type.Value, out footPrintToModelCurvesMapping), parametersMask); } if (element != null) { element.get_Parameter(DB.BuiltInParameter.ROOF_LEVEL_OFFSET_PARAM).Set(bbox.Min.Z / Revit.ModelUnits - level.Value.GetHeight()); } }
protected void PipeHostParameter(IGH_DataAccess DA, DB.Element srcElement, DB.BuiltInParameter srcParam, string paramName) { if (srcElement is null) { DA.SetData(paramName, null); return; } var param = srcElement.get_Parameter(srcParam); if (param != null) { switch (param.StorageType) { case DB.StorageType.None: break; case DB.StorageType.String: DA.SetData(paramName, param.AsString()); break; case DB.StorageType.Integer: if (param.Definition.ParameterType == DB.ParameterType.YesNo) { DA.SetData(paramName, param.AsInteger() != 0); } else { DA.SetData(paramName, param.AsInteger()); } break; case DB.StorageType.Double: DA.SetData(paramName, param.AsDoubleInRhinoUnits()); break; case DB.StorageType.ElementId: DA.SetData( paramName, Types.Element.FromElementId(srcElement.Document, param.AsElementId()) ); break; } } }
internal static bool TryGetFilterStringParam(DB.BuiltInParameter paramId, ref string pattern, out DB.ElementFilter filter) { if (pattern is string subPattern) { var inverted = false; var method = Operator.CompareMethodFromPattern(ref subPattern, ref inverted); if (Operator.CompareMethod.Nothing < method && method < Operator.CompareMethod.Wildcard) { var evaluator = default(DB.FilterStringRuleEvaluator); switch (method) { case Operator.CompareMethod.Equals: evaluator = new DB.FilterStringEquals(); break; case Operator.CompareMethod.StartsWith: evaluator = new DB.FilterStringBeginsWith(); break; case Operator.CompareMethod.EndsWith: evaluator = new DB.FilterStringEndsWith(); break; case Operator.CompareMethod.Contains: evaluator = new DB.FilterStringContains(); break; } var rule = new DB.FilterStringRule ( new DB.ParameterValueProvider(new DB.ElementId(paramId)), evaluator, subPattern, true ); filter = new DB.ElementParameterFilter(rule, inverted); pattern = default; return(true); } } filter = default; return(false); }
void ReconstructBeamByCurve ( DB.Document doc, ref DB.FamilyInstance element, Rhino.Geometry.Curve curve, Optional <DB.FamilySymbol> type, Optional <DB.Level> level ) { if ( curve.IsClosed || !curve.IsPlanar(Revit.VertexTolerance * Revit.ModelUnits) || curve.GetNextDiscontinuity(Rhino.Geometry.Continuity.C2_continuous, curve.Domain.Min, curve.Domain.Max, out var _) ) { ThrowArgumentException(nameof(curve), "Curve must be a C2 continuous planar non closed curve."); } SolveOptionalLevel(doc, curve, ref level, out var bbox); var centerLine = curve.ToCurve(); if (type.HasValue) { ChangeElementTypeId(ref element, type.Value.Id); } // Try to update Beam if (element is object && element.Location is DB.LocationCurve locationCurve && centerLine.IsSameKindAs(locationCurve.Curve)) { var referenceLevel = element.get_Parameter(DB.BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM); var updateLevel = referenceLevel.AsElementId() != level.Value.Id; if (!updateLevel || !referenceLevel.IsReadOnly) { if (updateLevel) { referenceLevel.Set(level.Value.Id); } locationCurve.Curve = centerLine; return; } } // Reconstruct Beam { SolveOptionalType(ref type, doc, DB.BuiltInCategory.OST_StructuralFraming, nameof(type)); var newBeam = doc.Create.NewFamilyInstance ( centerLine, type.Value, level.Value, DB.Structure.StructuralType.Beam ); newBeam.get_Parameter(DB.BuiltInParameter.Y_JUSTIFICATION).Set((int)DB.Structure.YJustification.Origin); newBeam.get_Parameter(DB.BuiltInParameter.Z_JUSTIFICATION).Set((int)DB.Structure.ZJustification.Origin); if (element is object && DB.Structure.StructuralFramingUtils.IsJoinAllowedAtEnd(element, 0)) { DB.Structure.StructuralFramingUtils.AllowJoinAtEnd(newBeam, 0); } else { DB.Structure.StructuralFramingUtils.DisallowJoinAtEnd(newBeam, 0); } if (element is object && DB.Structure.StructuralFramingUtils.IsJoinAllowedAtEnd(element, 1)) { DB.Structure.StructuralFramingUtils.AllowJoinAtEnd(newBeam, 1); } else { DB.Structure.StructuralFramingUtils.DisallowJoinAtEnd(newBeam, 1); } var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM }; ReplaceElement(ref element, newBeam, parametersMask); } }
protected void PipeHostParameter(IGH_DataAccess DA, DB.Element srcElement, DB.BuiltInParameter srcParam, string paramName) { DA.SetData(paramName, srcElement?.get_Parameter(srcParam).AsGoo()); }
void ReconstructBuildingPadByOutline ( DB.Document doc, ref DB.Architecture.BuildingPad element, IList <Rhino.Geometry.Curve> boundaries, Optional <DB.BuildingPadType> type, Optional <DB.Level> level ) { var scaleFactor = 1.0 / Revit.ModelUnits; boundaries = boundaries.Select(x => x.ChangeUnits(scaleFactor)).ToArray(); var boundaryBBox = Rhino.Geometry.BoundingBox.Empty; foreach (var boundary in boundaries) { boundaryBBox.Union(boundary.GetBoundingBox(true)); } var curveLoops = boundaries.Select(region => DB.CurveLoop.Create(region.ToHostMultiple().SelectMany(x => x.ToBoundedCurves()).ToList())); SolveOptionalLevel(ref level, doc, boundaryBBox.Min.Z, nameof(level)); if (type.HasValue) { ChangeElementTypeId(ref element, type.Value.Id); } if (element is DB.Architecture.BuildingPad buildingPad) { element.get_Parameter(DB.BuiltInParameter.LEVEL_PARAM).Set(level.Value.Id); buildingPad.SetBoundary(curveLoops.ToList()); } else { SolveOptionalType(ref type, doc, DB.ElementTypeGroup.BuildingPadType, (document, param) => DB.BuildingPadType.CreateDefault(document), nameof(type)); var newPad = DB.Architecture.BuildingPad.Create ( doc, type.Value.Id, level.Value.Id, curveLoops.ToList() ); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.LEVEL_PARAM, DB.BuiltInParameter.BUILDINGPAD_HEIGHTABOVELEVEL_PARAM }; ReplaceElement(ref element, newPad, parametersMask); } element?.get_Parameter(DB.BuiltInParameter.BUILDINGPAD_HEIGHTABOVELEVEL_PARAM).Set(boundaryBBox.Min.Z - level.Value.Elevation); }
protected void PipeHostParameter <T>(IGH_DataAccess DA, DB.Element srcElement, DB.BuiltInParameter srcParam, string paramName) where T : Types.GH_Enumerate, new() { if (srcElement is null) { DA.SetData(paramName, null); return; } var param = srcElement.get_Parameter(srcParam); if (param != null && param.StorageType == DB.StorageType.Integer) { var enumType = new T(); enumType.Value = param.AsInteger(); DA.SetData(paramName, enumType); } }
void ReconstructFamilyInstanceByLocation ( DB.Document doc, ref DB.FamilyInstance element, [Description("Location where to place the element. Point or plane is accepted.")] Plane location, DB.FamilySymbol type, Optional <DB.Level> level, [Optional] DB.Element host ) { if (!location.IsValid) { ThrowArgumentException(nameof(location), "Location is not valid."); } if (!type.IsActive) { type.Activate(); } { FamilyInstanceCreationData creationData; switch (type.Family.FamilyPlacementType) { case DB.FamilyPlacementType.OneLevelBased: creationData = CreateOneLevelBased(doc, location, type, level, host); break; case DB.FamilyPlacementType.OneLevelBasedHosted: creationData = CreateOneLevelBasedHosted(doc, location, type, level, host); break; case DB.FamilyPlacementType.TwoLevelsBased: creationData = CreateTwoLevelsBased(doc, location, type, level, host); break; case DB.FamilyPlacementType.WorkPlaneBased: creationData = CreateWorkPlaneBased(doc, location, type, level, host); break; default: creationData = CreateDefault(doc, location, type, level, host); break; } var dataList = new List <FamilyInstanceCreationData>() { creationData }; var newElementIds = doc.IsFamilyDocument ? doc.FamilyCreate.NewFamilyInstances2(dataList) : doc.Create.NewFamilyInstances2(dataList); if (newElementIds.Count != 1) { doc.Delete(newElementIds); throw new InvalidOperationException(); } var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.FAMILY_LEVEL_PARAM, DB.BuiltInParameter.FAMILY_BASE_LEVEL_PARAM, DB.BuiltInParameter.FAMILY_BASE_LEVEL_OFFSET_PARAM, DB.BuiltInParameter.FAMILY_TOP_LEVEL_PARAM, DB.BuiltInParameter.FAMILY_TOP_LEVEL_OFFSET_PARAM, DB.BuiltInParameter.SCHEDULE_LEVEL_PARAM, DB.BuiltInParameter.SCHEDULE_BASE_LEVEL_PARAM, DB.BuiltInParameter.SCHEDULE_BASE_LEVEL_OFFSET_PARAM, DB.BuiltInParameter.SCHEDULE_TOP_LEVEL_PARAM, DB.BuiltInParameter.SCHEDULE_TOP_LEVEL_OFFSET_PARAM, DB.BuiltInParameter.INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM, DB.BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM }; ReplaceElement(ref element, doc.GetElement(newElementIds.First()) as DB.FamilyInstance, parametersMask); doc.Regenerate(); if (element.Pinned) { try { element.Pinned = false; } catch (Autodesk.Revit.Exceptions.InvalidOperationException) { } } } element?.SetLocation(location.Origin.ToXYZ(), location.XAxis.ToXYZ(), location.YAxis.ToXYZ()); }
void ReconstructRailingByCurve ( DB.Document doc, ref DB.Architecture.Railing element, Rhino.Geometry.Curve curve, Optional <DB.Architecture.RailingType> type, Optional <DB.Level> level, [Optional] DB.Element host, [Optional] bool flipped ) { SolveOptionalType(ref type, doc, DB.ElementTypeGroup.StairsRailingType, nameof(type)); SolveOptionalLevel(doc, curve, ref level, out var bbox); // Axis var levelPlane = new Rhino.Geometry.Plane(new Rhino.Geometry.Point3d(0.0, 0.0, level.Value.Elevation * Revit.ModelUnits), Rhino.Geometry.Vector3d.ZAxis); curve = Rhino.Geometry.Curve.ProjectToPlane(curve, levelPlane); curve = curve.Simplify(Rhino.Geometry.CurveSimplifyOptions.All, Revit.VertexTolerance * Revit.ModelUnits, Revit.AngleTolerance) ?? curve; // Type ChangeElementTypeId(ref element, type.Value.Id); DB.Architecture.Railing newRail = null; if (element is DB.Architecture.Railing previousRail) { newRail = previousRail; newRail.SetPath(curve.ToCurveLoop()); } else { newRail = DB.Architecture.Railing.Create ( doc, curve.ToCurveLoop(), type.Value.Id, level.Value.Id ); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.STAIRS_RAILING_BASE_LEVEL_PARAM, DB.BuiltInParameter.STAIRS_RAILING_HEIGHT_OFFSET, }; ReplaceElement(ref element, newRail, parametersMask); } if (newRail is object) { using (var baseLevel = newRail.get_Parameter(DB.BuiltInParameter.STAIRS_RAILING_BASE_LEVEL_PARAM)) { if (!baseLevel.IsReadOnly) { baseLevel.Set(level.Value.Id); } } using (var heightOffset = newRail.get_Parameter(DB.BuiltInParameter.STAIRS_RAILING_HEIGHT_OFFSET)) { if (!heightOffset.IsReadOnly) { heightOffset.Set(bbox.Min.Z / Revit.ModelUnits - level.Value.Elevation); } } newRail.HostId = host?.Id ?? DB.ElementId.InvalidElementId; if (newRail.Flipped != flipped) { newRail.Flip(); } } }
private bool ConvertToBool(Rvt.BuiltInParameter bip) { var parameter = family.get_Parameter(bip); return(Convert.ToBoolean(parameter.AsInteger())); }
void ReconstructWallByProfile ( DB.Document doc, ref DB.Wall element, IList <Rhino.Geometry.Curve> profile, Optional <DB.WallType> type, Optional <DB.Level> level, [Optional] DB.WallLocationLine locationLine, [Optional] bool flipped, [Optional, NickName("J")] bool allowJoins, [Optional] DB.Structure.StructuralWallUsage structuralUsage ) { foreach (var boundary in profile) { if ( !boundary.IsClosed || !boundary.TryGetPlane(out var boundaryPlane, Revit.VertexTolerance) || !boundaryPlane.ZAxis.IsPerpendicularTo(Rhino.Geometry.Vector3d.ZAxis) ) { ThrowArgumentException(nameof(boundary), "Boundary must be a vertical planar closed curve."); } } SolveOptionalType(ref type, doc, DB.ElementTypeGroup.WallType, nameof(type)); SolveOptionalLevel(doc, profile, ref level, out var bbox); foreach (var curve in profile) { curve.RemoveShortSegments(Revit.ShortCurveTolerance * Revit.ModelUnits); } var boundaries = profile.SelectMany(x => GeometryEncoder.ToCurveMany(x)).SelectMany(CurveExtension.ToBoundedCurves).ToList(); // LocationLine if (locationLine != DB.WallLocationLine.WallCenterline) { double offsetDist = 0.0; var compoundStructure = type.Value.GetCompoundStructure(); if (compoundStructure == null) { switch (locationLine) { case DB.WallLocationLine.WallCenterline: case DB.WallLocationLine.CoreCenterline: break; case DB.WallLocationLine.FinishFaceExterior: case DB.WallLocationLine.CoreExterior: offsetDist = type.Value.Width / +2.0; break; case DB.WallLocationLine.FinishFaceInterior: case DB.WallLocationLine.CoreInterior: offsetDist = type.Value.Width / -2.0; break; } } else { if (!compoundStructure.IsVerticallyHomogeneous()) { compoundStructure = DB.CompoundStructure.CreateSimpleCompoundStructure(compoundStructure.GetLayers()); } offsetDist = compoundStructure.GetOffsetForLocationLine(locationLine); } if (offsetDist != 0.0) { profile[0].TryGetPlane(out var plane); var translation = DB.Transform.CreateTranslation((plane.Normal * (flipped ? -offsetDist : offsetDist)).ToXYZ()); for (int b = 0; b < boundaries.Count; ++b) { boundaries[b] = boundaries[b].CreateTransformed(translation); } } } var newWall = DB.Wall.Create ( doc, boundaries, type.Value.Id, level.Value.Id, structuralUsage != DB.Structure.StructuralWallUsage.NonBearing ); // Walls are created with the last LocationLine used in the Revit editor!! //newWall.get_Parameter(BuiltInParameter.WALL_KEY_REF_PARAM).Set((int) WallLocationLine.WallCenterline); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.WALL_KEY_REF_PARAM, DB.BuiltInParameter.WALL_USER_HEIGHT_PARAM, DB.BuiltInParameter.WALL_BASE_CONSTRAINT, DB.BuiltInParameter.WALL_BASE_OFFSET, DB.BuiltInParameter.WALL_STRUCTURAL_SIGNIFICANT, DB.BuiltInParameter.WALL_STRUCTURAL_USAGE_PARAM }; ReplaceElement(ref element, newWall, parametersMask); if (newWall != null) { newWall.get_Parameter(DB.BuiltInParameter.WALL_BASE_CONSTRAINT).Set(level.Value.Id); newWall.get_Parameter(DB.BuiltInParameter.WALL_BASE_OFFSET).Set(bbox.Min.Z / Revit.ModelUnits - level.Value.Elevation); newWall.get_Parameter(DB.BuiltInParameter.WALL_KEY_REF_PARAM).Set((int)locationLine); if (structuralUsage == DB.Structure.StructuralWallUsage.NonBearing) { newWall.get_Parameter(DB.BuiltInParameter.WALL_STRUCTURAL_SIGNIFICANT).Set(0); } else { newWall.get_Parameter(DB.BuiltInParameter.WALL_STRUCTURAL_SIGNIFICANT).Set(1); newWall.get_Parameter(DB.BuiltInParameter.WALL_STRUCTURAL_USAGE_PARAM).Set((int)structuralUsage); } if (newWall.Flipped != flipped) { newWall.Flip(); } // Setup joins in a last step if (allowJoins) { joinedWalls.Add(newWall); } else { DB.WallUtils.DisallowWallJoinAtEnd(newWall, 0); DB.WallUtils.DisallowWallJoinAtEnd(newWall, 1); } } }
void ReconstructFamilyInstanceByLocation ( DB.Document doc, ref DB.FamilyInstance element, [Description("Location where to place the element. Point or plane is accepted.")] Rhino.Geometry.Plane location, DB.FamilySymbol type, Optional <DB.Level> level, [Optional] DB.Element host ) { var scaleFactor = 1.0 / Revit.ModelUnits; location = location.ChangeUnits(scaleFactor); if (!location.IsValid) { ThrowArgumentException(nameof(location), "Should be a valid point or plane."); } SolveOptionalLevel(doc, location.Origin, ref level, out var bbox); if (host == null && type.Family.FamilyPlacementType == DB.FamilyPlacementType.OneLevelBasedHosted) { ThrowArgumentException(nameof(host), $"This family requires a host."); } if (!type.IsActive) { type.Activate(); } ChangeElementTypeId(ref element, type.Id); bool hasSameHost = false; if (element is DB.FamilyInstance) { hasSameHost = (element.Host?.Id ?? DB.ElementId.InvalidElementId) == (host?.Id ?? DB.ElementId.InvalidElementId); if (element.Host == null) { if (element?.get_Parameter(DB.BuiltInParameter.INSTANCE_FREE_HOST_PARAM) is DB.Parameter freeHostParam) { var freeHostName = freeHostParam.AsString(); hasSameHost = freeHostName.EndsWith(host?.Name ?? level.Value.Name); } } } if ( hasSameHost && element is DB.FamilyInstance && element.Location is DB.LocationPoint locationPoint ) { using (var levelParam = element.get_Parameter(DB.BuiltInParameter.FAMILY_LEVEL_PARAM)) { if (levelParam.AsElementId() != level.Value.Id) { levelParam.Set(level.Value.Id); doc.Regenerate(); } } if (host is object) { var newOrigin = location.Origin.ToHost(); if (!newOrigin.IsAlmostEqualTo(locationPoint.Point)) { element.Pinned = false; locationPoint.Point = newOrigin; element.Pinned = true; } } } else { var creationData = new List <Autodesk.Revit.Creation.FamilyInstanceCreationData>() { new Autodesk.Revit.Creation.FamilyInstanceCreationData(location.Origin.ToHost(), type, host, level.Value, DB.Structure.StructuralType.NonStructural) }; var newElementIds = doc.IsFamilyDocument ? doc.FamilyCreate.NewFamilyInstances2(creationData) : doc.Create.NewFamilyInstances2(creationData); if (newElementIds.Count != 1) { doc.Delete(newElementIds); throw new InvalidOperationException(); } var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM, DB.BuiltInParameter.FAMILY_LEVEL_PARAM }; ReplaceElement(ref element, doc.GetElement(newElementIds.First()) as DB.FamilyInstance, parametersMask); doc.Regenerate(); } if (element is object && element.Host is null) { element.Pinned = false; element.SetTransform(location.Origin.ToHost(), location.XAxis.ToHost(), location.YAxis.ToHost()); element.Pinned = true; } }
public APIAssetBuiltInPropAttribute(DB.BuiltInParameter paramId, Type type, bool exclusive = false) { ParamId = paramId; DataType = type; Exclusive = exclusive; }
void ReconstructView3DByPlane ( DB.Document doc, ref DB.View3D view, Rhino.Geometry.Plane plane, Optional <DB.ElementType> type, Optional <string> name, Optional <bool> perspective ) { SolveOptionalType(ref type, doc, DB.ElementTypeGroup.ViewType3D, nameof(type)); var orientation = new DB.ViewOrientation3D ( plane.Origin.ToXYZ(), plane.YAxis.ToXYZ(), plane.ZAxis.ToXYZ() ); if (view is null) { var newView = perspective.IsNullOrMissing ? DB.View3D.CreatePerspective ( doc, type.Value.Id ) : DB.View3D.CreateIsometric ( doc, type.Value.Id ); var parametersMask = new DB.BuiltInParameter[] { DB.BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM, DB.BuiltInParameter.ELEM_FAMILY_PARAM, DB.BuiltInParameter.ELEM_TYPE_PARAM }; newView.SetOrientation(orientation); view.get_Parameter(DB.BuiltInParameter.VIEWER_CROP_REGION).Set(0); ReplaceElement(ref view, newView, parametersMask); } else { view.SetOrientation(orientation); if (perspective.HasValue) { view.get_Parameter(DB.BuiltInParameter.VIEWER_PERSPECTIVE).Set(perspective.Value ? 1 : 0); } ChangeElementTypeId(ref view, type.Value.Id); } if (name.HasValue && view is object) { try { view.Name = name.Value; } catch (Autodesk.Revit.Exceptions.ArgumentException e) { AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, $"{e.Message.Replace($".{Environment.NewLine}", ". ")}"); } } }
public static IDictionary MergeElementTypes(DynaElem FromType, DynaElem ToType) { // Name of Transaction string transactionName = "Merge Element Type"; // Get the Revit elements from the Dynamo Elements RevitDB.ElementType rFromType = (RevitDB.ElementType)FromType.InternalElement; RevitDB.ElementType rToType = (RevitDB.ElementType)ToType.InternalElement; RevitDoc document = rToType.Document; // Collect all instances of FromType RevitDB.FilteredElementCollector collector = new RevitDB.FilteredElementCollector(document); RevitDB.BuiltInParameter parameterId = RevitDB.BuiltInParameter.ELEM_TYPE_PARAM; RevitDB.FilterNumericEquals filterNumberRule = new RevitDB.FilterNumericEquals(); RevitDB.ParameterValueProvider provider = new RevitDB.ParameterValueProvider(new RevitDB.ElementId(parameterId)); RevitDB.FilterRule filterRule = new RevitDB.FilterElementIdRule(provider, filterNumberRule, rFromType.Id); RevitDB.ElementFilter filterParameter = new RevitDB.ElementParameterFilter(filterRule, false); Type instanceType = Select.InstanceClassFromTypeClass(rFromType.GetType()); if (instanceType != null) { collector.OfClass(instanceType); } IEnumerable <RevitDB.Element> instances = collector .WhereElementIsNotElementType() .WherePasses(filterParameter) .ToElements(); // Intialize list for elements that are successfully merged and failed to merge. List <DynaElem> elements = new List <DynaElem>(); List <DynaElem> elementsFailed = new List <DynaElem>(); // Define Function to change instances types. Action <IEnumerable <RevitDB.Element> > _SetType = (isntances) => { foreach (RevitDB.Element elem in instances) { // If Element is in a group, put the element in the failed list int groupId = elem.GroupId.IntegerValue; if (groupId == -1) { //elem.TextNoteType = rToType; RevitDB.Parameter param = elem.get_Parameter(RevitDB.BuiltInParameter.ELEM_TYPE_PARAM); param.Set(rToType.Id); DynaElem dElem = elem.ToDSType(true); elements.Add(dElem); } else { DynaElem dElem = elem.ToDSType(true); elementsFailed.Add(dElem); } } // Check if there are any instances of FromType left int count = collector.Count(); if (count == 0) { document.Delete(rFromType.Id); } }; if (document.IsModifiable) { TransactionManager.Instance.EnsureInTransaction(document); _SetType(instances); TransactionManager.Instance.TransactionTaskDone(); } else { using (Autodesk.Revit.DB.Transaction trans = new Autodesk.Revit.DB.Transaction(document)) { trans.Start(transactionName); _SetType(instances); trans.Commit(); } } return(new Dictionary <string, object> { { "Merged", elements }, { "Failed", elementsFailed } }); }