internal static Space FromExisting(Autodesk.Revit.DB.Mechanical.Space instance, bool isRevitOwned)
{
return(new Space(instance)
{
IsRevitOwned = isRevitOwned
});
}
/// <summary>
/// Create a space from an existing reference
/// </summary>
/// <param name="space"></param>
/// <param name="isRevitOwned"></param>
/// <returns></returns>
internal static Space FromExisting(DB.Mechanical.Space space, bool isRevitOwned)
{
return(new Space(space)
{
//IsRevitOwned = isRevitOwned
});
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
bool run = false;
if (!dataAccess.GetData(2, ref run) || !run)
{
return;
}
ConvertSettings convertSettings = null;
dataAccess.GetData(1, ref convertSettings);
convertSettings = this.UpdateSolutionEndEventHandler(convertSettings);
Space space = null;
if (!dataAccess.GetData(0, ref space))
{
return;
}
Document document = RhinoInside.Revit.Revit.ActiveDBDocument;
Core.Revit.Modify.RemoveExisting(convertSettings, document, space);
Autodesk.Revit.DB.Mechanical.Space space_Revit = Analytical.Revit.Convert.ToRevit(space, document, convertSettings);
dataAccess.SetData(0, space_Revit);
}
public static void AssignRequiredPressurization(RevitSpace space)
{
var spaceType = SpacePropertyService.GetSpaceTypeAsString(space);
var press = VentilationLookupService.GetRequirePressurizationBasedOnOccupancy(spaceType);
space.SetParameterValue("PRESSURIZATION_REQ", press.ToString());
}
/// <summary>
/// Always VENT
/// </summary>
/// <param name="space"></param>
public static void AssignOAACHRBasedOnCategory(RevitSpace space)
{
var spaceType = SpacePropertyService.GetSpaceTypeAsString(space);
var oaachr = VentilationLookupService.GetOAACHRBasedOnOccupancyCategory(spaceType);
space.SetParameterValue("OAACHR", oaachr.ToString());
}
/// <summary>
/// Set the internal Element, ElementId, and UniqueId
/// </summary>
/// <param name="space"></param>
private void InternalSetSpace(DB.Mechanical.Space space)
{
InternalSpace = space;
InternalElementId = space.Id;
InternalUniqueId = space.UniqueId;
InternalBoundarySegments = GetBoundarySegment();
InternalTransform = GetTransform();
}
public static void AssignOAACHMBasedOnCategory(RevitSpace space)
{
var factory = new SpaceConversionFactory();
var spaceType = SpacePropertyService.GetSpaceTypeAsString(space);
var dSpace = factory.Create(space);
var oaachm = VentilationCalculationService.CalculateCFMBasedOnSupplyACH(dSpace);
space.SetParameterValue("OAACHM", oaachm.ToString());
}
public static void AssignModeledPressurization(RevitSpace space)
{
var factory = new SpaceConversionFactory();
var spaceType = SpacePropertyService.GetSpaceTypeAsString(space);
var dSpace = factory.Create(space);
var press = VentilationCalculationService.CalculateModeledPressurization(dSpace);
space.SetParameterValue("PRESSURIZATION_MOD", press.ToString());
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, Zone zone, Document document, ConvertSettings convertSettings)
{
if (adjacencyCluster == null || zone == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(zone.Guid);
if (result != null)
{
return(result);
}
Zone zone_Temp = adjacencyCluster.GetObject <Zone>(zone.Guid);
if (zone_Temp == null)
{
zone_Temp = zone;
}
if (convertSettings.ConvertParameters)
{
List <Space> spaces = adjacencyCluster.GetSpaces(zone_Temp);
if (spaces != null)
{
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Revit = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
foreach (Space space in spaces)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space);
if (space_Revit == null)
{
string name = space.Name;
if (name != null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == name);
}
}
if (space_Revit == null)
{
continue;
}
Core.Revit.Modify.SetValues(space_Revit, zone_Temp);
Core.Revit.Modify.SetValues(space_Revit, zone_Temp, ActiveSetting.Setting);
}
}
}
convertSettings?.Add(zone.Guid, result);
return(result);
}
public static Autodesk.Revit.DB.Mechanical.Space ToRevit(this Space space, Document document, ConvertSettings convertSettings)
{
if (space == null)
{
return(null);
}
Autodesk.Revit.DB.Mechanical.Space result = convertSettings?.GetObject <Autodesk.Revit.DB.Mechanical.Space>(space.Guid);
if (result != null)
{
return(result);
}
if (!convertSettings.RemoveExisting)
{
result = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space);
}
if (result == null)
{
double lowElevation = Query.LowElevation(space);
if (double.IsNaN(lowElevation))
{
return(null);
}
Level level = Geometry.Revit.Query.LowLevel(document, lowElevation);
if (level == null)
{
return(null);
}
result = document.Create.NewSpace(level, new UV(UnitUtils.ConvertToInternalUnits(space.Location.X, DisplayUnitType.DUT_METERS), UnitUtils.ConvertToInternalUnits(space.Location.Y, DisplayUnitType.DUT_METERS)));
}
if (result == null)
{
return(null);
}
result.get_Parameter(BuiltInParameter.ROOM_NAME).Set(space.Name);
if (convertSettings.ConvertParameters)
{
Core.Revit.Modify.SetValues(result, space);
Core.Revit.Modify.SetValues(result, space, ActiveSetting.Setting);
Core.Revit.Modify.SetJson(result, space.ToJObject()?.ToString());
}
convertSettings?.Add(space.Guid, result);
return(result);
}
/***************************************************/
public static bool SetLocation(this Autodesk.Revit.DB.Mechanical.Space revitSpace, Space bHoMSpace, RevitSettings settings)
{
Level level = revitSpace.Document.LevelBelow(bHoMSpace.Location, settings);
if (level == null)
{
return(false);
}
oM.Geometry.Point point = BH.Engine.Geometry.Create.Point(bHoMSpace.Location.X, bHoMSpace.Location.Y, level.Elevation);
return(revitSpace.SetLocation(point, settings));
}
public static Space ToSpeckle(this Autodesk.Revit.DB.Mechanical.Space mySpace)
{
var speckleSpace = new SpeckleElementsClasses.Space();
//Name & number
speckleSpace.spaceName = mySpace.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.ROOM_NAME).AsString();
speckleSpace.spaceNumber = mySpace.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.ROOM_NUMBER).AsString();
//Location
var locPt = ((Autodesk.Revit.DB.LocationPoint)mySpace.Location).Point;
speckleSpace.spaceLocation = new SpecklePoint(locPt.X / Scale, locPt.Y / Scale, locPt.Z / Scale);
//speckleSpace.levelElementId = mySpace.LevelId.IntegerValue.ToString();
//speckleSpace.phaseElementId = mySpace.GetParameters("Phase Id").FirstOrDefault().AsElementId().ToString();
//3d geometry
(speckleSpace.Faces, speckleSpace.Vertices) = GetFaceVertexArrayFromElement(mySpace);
//2d boundary curve
var seg = mySpace.GetBoundarySegments(new Autodesk.Revit.DB.SpatialElementBoundaryOptions());
var myPolyCurve = new SpecklePolycurve()
{
Segments = new List <SpeckleCore.SpeckleObject>()
};
foreach (BoundarySegment segment in seg[0])
{
var crv = segment.GetCurve();
var converted = SpeckleCore.Converter.Serialise(crv);
myPolyCurve.Segments.Add(converted as SpeckleObject);
}
speckleSpace.baseCurve = myPolyCurve;
//parameters
speckleSpace.parameters = GetElementParams(mySpace);
//try get type parameters
if (mySpace.IsValidType(mySpace.GetTypeId()))
{
speckleSpace.typeParameters = GetElementTypeParams(mySpace);
}
//global parameters
speckleSpace.ApplicationId = mySpace.UniqueId;
speckleSpace.elementId = mySpace.Id.ToString();
speckleSpace.GenerateHash();
return(speckleSpace);
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
int index = -1;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run) || !run)
{
return;
}
ConvertSettings convertSettings = null;
index = Params.IndexOfInputParam("_convertSettings_");
if (index != -1)
{
dataAccess.GetData(index, ref convertSettings);
}
convertSettings = this.UpdateSolutionEndEventHandler(convertSettings);
Space space = null;
index = Params.IndexOfInputParam("_space");
if (index == -1 || !dataAccess.GetData(index, ref space))
{
return;
}
Document document = RhinoInside.Revit.Revit.ActiveDBDocument;
StartTransaction(document);
Core.Revit.Modify.RemoveExisting(convertSettings, document, space);
Autodesk.Revit.DB.Mechanical.Space space_Revit = Analytical.Revit.Convert.ToRevit(space, document, convertSettings);
index = Params.IndexOfOutputParam("space");
if (index != -1)
{
dataAccess.SetData(index, space_Revit);
}
}
public bool CanConvertToSpeckle(object @object)
{
return(@object
switch
{
DB.DetailCurve _ => true,
DB.DirectShape _ => true,
DB.FamilyInstance _ => true,
DB.Floor _ => true,
DB.Level _ => true,
DB.View _ => true,
DB.ModelCurve _ => true,
DB.Opening _ => true,
DB.RoofBase _ => true,
DB.Area _ => true,
DB.Architecture.Room _ => true,
DB.Architecture.TopographySurface _ => true,
DB.Wall _ => true,
DB.Mechanical.Duct _ => true,
DB.Mechanical.Space _ => true,
DB.Plumbing.Pipe _ => true,
DB.Electrical.Wire _ => true,
DB.CurtainGridLine _ => true, //these should be handled by curtain walls
DB.Architecture.BuildingPad _ => true,
DB.Architecture.Stairs _ => true,
DB.Architecture.StairsRun _ => true,
DB.Architecture.StairsLanding _ => true,
DB.Architecture.Railing _ => true,
DB.Architecture.TopRail _ => true,
DB.Ceiling _ => true,
DB.PointCloudInstance _ => true,
DB.Group _ => true,
DB.ProjectInfo _ => true,
DB.ElementType _ => true,
DB.Grid _ => true,
DB.ReferencePoint _ => true,
DB.Structure.AnalyticalModelStick _ => true,
DB.Structure.AnalyticalModelSurface _ => true,
DB.Structure.BoundaryConditions _ => true,
_ => (@object as Element).IsElementSupported()
});
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static Autodesk.Revit.DB.Mechanical.Space ToRevitSpace(this Space space, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
if (space == null)
{
return(null);
}
Autodesk.Revit.DB.Mechanical.Space revitSpace = refObjects.GetValue <Autodesk.Revit.DB.Mechanical.Space>(document, space.BHoM_Guid);
if (revitSpace != null)
{
return(revitSpace);
}
settings = settings.DefaultIfNull();
Level level = document.LevelBelow(space.Location, settings);
if (level == null)
{
return(null);
}
UV uv = new UV(space.Location.X.FromSI(UnitType.UT_Length), space.Location.Y.FromSI(UnitType.UT_Length));
revitSpace = document.Create.NewSpace(level, uv);
revitSpace.CheckIfNullPush(space);
if (revitSpace == null)
{
return(null);
}
revitSpace.Name = space.Name;
// Copy parameters from BHoM object to Revit element
revitSpace.CopyParameters(space, settings);
refObjects.AddOrReplace(space, revitSpace);
return(revitSpace);
}
public static Autodesk.Revit.DB.Mechanical.Space ToNative(this SpeckleElementsClasses.Space mySpace)
{
// Creation of space boundary, not necessary
//CurveArray curveArr = new CurveArray();
//SpecklePolycurve myPolyCurve = (SpecklePolycurve)mySpace.baseCurve;
//foreach (SpeckleObject segment in myPolyCurve.Segments)
//{
// var converted = SpeckleCore.Converter.Deserialise(segment);
// curveArr.Append(converted as Autodesk.Revit.DB.Curve);
//}
//ModelCurveArray crArr = Doc.Create.NewSpaceBoundaryLines(Doc.ActiveView.SketchPlane, curveArr, Doc.ActiveView);
// Get element level
ElementId elemLevelId = new ElementId(Int32.Parse(mySpace.levelElementId));
Autodesk.Revit.DB.Level level = Doc.GetElement(elemLevelId) as Autodesk.Revit.DB.Level;
// Get element phase
ElementId elemPhaseId = new ElementId(Int32.Parse(mySpace.phaseElementId));
Phase phase = Doc.GetElement(elemPhaseId) as Phase;
//Get element location point
Autodesk.Revit.DB.UV locPoint = new Autodesk.Revit.DB.UV(mySpace.spaceLocation.Value[0] * Scale, mySpace.spaceLocation.Value[1] * Scale);
//TODO: check view fro space creation - must be FloorPlan
//if (Doc.ActiveView.ViewType == Autodesk.Revit.DB.ViewType.FloorPlan)
// Create Revit space
Autodesk.Revit.DB.Mechanical.Space revitSpace = Doc.Create.NewSpace(level, phase, locPoint);
//Set element parameters
//TODO: Check if all parameters set up
SetElementParams(revitSpace, mySpace.parameters);
//Add space tag (if one been loaded to project)
Autodesk.Revit.DB.Mechanical.SpaceTag tag = Doc.Create.NewSpaceTag(revitSpace, locPoint, Doc.ActiveView);
return(revitSpace);
}
/// <summary>
/// Set internal element
/// </summary>
private void InitElement(Autodesk.Revit.DB.Mechanical.Space element)
{
InternalSetElement(element);
}
/// <summary>
/// Create from existing element
/// </summary>
/// <param name="space"></param>
internal Space(Autodesk.Revit.DB.Mechanical.Space space)
{
SafeInit(() => InitElement(space));
}
/// <summary>
/// Set the internal Element, ElementId, and UniqueId
/// </summary>
private void InternalSetElement(Autodesk.Revit.DB.Mechanical.Space element)
{
InternalRevitElement = element;
InternalElementId = element.Id;
InternalUniqueId = element.UniqueId;
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, ZoneSimulationResult zoneSimulationResult, Document document, ConvertSettings convertSettings)
{
if (adjacencyCluster == null || zoneSimulationResult == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(zoneSimulationResult.Guid);
if (result != null)
{
return(result);
}
ZoneSimulationResult zoneSimulationResult_Temp = adjacencyCluster.GetObject <ZoneSimulationResult>(zoneSimulationResult.Guid);
if (zoneSimulationResult_Temp == null)
{
zoneSimulationResult_Temp = zoneSimulationResult;
}
List <Zone> zones = adjacencyCluster.GetRelatedObjects <Zone>(zoneSimulationResult_Temp);
if (zones != null && zones.Count != 0)
{
if (convertSettings.ConvertParameters)
{
foreach (Zone zone in zones)
{
List <Space> spaces = adjacencyCluster.GetSpaces(zone);
if (spaces != null)
{
ZoneType zoneType = zone.ZoneType();
if (zoneType == ZoneType.Undefined)
{
continue;
}
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Revit = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
foreach (Space space_SAM in spaces)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, zoneSimulationResult_Temp);
if (space_Revit == null)
{
space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space_SAM);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == space_SAM.Name);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => space_SAM.Name.EndsWith(x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString()) && space_SAM.Name.StartsWith(x.get_Parameter(BuiltInParameter.ROOM_NUMBER)?.AsString()));
}
if (space_Revit == null)
{
continue;
}
Core.Revit.Modify.SetValues(space_Revit, zoneSimulationResult);
Core.Revit.Modify.SetValues(space_Revit, zoneSimulationResult, ActiveSetting.Setting);
Modify.SetValues(space_Revit, zoneSimulationResult, ActiveSetting.Setting, zoneType, convertSettings?.GetParameters());
}
}
}
}
}
convertSettings?.Add(zoneSimulationResult.Guid, result);
return(result);
}
/// <summary>
/// Create from an existing Revit Element
/// </summary>
/// <param name="space">An existing Revit space</param>
private Space(DB.Mechanical.Space space)
{
SafeInit(() => InitSpace(space));
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
int index = -1;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run) || !run)
{
return;
}
Element element = null;
index = Params.IndexOfInputParam("_element");
if (index == -1 || !dataAccess.GetData(index, ref element))
{
return;
}
Transform transform;
if (element == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
StartTransaction(element.Document);
bool successful = false;
if (element is Autodesk.Revit.DB.Wall)
{
List <Level> levels = new FilteredElementCollector(element.Document).OfClass(typeof(Level)).Cast <Level>().ToList();
if (levels != null && levels.Count != 0)
{
BoundingBoxXYZ boundingBoxXYZ = element.get_BoundingBox(null);
if (boundingBoxXYZ != null)
{
Level level = levels.Find(x => x.Elevation.AlmostEqual(boundingBoxXYZ.Max.Z, Tolerance.MacroDistance));
if (level != null)
{
Autodesk.Revit.DB.Wall wall = (Autodesk.Revit.DB.Wall)element;
Parameter parameter = wall.get_Parameter(BuiltInParameter.WALL_HEIGHT_TYPE);
if (parameter != null)
{
successful = parameter.Set(level.Id);
}
}
}
}
}
else if (element is Autodesk.Revit.DB.Mechanical.Space)
{
List <Level> levels = new FilteredElementCollector(element.Document).OfClass(typeof(Level)).Cast <Level>().ToList();
if (levels != null && levels.Count != 0)
{
Autodesk.Revit.DB.Mechanical.Space space = (Autodesk.Revit.DB.Mechanical.Space)element;
double elevation = space.UnboundedHeight + levels.Find(x => x.Id == space.LevelId).Elevation;
Level level = levels.Find(x => x.Elevation.AlmostEqual(elevation, Tolerance.MacroDistance));
if (level != null)
{
Parameter parameter = space.get_Parameter(BuiltInParameter.ROOM_UPPER_LEVEL);
if (parameter != null)
{
if (parameter.AsElementId() != level.Id)
{
successful = parameter.Set(level.Id);
parameter = space.get_Parameter(BuiltInParameter.ROOM_UPPER_OFFSET);
if (parameter != null)
{
parameter.Set(0.0);
}
}
}
}
}
}
index = Params.IndexOfOutputParam("element");
if (index != -1)
{
dataAccess.SetData(index, element);
}
index = Params.IndexOfOutputParam("successful");
if (index != -1)
{
dataAccess.SetData(index, successful);
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="dataAccess">
/// The DA object is used to retrieve from inputs and store in outputs.
/// </param>
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
int index = -1;
int index_Successful = -1;
index_Successful = Params.IndexOfOutputParam("successful");
if (index_Successful != -1)
{
dataAccess.SetData(index_Successful, false);
}
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run) || !run)
{
return;
}
Document document = RhinoInside.Revit.Revit.ActiveDBDocument;
RevitLinkInstance revitLinkInstance = null;
index = Params.IndexOfInputParam("_revitLinkInstance");
if (index == -1 || !dataAccess.GetData(index, ref revitLinkInstance) || revitLinkInstance == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
List <Level> levels = new FilteredElementCollector(document).OfClass(typeof(Level)).Cast <Level>().ToList();
if (levels == null || levels.Count == 0)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
StartTransaction(document);
TextMap textMap = null;
index = Params.IndexOfInputParam("_textMap_");
if (index != -1)
{
dataAccess.GetData(index, ref textMap);
}
bool rename = false;
index = Params.IndexOfInputParam("_rename");
if (index == -1 || !dataAccess.GetData(index, ref rename))
{
rename = false;
}
Transform transform = revitLinkInstance.GetTotalTransform();
Document document_Linked = revitLinkInstance.GetLinkDocument();
List <Autodesk.Revit.DB.Mechanical.Space> result = new List <Autodesk.Revit.DB.Mechanical.Space>();
List <Autodesk.Revit.DB.Architecture.Room> rooms = new FilteredElementCollector(document_Linked).OfCategory(BuiltInCategory.OST_Rooms).Cast <Autodesk.Revit.DB.Architecture.Room>().ToList();
if (rooms != null && rooms.Count > 0)
{
foreach (Autodesk.Revit.DB.Architecture.Room room in rooms)
{
LocationPoint locationPoint = room?.Location as LocationPoint;
if (locationPoint == null)
{
continue;
}
XYZ xyz = transform?.OfPoint(locationPoint.Point);
if (xyz == null)
{
continue;
}
double min = double.MaxValue;
Level level = null;
foreach (Level level_Temp in levels)
{
double min_Temp = Math.Abs(level_Temp.Elevation - xyz.Z);
if (min_Temp < min)
{
min = min_Temp;
level = level_Temp;
}
}
if (level == null)
{
continue;
}
Autodesk.Revit.DB.Mechanical.Space space = document.Create.NewSpace(level, new UV(xyz.X, xyz.Y));
if (space == null)
{
continue;
}
if (textMap != null)
{
Core.Revit.Modify.CopyValues(room, space, textMap);
}
if (rename)
{
string name = room.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString();
if (!string.IsNullOrEmpty(name))
{
space.get_Parameter(BuiltInParameter.ROOM_NAME).Set(name);
}
string number = room.get_Parameter(BuiltInParameter.ROOM_NUMBER)?.AsString();
if (!string.IsNullOrEmpty(number))
{
space.get_Parameter(BuiltInParameter.ROOM_NUMBER).Set(number);
}
}
result.Add(space);
}
}
index = Params.IndexOfOutputParam("spaces");
if (index != -1)
{
dataAccess.SetDataList(0, result);
}
if (index_Successful != -1)
{
dataAccess.SetData(index_Successful, result != null && result.Count > 0);
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="dataAccess">
/// The DA object is used to retrieve from inputs and store in outputs.
/// </param>
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
bool run = false;
if (!dataAccess.GetData(2, ref run) || !run)
{
return;
}
bool merge = true;
if (!dataAccess.GetData(1, ref merge))
{
return;
}
GH_ObjectWrapper objectWrapper = null;
if (!dataAccess.GetData(0, ref objectWrapper) || objectWrapper.Value == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
dynamic obj = objectWrapper.Value;
ElementId aId = obj.Id as ElementId;
string message = null;
Document document = obj.Document as Document;
Autodesk.Revit.DB.Mechanical.Space space = document.GetElement(aId) as Autodesk.Revit.DB.Mechanical.Space;
if (space == null)
{
message = "Invalid Element";
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message);
return;
}
if (space.Location == null)
{
message = string.Format("Cannot generate Panels. Space {0} [ElementId: {1}] not enclosed", space.Name, space.Id.IntegerValue);
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message);
return;
}
if (space.Volume < Core.Tolerance.MacroDistance)
{
message = string.Format("Space cannot be converted because it has no volume. Space {0} [ElementId: {1}] not enclosed", space.Name, space.Id.IntegerValue);
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message);
return;
}
ConvertSettings convertSettings = new ConvertSettings(true, true, true);
List <Panel> panels = Analytical.Revit.Create.Panels(space, convertSettings);
if (panels == null || panels.Count == 0)
{
message = "Panels ould not be generated";
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message);
return;
}
panels.RemoveAll(x => x == null);
List <Panel> panels_Temp = new List <Panel>();
foreach (Panel panel in panels)
{
PanelGroup panelGroup = Analytical.Query.PanelGroup(panel.PanelType);
if (panelGroup != PanelGroup.Floor && panelGroup != PanelGroup.Roof)
{
continue;
}
ElementId elementId = panel.ElementId();
if (elementId == null || elementId == ElementId.InvalidElementId)
{
panels_Temp.Add(panel);
continue;
}
HostObject hostObject = document.GetElement(elementId) as HostObject;
if (hostObject == null)
{
panels_Temp.Add(panel);
continue;
}
Geometry.Spatial.Plane plane = panel.PlanarBoundary3D.Plane;
List <Geometry.Spatial.Face3D> face3Ds = Geometry.Revit.Query.Profiles(hostObject);
if (face3Ds == null || face3Ds.Count == 0)
{
panels_Temp.Add(panel);
continue;
}
Geometry.Spatial.Plane plane_Face3D = face3Ds.Find(x => plane.Coplanar(x.GetPlane()))?.GetPlane();
if (plane_Face3D == null)
{
panels_Temp.Add(panel);
continue;
}
Geometry.Spatial.Point3D point3D_Projected = plane_Face3D.Project(plane.Origin);
panel.Move(new Geometry.Spatial.Vector3D(plane.Origin, point3D_Projected));
panels_Temp.Add(panel);
}
List <Panel> redundantPanels = new List <Panel>();
if (merge)
{
panels_Temp = Analytical.Query.MergeCoplanarPanels(panels_Temp, Core.Tolerance.MacroDistance, ref redundantPanels, true, Core.Tolerance.MacroDistance);
}
dataAccess.SetDataList(0, panels_Temp.FindAll(x => Analytical.Query.PanelGroup(x.PanelType) == PanelGroup.Floor));
dataAccess.SetDataList(1, panels_Temp.FindAll(x => Analytical.Query.PanelGroup(x.PanelType) == PanelGroup.Roof));
dataAccess.SetDataList(2, redundantPanels);
}
public static Space Wrap(Autodesk.Revit.DB.Mechanical.Space ele, bool isRevitOwned)
{
return(Space.FromExisting(ele, isRevitOwned));
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
int index = -1;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run) || !run)
{
return;
}
Autodesk.Revit.DB.Mechanical.Space space = null;
index = Params.IndexOfInputParam("_space");
if (index == -1 || !dataAccess.GetData(index, ref space) || space == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
bool successful = false;
List <Autodesk.Revit.DB.Mechanical.Space> spaces = new FilteredElementCollector(space.Document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
spaces?.RemoveAll(x => x.Id == space.Id || x.Level.Elevation <= space.Level.Elevation);
Level level = null;
StartTransaction(space.Document);
if (spaces != null || spaces.Count != 0)
{
List <Geometry.Planar.Face2D> face2Ds = Geometry.Revit.Query.BoundaryFace2Ds(space);
if (face2Ds != null && face2Ds.Count > 0)
{
List <Level> levels_Temp = new List <Level>();
foreach (Autodesk.Revit.DB.Mechanical.Space space_Temp in spaces)
{
List <Geometry.Planar.Face2D> face2Ds_Temp = Geometry.Revit.Query.BoundaryFace2Ds(space_Temp);
if (face2Ds_Temp == null || face2Ds_Temp.Count == 0)
{
continue;
}
Level level_Temp = null;
foreach (Geometry.Planar.Face2D face2D in face2Ds)
{
foreach (Geometry.Planar.Face2D face2D_Temp in face2Ds_Temp)
{
List <Geometry.Planar.Face2D> face2s_Intersection = Geometry.Planar.Query.Intersection(face2D, face2D_Temp);
if (face2s_Intersection == null || face2s_Intersection.Count == 0)
{
continue;
}
face2s_Intersection.RemoveAll(x => x == null || x.GetArea() < Tolerance.MacroDistance);
if (face2Ds.Count > 0)
{
level_Temp = space_Temp.Level;
break;
}
}
if (level_Temp != null)
{
break;
}
}
if (level_Temp != null && levels_Temp.Find(x => x.Id == level_Temp.Id) == null)
{
levels_Temp.Add(level_Temp);
}
}
if (levels_Temp != null && levels_Temp.Count != 0)
{
levels_Temp.Sort((x, y) => x.Elevation.CompareTo(y.Elevation));
level = levels_Temp[0];
}
}
}
if (level == null)
{
BoundingBoxXYZ boundingBoxXYZ = space.get_BoundingBox(null);
if (boundingBoxXYZ != null)
{
List <Level> levels = new FilteredElementCollector(space.Document).OfClass(typeof(Level)).Cast <Level>().ToList();
double elevation = boundingBoxXYZ.Max.Z;
if (levels.Find(x => Math.Abs(x.Elevation - elevation) < Tolerance.Distance) != null)
{
dataAccess.SetData(0, space);
dataAccess.SetData(1, false);
return;
}
}
level = Core.Revit.Query.HighLevel(space.Level);
}
if (level != null)
{
Parameter parameter = space.get_Parameter(BuiltInParameter.ROOM_UPPER_LEVEL);
if (parameter != null)
{
if (parameter.AsElementId() != level.Id)
{
successful = parameter.Set(level.Id);
parameter = space.get_Parameter(BuiltInParameter.ROOM_UPPER_OFFSET);
if (parameter != null)
{
parameter.Set(0.0);
}
}
}
}
index = Params.IndexOfOutputParam("space");
if (index != -1)
{
dataAccess.SetData(index, space);
}
index = Params.IndexOfOutputParam("successful");
if (index != -1)
{
dataAccess.SetData(index, successful);
}
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, SpaceSimulationResult spaceSimulationResult, Document document, ConvertSettings convertSettings)
{
if (spaceSimulationResult == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(spaceSimulationResult.Guid);
if (result != null)
{
return(result);
}
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Revit = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
if (adjacencyCluster != null)
{
List <Space> spaces_SAM = adjacencyCluster.GetRelatedObjects <Space>(spaceSimulationResult);
if (spaces_SAM != null)
{
foreach (Space space_SAM in spaces_SAM)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, spaceSimulationResult);
if (space_Revit == null)
{
space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space_SAM);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == space_SAM.Name);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => space_SAM.Name.EndsWith(x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString()) && space_SAM.Name.StartsWith(x.get_Parameter(BuiltInParameter.ROOM_NUMBER)?.AsString()));
}
if (space_Revit == null)
{
continue;
}
if (result == null)
{
result = new List <Autodesk.Revit.DB.Mechanical.Space>();
}
result.Add(space_Revit);
}
}
}
if (result == null)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, spaceSimulationResult);
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == spaceSimulationResult.Name);
}
if (space_Revit != null)
{
result = new List <Autodesk.Revit.DB.Mechanical.Space>()
{
space_Revit
}
}
;
}
if (result == null)
{
return(result);
}
if (convertSettings.ConvertParameters)
{
foreach (Autodesk.Revit.DB.Mechanical.Space space in result)
{
Core.Revit.Modify.SetValues(space, spaceSimulationResult);
Core.Revit.Modify.SetValues(space, spaceSimulationResult, ActiveSetting.Setting);
Modify.SetValues(space, spaceSimulationResult, ActiveSetting.Setting, spaceSimulationResult.LoadType(), convertSettings?.GetParameters());
}
}
convertSettings?.Add(spaceSimulationResult.Guid, result);
return(result);
}
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, Zone zone, Document document, ConvertSettings convertSettings)
{
if (adjacencyCluster == null || zone == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(zone.Guid);
if (result != null)
{
return(result);
}
Zone zone_Temp = adjacencyCluster.GetObject <Zone>(zone.Guid);
if (zone_Temp == null)
{
zone_Temp = zone;
}
if (convertSettings.ConvertParameters)
{
string zoneParameterName = Query.ZoneParameterName(zone);
ZoneType zoneType = zone.ZoneType();
List <Space> spaces = adjacencyCluster.GetSpaces(zone_Temp);
if (spaces != null)
{
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Revit = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
foreach (Space space_SAM in spaces)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, zone);
if (space_Revit == null)
{
space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space_SAM);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == space_SAM.Name);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => space_SAM.Name.EndsWith(x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString()) && space_SAM.Name.StartsWith(x.get_Parameter(BuiltInParameter.ROOM_NUMBER)?.AsString()));
}
if (space_Revit == null)
{
continue;
}
if (!string.IsNullOrWhiteSpace(zoneParameterName))
{
IEnumerable <Parameter> parameters = space_Revit.GetParameters(zoneParameterName);
if (parameters != null)
{
foreach (Parameter parameter in parameters)
{
if (parameter == null || parameter.IsReadOnly || parameter.StorageType != StorageType.String)
{
continue;
}
parameter.Set(zone.Name);
}
}
}
Core.Revit.Modify.SetValues(space_Revit, zone_Temp);
Core.Revit.Modify.SetValues(space_Revit, zone_Temp, ActiveSetting.Setting);
if (zoneType != ZoneType.Undefined)
{
Modify.SetValues(space_Revit, zone_Temp, ActiveSetting.Setting, zoneType, convertSettings?.GetParameters());
}
}
}
}
convertSettings?.Add(zone.Guid, result);
return(result);
}
/// <summary>
/// Initialize a Space element
/// </summary>
/// <param name="room"></param>
private void InitSpace(DB.Mechanical.Space room)
{
InternalSetSpace(room);
}
public static Autodesk.Revit.DB.Mechanical.Space ToRevit(this Space space, Document document, ConvertSettings convertSettings)
{
if (space == null)
{
return(null);
}
Autodesk.Revit.DB.Mechanical.Space result = convertSettings?.GetObject <Autodesk.Revit.DB.Mechanical.Space>(space.Guid);
if (result != null)
{
return(result);
}
if (!convertSettings.RemoveExisting)
{
result = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space);
}
if (result == null)
{
double lowElevation = Query.LowElevation(space);
if (double.IsNaN(lowElevation))
{
return(null);
}
Level level = Geometry.Revit.Query.LowLevel(document, lowElevation);
if (level == null)
{
return(null);
}
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
result = document.Create.NewSpace(level, new UV(UnitUtils.ConvertToInternalUnits(space.Location.X, DisplayUnitType.DUT_METERS), UnitUtils.ConvertToInternalUnits(space.Location.Y, DisplayUnitType.DUT_METERS)));
#else
result = document.Create.NewSpace(level, new UV(UnitUtils.ConvertToInternalUnits(space.Location.X, UnitTypeId.Meters), UnitUtils.ConvertToInternalUnits(space.Location.Y, UnitTypeId.Meters)));
#endif
}
if (result == null)
{
return(null);
}
//result.get_Parameter(BuiltInParameter.ROOM_NAME).Set(string.Empty);
//result.get_Parameter(BuiltInParameter.ROOM_NUMBER).Set(space.Name);
result.get_Parameter(BuiltInParameter.ROOM_NAME).Set(space.Name);
if (convertSettings.ConvertParameters)
{
Dictionary <string, object> parameters = convertSettings.GetParameters();
InternalCondition internalCondition = space.InternalCondition;
if (internalCondition != null)
{
Core.Revit.Modify.SetValues(result, internalCondition);
Core.Revit.Modify.SetValues(result, internalCondition, ActiveSetting.Setting, parameters);
}
Core.Revit.Modify.SetValues(result, space);
Core.Revit.Modify.SetValues(result, space, ActiveSetting.Setting, parameters);
Core.Revit.Modify.SetJson(result, space.ToJObject()?.ToString());
}
convertSettings?.Add(space.Guid, result);
return(result);
}
