public static List <Panel> SetConstructions(this List <Panel> panels, IConstruction newConstruction, List <string> typeNames = null)
{
List <Panel> clones = new List <Panel>(panels.Select(x => x.DeepClone <Panel>()).ToList());
List <Panel> returnPanels = new List <Panel>();
foreach (Panel p in clones)
{
if (typeNames == null || typeNames.Count() == 0)
{
p.Construction = newConstruction;
}
else
{
OriginContextFragment context = p.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
if (context != null && typeNames.Contains(context.TypeName))
{
p.Construction = newConstruction;
}
}
returnPanels.Add(p);
}
return(returnPanels);
}
public static List <Opening> SetConstructions(this List <Opening> openings, IConstruction newConstruction, List <string> typeNames = null)
{
List <Opening> clones = new List <Opening>(openings.Select(x => x.DeepClone <Opening>()).ToList());
List <Opening> returnOpenings = new List <Opening>();
foreach (Opening o in clones)
{
if (typeNames == null)
{
o.OpeningConstruction = newConstruction;
}
else
{
OriginContextFragment context = o.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
if (context != null && typeNames.Contains(context.TypeName))
{
o.OpeningConstruction = newConstruction;
}
}
returnOpenings.Add(o);
}
return(returnOpenings);
}
public static Space FromGBXML(this GBXML.Space space, GBXMLSettings settings = null)
{
Space bhomS = new oM.Environment.Elements.Space();
bhomS.Name = space.Name;
bhomS.Perimeter = space.PlanarGeoemtry.PolyLoop.FromGBXML();
OriginContextFragment f = new OriginContextFragment();
f.ElementID = space.ID;
bhomS.Fragments.Add(f);
return(bhomS);
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static OriginContextFragment OriginContext(this HostObject hostObject, RevitSettings settings)
{
if (hostObject == null)
{
return(null);
}
OriginContextFragment originContext = new OriginContextFragment();
originContext.ElementID = hostObject.Id.IntegerValue.ToString();
originContext.TypeName = hostObject.FamilyTypeFullName();
originContext.SetProperties(hostObject, settings.ParameterSettings);
originContext.SetProperties(hostObject.Document.GetElement(hostObject.GetTypeId()) as ElementType, settings.ParameterSettings);
return(originContext);
}
public static List <Panel> UniquePanelInstances(this List <Panel> panels)
{
List <Panel> returnPanels = new List <Panel>();
foreach (Panel p in panels)
{
OriginContextFragment o = p.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
if (o != null)
{
Panel testCheck = returnPanels.Where(x => x.FindFragment <OriginContextFragment>(typeof(OriginContextFragment)) != null && x.FindFragment <OriginContextFragment>(typeof(OriginContextFragment)).TypeName == o.TypeName).FirstOrDefault();
if (testCheck == null)
{
returnPanels.Add(p);
}
}
}
return(returnPanels);
}
public static List <Opening> UniqueOpeningInstances(this List <Opening> openings)
{
List <Opening> returnOpenings = new List <Opening>();
foreach (Opening p in openings)
{
OriginContextFragment o = p.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
if (o != null)
{
Opening testCheck = returnOpenings.Where(x => x.FindFragment <OriginContextFragment>(typeof(OriginContextFragment)) != null && x.FindFragment <OriginContextFragment>(typeof(OriginContextFragment)).TypeName == o.TypeName).FirstOrDefault();
if (testCheck == null)
{
returnOpenings.Add(p);
}
}
}
return(returnOpenings);
}
public static List <Panel> SetConstructions(this List <Panel> panels, List <string> typeNames, IConstruction newConstruction)
{
List <Panel> returnPanels = new List <Panel>();
foreach (Panel p in panels)
{
OriginContextFragment context = p.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
if (context == null || !typeNames.Contains(context.TypeName))
{
returnPanels.Add(p);
}
else if (context != null && typeNames.Contains(context.TypeName))
{
p.Construction = newConstruction;
returnPanels.Add(p);
}
}
return(returnPanels);
}
public static List <Opening> SetConstructions(this List <Opening> openings, List <string> typeNames, IConstruction newConstruction)
{
List <Opening> returnOpenings = new List <Opening>();
foreach (Opening o in openings)
{
OriginContextFragment context = o.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
if (context == null || !typeNames.Contains(context.TypeName))
{
returnOpenings.Add(o);
}
else if (context != null && typeNames.Contains(context.TypeName))
{
o.OpeningConstruction = newConstruction;
returnOpenings.Add(o);
}
}
return(returnOpenings);
}
private List <BHE.Space> ReadSpaces(BHX.GBXML gbx, List <string> ids = null)
{
//ToDo - Fix this!
List <BHE.Space> s = new List <BHE.Space>();
if (gbx.Campus != null)
{
foreach (BHX.Building b in gbx.Campus.Building)
{
foreach (BHX.Space space in b.Space)
{
BHE.Space bhomS = new oM.Environment.Elements.Space();
bhomS.Name = space.Name;
OriginContextFragment f = new OriginContextFragment();
f.ElementID = space.ID;
bhomS.Fragments.Add(f);
s.Add(bhomS);
}
}
}
return(s);
}
/***************************************************/
public List <Panel> ReadBuildingElements(List <string> ids = null)
{
TBD.Building building = m_tbdDocument.Building;
List <Panel> buildingElements = new List <Panel>();
int zoneIndex = 0;
TBD.zone zone = null;
while ((zone = building.GetZone(zoneIndex)) != null)
{
int zoneSurfaceIndex = 0;
TBD.zoneSurface zoneSrf = null;
while ((zoneSrf = zone.GetSurface(zoneSurfaceIndex)) != null)
{
//check to exlude tine area
if (zoneSrf.internalArea > 0 || zoneSrf.area > 0.2)
{
buildingElements.Add(zoneSrf.buildingElement.FromTAS(zoneSrf, _tasSettings));
}
zoneSurfaceIndex++;
}
zoneIndex++;
}
//Clean up building elements with openings and constructions
List <Panel> nonOpeningElements = buildingElements.Where(x =>
{
TASPanelData fragment = x.FindFragment <TASPanelData>(typeof(TASPanelData));
return(fragment.PanelIsOpening);
}).ToList();
List <Panel> frameElements = buildingElements.Where(x =>
{
TASPanelData fragment = x.FindFragment <TASPanelData>(typeof(TASPanelData));
return(fragment.PanelIsOpening && fragment.OpeningIsFrame);
}).ToList();
List <Panel> panes = buildingElements.Where(x =>
{
TASPanelData fragment = x.FindFragment <TASPanelData>(typeof(TASPanelData));
return(fragment.PanelIsOpening && !fragment.OpeningIsFrame);
}).ToList();
foreach (Panel element in nonOpeningElements)
{
//Sort out opening construction
OriginContextFragment originContext = element.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
string elementID = (originContext != null ? originContext.ElementID : "");
element.Openings = new List <Opening>();
List <Panel> frames = frameElements.Where(x =>
{
return(x.Openings.Where(y =>
{
TASOpeningData fragment = y.FindFragment <TASOpeningData>(typeof(TASOpeningData));
return fragment.ParentGUID == elementID;
}).Count() > 0);
}).ToList();
foreach (Panel frame in frames)
{
Panel pane = panes.Where(x => (x.FindFragment <OriginContextFragment>(typeof(OriginContextFragment))).TypeName == frame.Name.Replace("frame", "pane")).FirstOrDefault();
if (pane != null)
{
Opening newOpening = new Opening();
newOpening.Edges = frame.ExternalEdges;
newOpening.Fragments = new FragmentSet(pane.Fragments);
string oldname = (newOpening.FindFragment <OriginContextFragment>(typeof(OriginContextFragment))).TypeName;
(newOpening.FindFragment <OriginContextFragment>(typeof(OriginContextFragment))).TypeName = oldname.RemoveStringPart(" -pane");
newOpening.Name = oldname.RemoveStringPart(" -pane");
element.Openings.Add(newOpening);
}
}
}
return(nonOpeningElements);
}
/***************************************************/
/**** Internal Methods ****/
/***************************************************/
internal static oM.Environment.Elements.Panel EnvironmentPanelFromRevit(this Element element, ICurve crv, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
oM.Environment.Elements.Panel panel = refObjects.GetValue <oM.Environment.Elements.Panel>(element.Id);
if (panel != null)
{
return(panel);
}
ElementType elementType = element.Document.GetElement(element.GetTypeId()) as ElementType;
panel = new oM.Environment.Elements.Panel()
{
ExternalEdges = crv.ToEdges(),
Name = element.FamilyTypeFullName(),
};
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = element.Id.IntegerValue.ToString(), TypeName = element.FamilyTypeFullName()
};
originContext.SetProperties(element, settings.ParameterSettings);
originContext.SetProperties(elementType, settings.ParameterSettings);
panel.Fragments.Add(originContext);
PanelAnalyticalFragment panelAnalytical = new PanelAnalyticalFragment();
panelAnalytical.SetProperties(element, settings.ParameterSettings);
panelAnalytical.SetProperties(elementType, settings.ParameterSettings);
panel.Fragments.Add(panelAnalytical);
PanelContextFragment panelContext = new PanelContextFragment();
panelContext.SetProperties(element, settings.ParameterSettings);
panelContext.SetProperties(elementType, settings.ParameterSettings);
panel.Fragments.Add(panelContext);
BuildingResultFragment buildingResults = new BuildingResultFragment();
buildingResults.SetProperties(element, settings.ParameterSettings);
buildingResults.SetProperties(elementType, settings.ParameterSettings);
panel.Fragments.Add(buildingResults);
oM.Environment.Elements.PanelType?panelType = element.Category.PanelType();
if (panelType.HasValue)
{
panel.Type = panelType.Value;
}
else
{
panel.Type = oM.Environment.Elements.PanelType.Undefined;
}
//Set identifiers, parameters & custom data
panel.SetIdentifiers(element);
panel.CopyParameters(element, settings.ParameterSettings);
panel.SetProperties(element, settings.ParameterSettings);
refObjects.AddOrReplace(element.Id, panel);
return(panel);
}
/***************************************************/
internal static oM.Environment.Elements.Panel EnvironmentPanelFromRevit(this EnergyAnalysisSurface energyAnalysisSurface, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
oM.Environment.Elements.Panel panel = refObjects.GetValue <oM.Environment.Elements.Panel>(energyAnalysisSurface.Id);
if (panel != null)
{
return(panel);
}
//Get the geometry Curve
ICurve curve = null;
if (energyAnalysisSurface != null)
{
curve = energyAnalysisSurface.GetPolyloop().FromRevit();
}
//Get the name and element type
Element element = energyAnalysisSurface.Document.Element(energyAnalysisSurface.CADObjectUniqueId, energyAnalysisSurface.CADLinkUniqueId);
ElementType elementType = null;
if (element == null)
{
return(panel);
}
elementType = element.Document.GetElement(element.GetTypeId()) as ElementType;
panel = new oM.Environment.Elements.Panel()
{
ExternalEdges = curve.ToEdges(),
Name = element.FamilyTypeFullName(),
};
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = element.Id.IntegerValue.ToString(), TypeName = element.FamilyTypeFullName()
};
originContext.SetProperties(element, settings.ParameterSettings);
originContext.SetProperties(elementType, settings.ParameterSettings);
panel.AddFragment(originContext);
PanelAnalyticalFragment panelAnalytical = new PanelAnalyticalFragment();
panelAnalytical.SetProperties(elementType, settings.ParameterSettings);
panelAnalytical.SetProperties(element, settings.ParameterSettings);
panel.AddFragment(panelAnalytical);
PanelContextFragment panelContext = new PanelContextFragment();
List <string> connectedSpaces = new List <string>();
EnergyAnalysisSpace energyAnalysisSpace = null;
energyAnalysisSpace = energyAnalysisSurface.GetAnalyticalSpace();
if (energyAnalysisSpace != null)
{
SpatialElement spatialElement = energyAnalysisSpace.Document.Element(energyAnalysisSpace.CADObjectUniqueId) as SpatialElement;
connectedSpaces.Add(Query.Name(spatialElement));
}
energyAnalysisSpace = energyAnalysisSurface.GetAdjacentAnalyticalSpace();
if (energyAnalysisSpace != null)
{
SpatialElement spatialElement = energyAnalysisSpace.Document.Element(energyAnalysisSpace.CADObjectUniqueId) as SpatialElement;
if (spatialElement != null)
{
connectedSpaces.Add(Query.Name(spatialElement));
if (spatialElement is Autodesk.Revit.DB.Mechanical.Space)
{
Autodesk.Revit.DB.Mechanical.Space space = (Autodesk.Revit.DB.Mechanical.Space)spatialElement;
BuildingResultFragment buildingResultsProperties = new BuildingResultFragment();
buildingResultsProperties.PeakCooling = space.DesignCoolingLoad.ToSI(UnitType.UT_HVAC_Cooling_Load);
buildingResultsProperties.PeakHeating = space.DesignHeatingLoad.ToSI(UnitType.UT_HVAC_Heating_Load);
panel.AddFragment(buildingResultsProperties);
}
}
}
panel.ConnectedSpaces = connectedSpaces;
panelContext.SetProperties(elementType, settings.ParameterSettings);
panelContext.SetProperties(element, settings.ParameterSettings);
panel.AddFragment(panelContext);
oM.Environment.Elements.PanelType?panelType = element.Category.PanelType();
if (panelType.HasValue)
{
panel.Type = panelType.Value;
}
else
{
panel.Type = oM.Environment.Elements.PanelType.Undefined;
}
panel.Construction = Convert.ConstructionFromRevit(elementType as dynamic, null, settings, refObjects);
//Set identifiers, parameters & custom data
panel.SetIdentifiers(element);
panel.CopyParameters(element, settings.ParameterSettings);
panel.SetProperties(element, settings.ParameterSettings);
refObjects.AddOrReplace(energyAnalysisSurface.Id, panel);
return(panel);
}
/***************************************************/
public static Space SpaceFromRevit(this SpatialElement spatialElement, SpatialElementGeometryCalculator spatialElementGeometryCalculator, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
if (spatialElement == null || spatialElementGeometryCalculator == null)
{
return(new Space());
}
settings = settings.DefaultIfNull();
Space space = refObjects.GetValue <Space>(spatialElement.Id);
if (space != null)
{
return(space);
}
//Create the Space
space = new Space();
space.Name = Query.Name(spatialElement);
PolyCurve pcurve = spatialElement.Perimeter(settings).FirstOrDefault();
if (pcurve != null)
{
space.Location = pcurve.Centroid();
space.Perimeter = pcurve;
}
else if (spatialElement.Location != null && spatialElement.Location is LocationPoint)
{
space.Location = ((LocationPoint)spatialElement.Location).FromRevit();
}
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = spatialElement.Id.IntegerValue.ToString(), TypeName = Query.Name(spatialElement)
};
originContext.SetProperties(spatialElement, settings.ParameterSettings);
space.AddFragment(originContext);
SpaceAnalyticalFragment spaceAnalytical = new SpaceAnalyticalFragment();
spaceAnalytical.SetProperties(spatialElement, settings.ParameterSettings);
space.AddFragment(spaceAnalytical);
SpaceContextFragment spaceContext = new SpaceContextFragment();
spaceContext.SetProperties(spatialElement, settings.ParameterSettings);
//TODO: Implement ConnectedElements
space.AddFragment(spaceContext);
//Set identifiers, parameters & custom data
space.SetIdentifiers(spatialElement);
space.CopyParameters(spatialElement, settings.ParameterSettings);
space.SetProperties(spatialElement, settings.ParameterSettings);
refObjects.AddOrReplace(spatialElement.Id, space);
return(space);
}
/***************************************************/
public static Space SpaceFromRevit(this EnergyAnalysisSpace energyAnalysisSpace, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
if (energyAnalysisSpace == null)
{
return(new Space());
}
settings = settings.DefaultIfNull();
Space space = refObjects.GetValue <Space>(energyAnalysisSpace.Id.IntegerValue);
if (space != null)
{
return(space);
}
SpatialElement spatialElement = energyAnalysisSpace.Document.Element(energyAnalysisSpace.CADObjectUniqueId) as SpatialElement;
if (spatialElement == null)
{
return(space); //If we can't get data from it let's not waste our time
}
space = new Space();
space.Name = Query.Name(spatialElement);
Polyline pline = energyAnalysisSpace.GetBoundary().Select(x => x.FromRevit()).ToList().Join().FirstOrDefault();
if (pline != null)
{
space.Location = pline.Centroid();
space.Perimeter = pline;
}
else if (spatialElement != null && spatialElement.Location != null)
{
space.Location = (spatialElement.Location as LocationPoint).FromRevit();
}
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = spatialElement.Id.IntegerValue.ToString(), TypeName = Query.Name(spatialElement)
};
originContext.SetProperties(energyAnalysisSpace, settings.ParameterSettings);
originContext.SetProperties(spatialElement, settings.ParameterSettings);
space.AddFragment(originContext);
SpaceAnalyticalFragment spaceAnalytical = new SpaceAnalyticalFragment();
spaceAnalytical.SetProperties(energyAnalysisSpace, settings.ParameterSettings);
spaceAnalytical.SetProperties(spatialElement, settings.ParameterSettings);
space.AddFragment(spaceAnalytical);
SpaceContextFragment spaceContext = new SpaceContextFragment();
List <string> connectedElements = new List <string>();
foreach (EnergyAnalysisSurface energyAnalysisSurface in energyAnalysisSpace.GetAnalyticalSurfaces())
{
connectedElements.Add(energyAnalysisSurface.CADObjectUniqueId);
}
spaceContext.ConnectedElements = connectedElements;
spaceContext.SetProperties(energyAnalysisSpace, settings.ParameterSettings);
spaceContext.SetProperties(spatialElement, settings.ParameterSettings);
space.AddFragment(spaceContext);
//Set identifiers, parameters & custom data
space.SetIdentifiers(spatialElement);
space.CopyParameters(spatialElement, settings.ParameterSettings);
space.SetProperties(spatialElement, settings.ParameterSettings);
space.SetProperties(energyAnalysisSpace, settings.ParameterSettings);
refObjects.AddOrReplace(energyAnalysisSpace.Id, space);
return(space);
}
public static GBXML.GBXML ToGBXML(this List <IBHoMObject> objs, GBXMLSettings settings)
{
List <Panel> panels = objs.Panels();
List <Space> spaces = objs.Spaces();
List <Level> levels = objs.Levels();
List <Building> buildings = objs.Buildings();
if (buildings.Count > 1)
{
BH.Engine.Reflection.Compute.RecordWarning("More than 1 building has been supplied. Space information will be assigned to the first building but all buildings will be serialised");
}
else if (buildings.Count == 0)
{
BH.Engine.Reflection.Compute.RecordWarning("No building was supplied, generic empty building is being used to group the data");
buildings.Add(new Building());
}
List <Panel> shadingElements = panels.FilterPanelsByType(PanelType.Shade).Item1;
panels = panels.FilterPanelsByType(PanelType.Shade).Item2; //Remove shading if it exists
List <List <Panel> > panelsAsSpaces = panels.ToSpaces();
List <Construction> constructions = panels.Where(x => x.Construction != null).Select(x => x.Construction as Construction).ToList();
List <Construction> windowConstructions = panels.OpeningsFromElements().UniqueConstructions();
List <GBXML.Building> xmlBuildings = buildings.Select(x => x.ToGBXML()).ToList();
List <GBXML.BuildingStorey> xmlLevels = levels.Where(x => x.StoreyGeometry(panelsAsSpaces) != null).Select(x => x.ToGBXML(x.StoreyGeometry(panelsAsSpaces), settings)).ToList();
List <GBXML.Space> xmlSpaces = panelsAsSpaces.Select(x => x.ToGBXML(x.Level(levels), settings)).OrderBy(x => x.Name).ToList();
List <GBXML.Surface> xmlSurfaces = new List <GBXML.Surface>();
List <GBXML.Construction> xmlConstructions = new List <GBXML.Construction>();
List <GBXML.Layer> xmlLayers = new List <GBXML.Layer>();
List <GBXML.Material> xmlMaterials = new List <GBXML.Material>();
List <GBXML.WindowType> xmlWindows = new List <GBXML.WindowType>();
List <Panel> usedPanels = new List <Panel>();
foreach (List <Panel> space in panelsAsSpaces)
{
foreach (Panel p in space)
{
if (usedPanels.Where(x => x.BHoM_Guid == p.BHoM_Guid).FirstOrDefault() != null)
{
continue;
}
xmlSurfaces.Add(p.ToGBXML(settings, space));
usedPanels.Add(p);
}
}
//Check we haven't missed any panels (such as shading) and include them
foreach (Panel p in panels)
{
if (usedPanels.Where(x => x.BHoM_Guid == p.BHoM_Guid).FirstOrDefault() != null)
{
continue;
}
xmlSurfaces.Add(p.ToGBXML(settings));
usedPanels.Add(p);
}
//Include shading
foreach (Panel p in shadingElements)
{
if (usedPanels.Where(x => x.BHoM_Guid == p.BHoM_Guid).FirstOrDefault() != null)
{
continue;
}
xmlSurfaces.Add(p.ToGBXMLShade(settings));
usedPanels.Add(p);
}
foreach (Construction c in constructions)
{
if (c == null)
{
continue;
}
GBXML.Construction xmlConc = c.ToGBXML();
if (xmlConstructions.Where(x => x.ID == xmlConc.ID).FirstOrDefault() != null)
{
continue; //Don't add the same construction twice
}
List <GBXML.Material> layerMaterials = new List <GBXML.Material>();
foreach (Layer l in c.Layers)
{
layerMaterials.Add(l.ToGBXML(settings));
}
xmlMaterials.AddRange(layerMaterials);
GBXML.Layer layer = layerMaterials.ToGBXML();
xmlLayers.Add(layer);
xmlConc.LayerID.LayerIDRef = layer.ID;
xmlConstructions.Add(xmlConc);
}
foreach (Opening o in panels.OpeningsFromElements())
{
OriginContextFragment openingEnvContextProperties = o.FindFragment <OriginContextFragment>(typeof(OriginContextFragment));
string nameCheck = "";
if (openingEnvContextProperties != null)
{
nameCheck = openingEnvContextProperties.TypeName;
}
else if (o.OpeningConstruction != null)
{
nameCheck = o.OpeningConstruction.Name;
}
var t = xmlWindows.Where(a => a.Name == nameCheck).FirstOrDefault();
if (t == null && o.OpeningConstruction != null)
{
xmlWindows.Add(o.OpeningConstruction.ToGBXMLWindow(settings, o));
}
}
GBXML.GBXML gbx = new GBXML.GBXML();
gbx.Campus.Building = xmlBuildings.ToArray();
gbx.Campus.Location = buildings[0].ToGBXMLLocation(settings);
gbx.Campus.Building[0].BuildingStorey = xmlLevels.ToArray();
gbx.Campus.Building[0].Space = xmlSpaces;
gbx.Campus.Surface = xmlSurfaces;
if (settings.IncludeConstructions)
{
gbx.Construction = xmlConstructions.ToArray();
gbx.Layer = xmlLayers.ToArray();
gbx.Material = xmlMaterials.ToArray();
gbx.WindowType = xmlWindows.ToArray();
}
else
{
gbx.WindowType = null;
}
//Set the building area
List <Panel> floorElements = panels.Where(x => x.Type == PanelType.Floor || x.Type == PanelType.FloorExposed || x.Type == PanelType.FloorInternal || x.Type == PanelType.FloorRaised || x.Type == PanelType.SlabOnGrade || x.Type == PanelType.UndergroundSlab).ToList();
double buildingFloorArea = 0;
foreach (Panel p in floorElements)
{
buildingFloorArea += p.Area();
}
gbx.Campus.Building[0].Area = buildingFloorArea;
//Document History
GBXML.DocumentHistory DocumentHistory = new GBXML.DocumentHistory();
DocumentHistory.CreatedBy.Date = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss");
gbx.DocumentHistory = DocumentHistory;
//Unit set up
gbx.TemperatureUnit = settings.UnitSetUp.TemperatureUnit.ToGBX();
gbx.LengthUnit = settings.UnitSetUp.LengthUnit.ToGBX();
gbx.AreaUnit = settings.UnitSetUp.AreaUnit.ToGBX();
gbx.VolumeUnit = settings.UnitSetUp.VolumeUnit.ToGBX();
gbx.UseSIUnitsForResults = (settings.ResultsUnitType == oM.Adapters.XML.Enums.UnitType.SI ? "true" : "false");
return(gbx);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static oM.Environment.Elements.Panel EnvironmentPanelFromRevit(this FamilyInstance familyInstance, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
//Create a BuildingElement from the familyInstance geometry
settings = settings.DefaultIfNull();
oM.Environment.Elements.Panel panel = refObjects.GetValue <oM.Environment.Elements.Panel>(familyInstance.Id);
if (panel != null)
{
return(panel);
}
PlanarSurface openingSurface = familyInstance.OpeningSurface(null, settings) as PlanarSurface;
ICurve outline = openingSurface?.ExternalBoundary;
if (outline == null)
{
return(null);
}
panel = new oM.Environment.Elements.Panel()
{
ExternalEdges = outline.ToEdges(),
Name = familyInstance.FamilyTypeFullName(),
};
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = familyInstance.Id.IntegerValue.ToString(), TypeName = familyInstance.FamilyTypeFullName()
};
originContext.SetProperties(familyInstance.Symbol, settings.ParameterSettings);
originContext.SetProperties(familyInstance, settings.ParameterSettings);
panel.Fragments.Add(originContext);
PanelAnalyticalFragment panelAnalytical = new PanelAnalyticalFragment();
panelAnalytical.SetProperties(familyInstance.Symbol, settings.ParameterSettings);
panelAnalytical.SetProperties(familyInstance, settings.ParameterSettings);
panel.Fragments.Add(panelAnalytical);
PanelContextFragment panelContext = new PanelContextFragment();
panelContext.SetProperties(familyInstance.Symbol, settings.ParameterSettings);
panelContext.SetProperties(familyInstance, settings.ParameterSettings);
panel.Fragments.Add(panelContext);
BuildingResultFragment buildingResults = new BuildingResultFragment();
buildingResults.SetProperties(familyInstance.Symbol, settings.ParameterSettings);
buildingResults.SetProperties(familyInstance, settings.ParameterSettings);
panel.Fragments.Add(buildingResults);
oM.Environment.Elements.PanelType?panelType = familyInstance.Category.PanelType();
if (panelType.HasValue)
{
panel.Type = panelType.Value;
}
else
{
panel.Type = oM.Environment.Elements.PanelType.Undefined;
}
//Set identifiers, parameters & custom data
panel.SetIdentifiers(familyInstance);
panel.CopyParameters(familyInstance, settings.ParameterSettings);
panel.SetProperties(familyInstance, settings.ParameterSettings);
refObjects.AddOrReplace(familyInstance.Id, panel);
return(panel);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static oM.Environment.Elements.Opening OpeningFromRevit(this EnergyAnalysisOpening energyAnalysisOpening, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
Element element = energyAnalysisOpening.Element();
if (element == null)
{
oM.Environment.Elements.Opening result = refObjects.GetValue <oM.Environment.Elements.Opening>(energyAnalysisOpening.Id);
if (result != null)
{
return(result);
}
ICurve curve = energyAnalysisOpening.GetPolyloop().FromRevit();
result = new oM.Environment.Elements.Opening()
{
Edges = curve.ToEdges(),
};
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = energyAnalysisOpening.Id.IntegerValue.ToString(), TypeName = energyAnalysisOpening.OpeningName
};
originContext.SetProperties(energyAnalysisOpening, settings.ParameterSettings);
result.AddFragment(originContext);
result.OpeningConstruction = energyAnalysisOpening.Construction(settings);
result.Type = OpeningType.Undefined;
//Set identifiers, parameters & custom data
result.SetIdentifiers(energyAnalysisOpening);
result.CopyParameters(energyAnalysisOpening, settings.ParameterSettings);
result.SetProperties(energyAnalysisOpening, settings.ParameterSettings);
refObjects.AddOrReplace(energyAnalysisOpening.Id, result);
return(result);
}
else
{
oM.Environment.Elements.Opening result = refObjects.GetValue <oM.Environment.Elements.Opening>(energyAnalysisOpening.Id.IntegerValue);
if (result != null)
{
return(result);
}
ElementType elementType = element.Document.GetElement(element.GetTypeId()) as ElementType;
ICurve curve = energyAnalysisOpening.GetPolyloop().FromRevit();
result = new oM.Environment.Elements.Opening()
{
Edges = curve.ToEdges(),
Name = element.FamilyTypeFullName(),
};
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = element.Id.IntegerValue.ToString(), TypeName = element.FamilyTypeFullName()
};
originContext.SetProperties(element, settings.ParameterSettings);
originContext.SetProperties(elementType, settings.ParameterSettings);
result.AddFragment(originContext);
result.OpeningConstruction = energyAnalysisOpening.Construction(settings);
OpeningType?openingType = element.Category.OpeningType();
if (openingType.HasValue)
{
result.Type = openingType.Value;
}
else
{
result.Type = OpeningType.Undefined;
}
//Set identifiers, parameters & custom data
result.SetIdentifiers(element);
result.CopyParameters(element, settings.ParameterSettings);
result.SetProperties(element, settings.ParameterSettings);
refObjects.AddOrReplace(energyAnalysisOpening.Id, result);
return(result);
}
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static Building BuildingFromRevit(this ProjectInfo projectInfo, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
Document document = projectInfo.Document;
Building building = refObjects.GetValue <Building>(projectInfo.Id);
if (building != null)
{
return(building);
}
double elevation = 0;
double longitude = 0;
double latitude = 0;
double timeZone = 0;
string placeName = string.Empty;
string weatherStationName = string.Empty;
if (document.SiteLocation != null)
{
elevation = document.SiteLocation.Elevation.ToSI(UnitType.UT_Length);
longitude = document.SiteLocation.Longitude.ToSI(UnitType.UT_Length);
latitude = document.SiteLocation.Latitude.ToSI(UnitType.UT_Length);
timeZone = document.SiteLocation.TimeZone;
placeName = document.SiteLocation.PlaceName;
weatherStationName = document.SiteLocation.WeatherStationName;
}
double projectAngle = 0;
double projectEastWestOffset = 0;
double projectElevation = 0;
double projectNorthSouthOffset = 0;
if (document.ActiveProjectLocation != null)
{
ProjectLocation projectLocation = document.ActiveProjectLocation;
XYZ xyz = new XYZ(0, 0, 0);
ProjectPosition projectPosition = projectLocation.GetProjectPosition(xyz);
if (projectPosition != null)
{
projectAngle = projectPosition.Angle;
projectEastWestOffset = projectPosition.EastWest;
projectElevation = projectPosition.Elevation;
projectNorthSouthOffset = projectPosition.NorthSouth;
}
}
BH.oM.Environment.Climate.Location location = new BH.oM.Environment.Climate.Location()
{
Latitude = latitude, Longitude = longitude
};
building = new Building {
Elevation = elevation, Location = location
};
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = projectInfo.Id.IntegerValue.ToString(), Description = projectInfo.OrganizationDescription, TypeName = projectInfo.Name
};
building.AddFragment(originContext);
BuildingAnalyticalFragment buildingAnalytical = new BuildingAnalyticalFragment()
{
GMTOffset = timeZone, NorthAngle = projectAngle
};
building.AddFragment(buildingAnalytical);
BuildingContextFragment buildingContext = new BuildingContextFragment()
{
PlaceName = placeName, WeatherStation = weatherStationName
};
building.AddFragment(buildingContext);
//Set identifiers, parameters & custom data
building.SetIdentifiers(projectInfo);
building.CopyParameters(projectInfo, settings.ParameterSettings);
building.SetProperties(projectInfo, settings.ParameterSettings);
refObjects.AddOrReplace(projectInfo.Id, building);
return(building);
}
/***************************************************/
public static List <oM.Environment.Elements.Panel> EnvironmentPanelsFromRevit(this Wall wall, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
List <oM.Environment.Elements.Panel> panels = refObjects.GetValues <oM.Environment.Elements.Panel>(wall.Id);
if (panels != null && panels.Count > 0)
{
return(panels);
}
if (wall.StackedWallOwnerId != null && wall.StackedWallOwnerId != ElementId.InvalidElementId)
{
return(null);
}
Dictionary <PlanarSurface, List <PlanarSurface> > surfaces = wall.PanelSurfaces(wall.FindInserts(true, true, true, true), settings);
if (surfaces == null)
{
return(panels);
}
BH.oM.Physical.Constructions.Construction constrtuction = wall.WallType.ConstructionFromRevit(null, settings, refObjects);
panels = new List <oM.Environment.Elements.Panel>();
foreach (PlanarSurface surface in surfaces.Keys)
{
//Create the BuildingElement
oM.Environment.Elements.Panel panel = new oM.Environment.Elements.Panel()
{
ExternalEdges = surface.ExternalBoundary.ToEdges(),
Name = wall.FamilyTypeFullName(),
};
//Set ExtendedProperties
OriginContextFragment originContext = new OriginContextFragment()
{
ElementID = wall.Id.IntegerValue.ToString(), TypeName = wall.FamilyTypeFullName()
};
originContext.SetProperties(wall.WallType, settings.ParameterSettings);
originContext.SetProperties(wall, settings.ParameterSettings);
panel.AddFragment(originContext);
PanelAnalyticalFragment panelAnalytical = new PanelAnalyticalFragment();
panelAnalytical.SetProperties(wall.WallType, settings.ParameterSettings);
panelAnalytical.SetProperties(wall, settings.ParameterSettings);
panel.AddFragment(panelAnalytical);
PanelContextFragment panelContext = new PanelContextFragment();
panelContext.SetProperties(wall.WallType, settings.ParameterSettings);
panelContext.SetProperties(wall, settings.ParameterSettings);
panel.AddFragment(panelContext);
BuildingResultFragment buildingResults = new BuildingResultFragment();
buildingResults.SetProperties(wall.WallType, settings.ParameterSettings);
buildingResults.SetProperties(wall, settings.ParameterSettings);
panel.AddFragment(buildingResults);
panel.Construction = constrtuction;
panel.Type = oM.Environment.Elements.PanelType.Wall;
//Set identifiers, parameters & custom data
panel.SetIdentifiers(wall);
panel.CopyParameters(wall, settings.ParameterSettings);
panel.SetProperties(wall, settings.ParameterSettings);
refObjects.AddOrReplace(wall.Id, panel);
panels.Add(panel);
}
return(panels);
}