/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static void Serialize <T>(IEnumerable <T> bhomObjects, BH.oM.XML.GBXML gbx, string fileName, XMLSettings settings) where T : IObject
{
switch (settings.ExportDetail)
{
case ExportDetail.Full:
SerializeCollectionFull(bhomObjects as dynamic, gbx, settings);
break;
case ExportDetail.BuildingShell:
SerializeBuildingShell(bhomObjects as dynamic, gbx, settings);
break;
case ExportDetail.IndividualSpaces:
SerializeSpaces(bhomObjects, fileName, settings);
break;
default:
throw new NotImplementedException("That option has not been implemented");
}
// Document History
DocumentHistory DocumentHistory = new DocumentHistory();
DocumentHistory.CreatedBy.Date = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:ss");
gbx.DocumentHistory = DocumentHistory;
}
private IEnumerable <IBHoMObject> Read(Type type = null)
{
BH.oM.XML.GBXML gbx = XMLReader.Load(_fileSettings.FullFileName());
if (type == null)
{
return(ReadFullXMLFile(gbx));
}
else if (type == typeof(BHE.Building))
{
return(ReadBuilding(gbx));
}
else if (type == typeof(BHE.Panel))
{
return(ReadPanels(gbx));
}
/*else if (type == typeof(BHC.Construction))
* return ReadConstructions(gbx);
* else if (type == typeof(BH.oM.Physical.Properties.Material))
* return ReadMaterials(gbx);*/
else if (type == typeof(BHA.Level))
{
return(ReadLevels(gbx));
}
else
{
return(ReadFullXMLFile(gbx));
}
}
private List <BHC.Construction> ReadConstructions(BHX.GBXML gbx, List <string> ids = null)
{
List <BHC.Construction> constructions = new List <BHC.Construction>();
if (gbx.Construction != null)
{
if (gbx.Layer != null)
{
foreach (BHX.Construction c in gbx.Construction)
{
BHX.Layer gbLayer = gbx.Layer.Where(x => x.ID == c.LayerID.LayerIDRef).FirstOrDefault();
if (gbLayer != null)
{
List <BHX.Material> gbMaterials = gbx.Material.Where(x => gbLayer.MaterialID.Where(y => y.MaterialIDRef == x.ID).FirstOrDefault() != null).ToList();
if (gbMaterials.Count > 0)
{
List <BHC.Layer> layers = gbMaterials.Select(x => x.ToBHoM()).ToList();
constructions.Add(c.ToBHoM(layers));
}
}
}
}
}
return(constructions);
}
/*private List<BH.oM.Physical.Properties.Material> ReadMaterials(BHX.GBXML gbx, List<string> ids = null)
* {
* if (gbx.Material != null)
* return gbx.Material.Select(x => x.ToBHoM()).ToList();
* else
* return new List<BH.oM.Environment.Materials.Material>();
* }*/
private List <BHA.Level> ReadLevels(BHX.GBXML gbx, List <string> ids = null)
{
if (gbx.Campus.Building.Length > 0)
{
return(gbx.Campus.Building[0].BuildingStorey.Select(x => x.ToBHoM()).ToList());
}
else
{
return(new List <BHA.Level>());
}
}
/***************************************************/
/**** Private Methods ****/
/***************************************************/
private List <IBHoMObject> ReadFullXMLFile(BH.oM.XML.GBXML gbx, List <string> ids = null)
{
List <IBHoMObject> objects = new List <IBHoMObject>();
objects.AddRange(ReadBuilding(gbx));
objects.AddRange(ReadPanels(gbx));
objects.AddRange(ReadConstructions(gbx));
//objects.AddRange(ReadMaterials(gbx));
objects.AddRange(ReadLevels(gbx));
objects.AddRange(ReadSpaces(gbx));
return(objects);
}
private List <BHE.Building> ReadBuilding(BHX.GBXML gbx, List <string> ids = null)
{
if (gbx.Campus != null)
{
return new List <BHE.Building>()
{
gbx.Campus.Location.ToBHoM()
}
}
;
else
{
return(new List <BHE.Building>());
}
}
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);
}
private List <BHE.Panel> ReadPanels(BHX.GBXML gbx, List <string> ids = null)
{
List <BHE.Panel> panels = new List <BHE.Panel>();
if (gbx.Campus != null && gbx.Campus.Surface != null)
{
foreach (BHX.Surface s in gbx.Campus.Surface)
{
BHE.Panel p = s.ToBHoM();
if (gbx.Construction != null)
{
BHX.Construction c = gbx.Construction.Where(x => x.ID == s.ConstructionIDRef).FirstOrDefault();
if (c != null)
{
BHX.Layer gbLayer = gbx.Layer.Where(x => x.ID == c.LayerID.LayerIDRef).FirstOrDefault();
if (gbLayer != null)
{
List <BHX.Material> gbMaterials = gbx.Material.Where(x => gbLayer.MaterialID.Where(y => y.MaterialIDRef == x.ID).FirstOrDefault() != null).ToList();
if (gbMaterials.Count > 0)
{
List <BHC.Layer> layers = gbMaterials.Select(x => x.ToBHoM()).ToList();
p.Construction = c.ToBHoM(layers);
}
}
}
}
foreach (BHX.Opening gbxOpening in s.Opening)
{
p.Openings.Add(gbxOpening.ToBHoM());
}
panels.Add(p);
}
}
return(panels);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static void SerializeCollection(IEnumerable <IEnumerable <Panel> > inputElements, List <Level> levels, List <Panel> openings, BH.oM.XML.GBXML gbx, XMLSettings settings)
{
List <List <Panel> > elementsAsSpaces = new List <List <Panel> >();
foreach (IEnumerable <Panel> input in inputElements)
{
elementsAsSpaces.Add(input.ToList());
}
List <Panel> uniqueBuildingElements = elementsAsSpaces.UniquePanels();
List <Panel> allElements = new List <Panel>(uniqueBuildingElements);
allElements.AddRange(openings);
//List<BH.oM.Environment.Elements.Space> spaces = elementsAsSpaces.Spaces();
List <Panel> usedBEs = new List <Panel>();
List <BH.oM.XML.Construction> usedConstructions = new List <BH.oM.XML.Construction>();
List <BH.oM.XML.Material> usedMaterials = new List <Material>();
List <BH.oM.XML.Layer> usedLayers = new List <Layer>();
List <string> usedSpaceNames = new List <string>();
List <BH.oM.XML.WindowType> usedWindows = new List <WindowType>();
foreach (List <Panel> space in elementsAsSpaces)
{
//For each collection of BuildingElements that define a space, convert the panels to XML surfaces and add to the GBXML
List <Surface> spaceSurfaces = new List <Surface>();
for (int x = 0; x < space.Count; x++)
{
if (usedBEs.Where(i => i.BHoM_Guid == space[x].BHoM_Guid).FirstOrDefault() != null)
{
continue;
}
//Fix panel type
//if(space[x].Type == PanelType.WallExternal && space[x].ConnectedSpaces.Count == 2)
//space[x].Type = PanelType.WallInternal;
BHP.OriginContextFragment envContextProperties = space[x].FindFragment <BHP.OriginContextFragment>(typeof(BHP.OriginContextFragment));
List <List <Panel> > adjacentSpaces = BH.Engine.Environment.Query.AdjacentSpaces(space[x], elementsAsSpaces);
Surface srf = space[x].ToGBXML(adjacentSpaces, space);
srf.ID = "Panel-" + gbx.Campus.Surface.Count.ToString().Replace(" ", "").Replace("-", "");
srf.Name = "Panel" + gbx.Campus.Surface.Count.ToString().Replace(" ", "").Replace("-", "");
if (space[x] != null)
{
srf.CADObjectID = BH.Engine.XML.Query.CADObjectID(space[x], settings.ReplaceCurtainWalls);
}
if (settings.IncludeConstructions)
{
srf.ConstructionIDRef = (envContextProperties != null ? envContextProperties.TypeName.CleanName() : space[x].ConstructionID());
}
else
{
srf.ConstructionIDRef = null;
}
if (settings.ReplaceCurtainWalls)
{
//If the surface is a basic Wall: SIM_EXT_GLZ so Curtain Wall after CADObjectID translation add the wall as an opening
if (srf.CADObjectID.Contains("Curtain") && srf.CADObjectID.Contains("GLZ"))
{
List <BHG.Polyline> newOpeningBounds = new List <oM.Geometry.Polyline>();
if (space[x].Openings.Count > 0)
{
//This surface already has openings - cut them out of the new opening
List <BHG.Polyline> refRegion = space[x].Openings.Where(y => y.Polyline() != null).ToList().Select(z => z.Polyline()).ToList();
newOpeningBounds.AddRange((new List <BHG.Polyline> {
space[x].Polyline()
}).BooleanDifference(refRegion, 0.01));
}
else
{
newOpeningBounds.Add(space[x].Polyline());
}
BH.oM.Environment.Elements.Opening curtainWallOpening = BH.Engine.Environment.Create.Opening(externalEdges: newOpeningBounds.ToEdges());
curtainWallOpening.Name = space[x].Name;
BHP.OriginContextFragment curtainWallProperties = new BHP.OriginContextFragment();
if (envContextProperties != null)
{
curtainWallProperties.ElementID = envContextProperties.ElementID;
curtainWallProperties.TypeName = envContextProperties.TypeName;
}
curtainWallOpening.Type = OpeningType.CurtainWall;
curtainWallOpening.OpeningConstruction = space[x].Construction;
curtainWallOpening.Fragments.Add(curtainWallProperties);
space[x].Openings.Add(curtainWallOpening);
//Update the host elements element type
srf.SurfaceType = (adjacentSpaces.Count == 1 ? PanelType.WallExternal : PanelType.WallInternal).ToGBXML();
srf.ExposedToSun = BH.Engine.XML.Query.ExposedToSun(srf.SurfaceType).ToString().ToLower();
}
}
else
{
//Fix surface type for curtain walls
if (space[x].Type == PanelType.CurtainWall)
{
srf.SurfaceType = (adjacentSpaces.Count == 1 ? PanelType.WallExternal : PanelType.WallInternal).ToGBXML();
srf.ExposedToSun = BH.Engine.XML.Query.ExposedToSun(srf.SurfaceType).ToString().ToLower();
}
}
if (settings.FixIncorrectAirTypes && space[x].Type == PanelType.Undefined && space[x].ConnectedSpaces.Count == 1)
{
//Fix external air types
if (space[x].Tilt() == 0)
{
srf.SurfaceType = PanelType.Roof.ToGBXML();
}
else if (space[x].Tilt() == 90)
{
srf.SurfaceType = PanelType.WallExternal.ToGBXML();
}
else if (space[x].Tilt() == 180)
{
srf.SurfaceType = PanelType.SlabOnGrade.ToGBXML();
}
}
//Openings
if (space[x].Openings.Count > 0)
{
srf.Opening = SerializeOpenings(space[x].Openings, space, allElements, elementsAsSpaces, gbx, settings).ToArray();
foreach (BH.oM.Environment.Elements.Opening o in space[x].Openings)
{
string nameCheck = "";
BHP.OriginContextFragment openingEnvContextProperties = o.FindFragment <BHP.OriginContextFragment>(typeof(BHP.OriginContextFragment));
if (openingEnvContextProperties != null)
{
nameCheck = openingEnvContextProperties.TypeName;
}
else if (o.OpeningConstruction != null)
{
nameCheck = o.OpeningConstruction.Name;
}
var t = usedWindows.Where(a => a.Name == nameCheck).FirstOrDefault();
if (t == null && o.OpeningConstruction != null)
{
usedWindows.Add(o.OpeningConstruction.ToGBXMLWindow(o));
}
}
}
gbx.Campus.Surface.Add(srf);
usedBEs.Add(space[x]);
if (settings.IncludeConstructions && space[x].Construction != null)
{
BH.oM.XML.Construction conc = space[x].ToGBXMLConstruction();
BH.oM.XML.Construction test = usedConstructions.Where(y => y.ID == conc.ID).FirstOrDefault();
if (test == null)
{
List <BH.oM.XML.Material> materials = new List <Material>();
BHC.Construction construction = space[x].Construction as BHC.Construction;
foreach (BHC.Layer l in construction.Layers)
{
materials.Add(l.ToGBXML());
}
BH.oM.XML.Layer layer = materials.ToGBXML();
conc.LayerID.LayerIDRef = layer.ID;
usedConstructions.Add(conc);
if (usedLayers.Where(y => y.ID == layer.ID).FirstOrDefault() == null)
{
usedLayers.Add(layer);
}
foreach (BH.oM.XML.Material mat in materials)
{
if (usedMaterials.Where(y => y.ID == mat.ID).FirstOrDefault() == null)
{
usedMaterials.Add(mat);
}
}
}
}
}
BH.oM.XML.Space xmlSpace = new oM.XML.Space();
xmlSpace.Name = space.ConnectedSpaceName();
xmlSpace.ID = "Space" + xmlSpace.Name.Replace(" ", "").Replace("-", "");
xmlSpace.CADObjectID = BH.Engine.XML.Query.CADObjectID(space);
xmlSpace.ShellGeometry.ClosedShell.PolyLoop = BH.Engine.XML.Query.ClosedShellGeometry(space).ToArray();
xmlSpace.ShellGeometry.ID = "SpaceShellGeometry-" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
xmlSpace.SpaceBoundary = BH.Engine.XML.Query.SpaceBoundaries(space, uniqueBuildingElements);
xmlSpace.PlanarGeoemtry.ID = "SpacePlanarGeometry-" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
if (BH.Engine.Environment.Query.FloorGeometry(space) != null)
{
xmlSpace.PlanarGeoemtry.PolyLoop = BH.Engine.XML.Convert.ToGBXML(BH.Engine.Environment.Query.FloorGeometry(space));
xmlSpace.Area = BH.Engine.Environment.Query.FloorGeometry(space).Area();
xmlSpace.Volume = space.Volume();
}
Level spaceLevel = space.Level(levels);
if (spaceLevel != null)
{
string levelName = "";
if (spaceLevel.Name == "")
{
levelName = spaceLevel.Elevation.ToString();
}
else
{
levelName = spaceLevel.Name;
}
xmlSpace.BuildingStoreyIDRef = "Level-" + levelName.Replace(" ", "").ToLower();
}
gbx.Campus.Building[0].Space.Add(xmlSpace);
usedSpaceNames.Add(xmlSpace.Name);
}
//Reorder the spaces
gbx.Campus.Building[0].Space = gbx.Campus.Building[0].Space.OrderBy(x => x.Name).ToList();
gbx.Construction = usedConstructions.ToArray();
gbx.Layer = usedLayers.ToArray();
gbx.Material = usedMaterials.ToArray();
if (settings.IncludeConstructions)
{
gbx.WindowType = usedWindows.ToArray();
}
else //We have to force null otherwise WindowType will be created
{
gbx.WindowType = null;
}
//Set the building area
List <Panel> floorElements = allElements.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 be in floorElements)
{
buildingFloorArea += be.Area();
}
gbx.Campus.Building[0].Area = buildingFloorArea;
}
public static void SerializeCollection(IEnumerable <Panel> inputElements, List <Level> levels, List <Panel> openings, BH.oM.XML.GBXML gbx, XMLSettings settings)
{
List <List <Panel> > elementsAsSpaces = new List <List <Panel> >();
elementsAsSpaces.Add(inputElements.ToList());
SerializeCollection(elementsAsSpaces, levels, openings, gbx, settings);
}
public static void SerializeCollection(IEnumerable <Panel> inputElements, BH.oM.XML.GBXML gbx, XMLSettings settings)
{
//For serializing shade elements
List <Panel> buildingElements = inputElements.ToList();
List <BH.oM.XML.Construction> usedConstructions = new List <oM.XML.Construction>(gbx.Construction);
List <BH.oM.XML.Material> usedMaterials = new List <Material>(gbx.Material);
List <BH.oM.XML.Layer> usedLayers = new List <Layer>(gbx.Layer);
foreach (Panel be in buildingElements)
{
Surface gbSrf = be.ToGBXML();
gbSrf.ID = "Panel-" + gbx.Campus.Surface.Count.ToString().Replace(" ", "").Replace("-", "");
gbSrf.Name = "Panel" + gbx.Campus.Surface.Count.ToString().Replace(" ", "").Replace("-", "");
gbSrf.SurfaceType = "Shade";
gbSrf.ExposedToSun = BH.Engine.XML.Query.ExposedToSun(gbSrf.SurfaceType).ToString().ToLower();
gbSrf.CADObjectID = be.CADObjectID();
if (settings.IncludeConstructions)
{
BHP.OriginContextFragment envContextProperties = be.FindFragment <BHP.OriginContextFragment>(typeof(BHP.OriginContextFragment));
gbSrf.ConstructionIDRef = (envContextProperties != null ? envContextProperties.TypeName.CleanName() : be.ConstructionID());
BH.oM.XML.Construction conc = be.ToGBXMLConstruction();
BH.oM.XML.Construction test = usedConstructions.Where(y => y.ID == conc.ID).FirstOrDefault();
if (test == null)
{
List <BH.oM.XML.Material> materials = new List <Material>();
BHC.Construction construction = be.Construction as BHC.Construction;
foreach (BHC.Layer l in construction.Layers)
{
materials.Add(l.ToGBXML());
}
BH.oM.XML.Layer layer = materials.ToGBXML();
conc.LayerID.LayerIDRef = layer.ID;
usedConstructions.Add(conc);
if (usedLayers.Where(y => y.ID == layer.ID).FirstOrDefault() == null)
{
usedLayers.Add(layer);
}
foreach (BH.oM.XML.Material mat in materials)
{
if (usedMaterials.Where(y => y.ID == mat.ID).FirstOrDefault() == null)
{
usedMaterials.Add(mat);
}
}
}
}
else //We have to force null otherwise Construction will be created
{
gbSrf.ConstructionIDRef = null;
}
gbx.Campus.Surface.Add(gbSrf);
}
gbx.Construction = usedConstructions.ToArray();
gbx.Layer = usedLayers.ToArray();
gbx.Material = usedMaterials.ToArray();
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <BH.oM.XML.Opening> SerializeOpenings(IEnumerable <BH.oM.Environment.Elements.Opening> openings, List <Panel> space, List <Panel> allElements, List <List <Panel> > spaces, BH.oM.XML.GBXML gbx, XMLSettings settings)
{
List <BH.oM.XML.Opening> gbOpenings = new List <oM.XML.Opening>();
foreach (BH.oM.Environment.Elements.Opening opening in openings)
{
Polyline openingPoly = opening.Polyline();
if (openingPoly == null || openingPoly.CleanPolyline(distanceTolerance: settings.DistanceTolerance) == null)
{
continue;
}
openingPoly = openingPoly.CleanPolyline(distanceTolerance: settings.DistanceTolerance);
BH.oM.XML.Opening gbOpening = BH.Engine.XML.Convert.ToGBXML(opening);
//Normals away from space
if (!BH.Engine.Environment.Query.NormalAwayFromSpace(openingPoly, space))
{
gbOpening.PlanarGeometry.PolyLoop = BH.Engine.XML.Convert.ToGBXML(openingPoly.Flip());
}
Panel buildingElement = new Panel();
;
BHP.OriginContextFragment contextProperties = opening.FindFragment <BHP.OriginContextFragment>(typeof(BHP.OriginContextFragment));
string elementID = "";
string familyName = "";
if (contextProperties != null)
{
elementID = contextProperties.ElementID;
familyName = contextProperties.TypeName;
}
gbOpening.CADObjectID = opening.CADObjectID();
gbOpening.OpeningType = opening.Type.ToGBXML();
if (gbOpening.OpeningType.ToLower() == "fixedwindow" && contextProperties != null && contextProperties.TypeName.ToLower().Contains("skylight"))
{
gbOpening.OpeningType = "FixedSkylight";
}
if (familyName == "System Panel") //No SAM_BuildingElementType for this one atm
{
gbOpening.OpeningType = "FixedWindow";
}
if (settings.ReplaceSolidOpeningsIntoDoors && gbOpening.OpeningType.Contains("Window") && (opening.OpeningConstruction != null && opening.OpeningConstruction.Name.Contains("SLD"))) //Change windows with SLD construction into doors for IES
{
gbOpening.OpeningType = "NonSlidingDoor";
}
if (settings.IncludeConstructions)
{
gbOpening.WindowTypeIDRef = "window-" + (contextProperties != null? contextProperties.TypeName.CleanName() : (opening.OpeningConstruction != null ? opening.OpeningConstruction.Name.CleanName() : ""));
}
else
{
gbOpening.WindowTypeIDRef = null;
}
gbOpening.ConstructionIDRef = null; //ToDo review having this property on an opening?
gbOpenings.Add(gbOpening);
}
return(gbOpenings);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static void SerializeLevels(List <BH.oM.Architecture.Elements.Level> levels, List <List <Panel> > spaces, BH.oM.XML.GBXML gbx, XMLSettings settings)
{
List <BH.oM.XML.BuildingStorey> xmlLevels = new List <BuildingStorey>();
foreach (BH.oM.Architecture.Elements.Level level in levels)
{
string levelName = "";
if (level.Name == "")
{
levelName = level.Elevation.ToString();
}
else
{
levelName = level.Name;
}
BuildingStorey storey = BH.Engine.XML.Convert.ToGBXML(level);
Polyline storeyGeometry = BH.Engine.Environment.Query.StoreyGeometry(level, spaces);
if (storeyGeometry == null)
{
continue;
}
storey.PlanarGeometry.PolyLoop = BH.Engine.XML.Convert.ToGBXML(storeyGeometry);
storey.PlanarGeometry.ID = "LevelPlanarGeometry-" + Guid.NewGuid().ToString().Replace("-", "").Substring(0, 10);
storey.Name = levelName;
storey.Level = (float)level.Elevation;
storey.ID = "Level-" + levelName.Replace(" ", "").ToLower();
xmlLevels.Add(storey);
}
gbx.Campus.Building[0].BuildingStorey = xmlLevels.ToArray();
}
