private static void CreateFilledRegion(Document doc, SpatialObjectWrapper so)
{
try
{
var filledRegionType = new FilteredElementCollector(doc).OfClass(typeof(FilledRegionType)).FirstElementId();
if (filledRegionType == null || filledRegionType == ElementId.InvalidElementId)
{
return;
}
var curves = new List <CurveLoop>();
var loop = new CurveLoop();
foreach (var curve in so.Room2D.FloorBoundary.GetCurves(so.Level.Elevation))
{
//doc.Create.NewDetailCurve(doc.ActiveView, curve);
loop.Append(curve);
}
curves.Add(loop);
FilledRegion.Create(doc, filledRegionType, doc.ActiveView.Id, curves);
}
catch (Exception e)
{
_logger.Fatal(e);
}
}
public static BoundaryConditionBase HB_Init(
IEnumerable <SpatialObjectWrapper> objects,
Face face,
SpatialObjectWrapper sow,
bool allowAdiabatic)
{
var adjacentRoomId = string.Empty;
var adjacentFaceId = string.Empty;
Face adjacentFace;
foreach (var so in objects)
{
if (!string.IsNullOrWhiteSpace(adjacentRoomId) &&
!string.IsNullOrWhiteSpace(adjacentFaceId))
{
break;
}
var faces = so.Room2D.Faces;
for (var i = 0; i < faces.Count; i++)
{
var f = faces[i];
if (!f.OverlapsWith(face))
{
continue;
}
adjacentFace = faces[i];
adjacentFaceId = faces[i].Identifier;
adjacentRoomId = so.Room2D.Identifier;
break;
}
}
if (!string.IsNullOrWhiteSpace(adjacentRoomId) &&
!string.IsNullOrWhiteSpace(adjacentFaceId))
{
// (Konrad) We found a matching Surface Boundary Condition.
// Tuple for HB Surface is always ApertureId, FaceId, RoomId.
var bConditionObj = new Tuple <string, string, string>(string.Empty, adjacentFaceId, adjacentRoomId);
return(new Surface(bConditionObj));
}
if (!allowAdiabatic)
{
return(new Outdoors());
}
//var boundary = face.Geometry.Boundary;
//var plane = RVT.Plane.CreateByThreePoints(boundary[0].ToXyz(), boundary[1].ToXyz(),
// boundary[boundary.Count - 1].ToXyz());
//var perpendicular = plane.Normal.Multiply(2);
// (Konrad) We can't find the Room adjacent to this Curve.
return(new Outdoors());
}
public Tuple <List <SpatialObjectWrapper>, List <LevelWrapper> > GetSpatialObjects(bool dragonfly)
{
var allLevels = new HashSet <LevelWrapper>();
var storedObjects = AppSettings.Instance.StoredSettings.EnergyModelSettings.Rooms;
var spatialObjects = new FilteredElementCollector(Doc)
.OfClass(typeof(SpatialElement))
.WhereElementIsNotElementType()
.Cast <SpatialElement>()
//.Where(x => (x is Room || x is Space) && x.Area > 0 && (x.Name.Contains("2-180")))
//.Where(x => (x is Room || x is Space) && x.Area > 0 && (x.Name.Contains("2-180") || x.Name.Contains("2-178")))
.Where(x => (x is Room || x is Space) && x.Area > 0)
.OrderBy(x => x.Level.Elevation)
.ToList();
var modelName = dragonfly ? "Dragonfly" : "Honeybee";
StatusBarManager.InitializeProgress($"Exporting {modelName} Model.", spatialObjects.Count);
var result = new List <SpatialObjectWrapper>();
foreach (var se in spatialObjects)
{
var timer = Stopwatch.StartNew();
StatusBarManager.StepForward($"Processing Room: {se.Name}.");
if (!storedObjects.Any())
{
result.Add(new SpatialObjectWrapper(se, dragonfly));
continue;
}
var index = storedObjects.FindIndex(y => y.Room2D?.Identifier == $"Room_{se.UniqueId}");
if (index == -1)
{
result.Add(new SpatialObjectWrapper(se, dragonfly));
continue;
}
var storedSo = storedObjects[index];
var so = new SpatialObjectWrapper(se, dragonfly);
so.IsConstructionSetOverriden = storedSo.IsConstructionSetOverriden;
so.IsProgramTypeOverriden = storedSo.IsProgramTypeOverriden;
so.Room2D.FloorToCeilingHeight = storedSo.Room2D.FloorToCeilingHeight;
so.Room2D.IsTopExposed = storedSo.Room2D.IsTopExposed;
so.Room2D.IsGroundContact = storedSo.Room2D.IsGroundContact;
so.Room2D.Properties.Energy.ConstructionSet = storedSo.Room2D.Properties.Energy.ConstructionSet;
so.Room2D.Properties.Energy.ProgramType = storedSo.Room2D.Properties.Energy.ProgramType;
allLevels.Add(so.Level);
result.Add(so);
_logger.Info($"Processed {so.Name} in {timer.Elapsed.TotalSeconds}s.");
}
if (dragonfly)
{
DF_AssignBoundaryConditions(result);
}
else
{
HB_AssignBoundaryConditions(result);
}
StatusBarManager.FinalizeProgress(true);
return(new Tuple <List <SpatialObjectWrapper>, List <LevelWrapper> >(result, allLevels.ToList()));
}
//public string RunHoneybeeEnergyCommand2(string command, IEnumerable<string> args)
//{
// var path = Environment.GetEnvironmentVariable("PATH", EnvironmentVariableTarget.User);
// if (path == null)
// return string.Empty;
// string pyPath = null;
// foreach (var p in path.Split(';'))
// {
// var fullPath = Path.Combine(p, "python.exe");
// if (!File.Exists(fullPath))
// continue;
// pyPath = fullPath;
// break;
// }
// if (string.IsNullOrWhiteSpace(pyPath))
// return string.Empty;
// var pyDir = Path.GetDirectoryName(pyPath);
// if (pyDir == null)
// return string.Empty;
// var dfPath = Path.Combine(pyDir, "Scripts", "honeybee-energy.exe");
// if (!File.Exists(dfPath))
// return string.Empty;
// var ps = PowerShell.Create();
// ps.AddCommand(pyPath)
// .AddParameter("-m")
// .AddCommand(dfPath)
// .AddArgument("lib")
// .AddArgument(command);
// foreach (var arg in args)
// {
// ps.AddArgument(arg);
// }
// var psObject = ps.Invoke();
// var result = psObject.FirstOrDefault()?.ImmediateBaseObject as string;
// ps.Commands.Clear();
// return result;
//}
public void ShowBoundaryConditions(SpatialObjectWrapper so)
{
AppCommand.CreateModelHandler.Arg1 = so;
AppCommand.CreateModelHandler.Request.Make(RequestId.ShowBoundaryConditions);
AppCommand.CreateModelEvent.Raise();
}
private void OnShowBoundaryConditions(SpatialObjectWrapper so)
{
Model.ShowBoundaryConditions(so);
}
private static void OnShowDetails(SpatialObjectWrapper so)
{
so.IsExpanded = !so.IsExpanded;
}
public static BoundaryConditionBase DF_Init(
IEnumerable <SpatialObjectWrapper> objects,
RVT.Curve curve,
SpatialObjectWrapper sow,
bool allowAdiabatic)
{
var adjacentRoomName = string.Empty;
var adjacentCurveIndex = -1;
foreach (var so in objects)
{
if (adjacentCurveIndex != -1 && adjacentRoomName != null)
{
break;
}
var boundarySegments = so.Room2D.FloorBoundary.GetCurves(so.Level.Elevation);
for (var i = 0; i < boundarySegments.Count; i++)
{
var c = boundarySegments[i];
if (!c.OverlapsWithIn2D(curve))
{
continue;
}
adjacentCurveIndex = i;
adjacentRoomName = so.Room2D.Identifier;
break;
}
}
if (adjacentCurveIndex != -1 && !string.IsNullOrWhiteSpace(adjacentRoomName))
{
// (Konrad) We found a matching Surface Boundary Condition.
var bConditionObj = new Tuple <string, string, string>(string.Empty, adjacentCurveIndex.ToString(), adjacentRoomName);
return(new Surface(bConditionObj));
}
if (!allowAdiabatic)
{
return(new Outdoors());
}
// (Konrad) We can try assigning Adiabatic and Outdoors.
var direction = curve is RVT.Line
? curve.ComputeDerivatives(0, true).BasisX.Normalize()
: (curve.GetEndPoint(1) - curve.GetEndPoint(0)).Normalize();
var perpendicular = RVT.XYZ.BasisZ.CrossProduct(direction).Multiply(2);
var start = curve.GetEndPoint(0);
var end = curve.GetEndPoint(1);
var midPoint = new RVT.XYZ((start.X + end.X) / 2, (start.Y + end.Y) / 2, start.Z + 1);
var outPt = midPoint + perpendicular;
var doc = sow.Self.Document;
var phases = doc.Phases;
var room = phases.Cast <RVT.Phase>().Select(x => doc.GetRoomAtPoint(outPt, x)).FirstOrDefault(x => x != null);
if (room != null && room.Id != sow.Self.Id)
{
return(new Adiabatic());
}
var inPt = midPoint + perpendicular.Negate();
room = phases.Cast <RVT.Phase>().Select(x => doc.GetRoomAtPoint(inPt, x)).FirstOrDefault(x => x != null);
if (room != null && room.Id != sow.Self.Id)
{
return(new Adiabatic());
}
// (Konrad) We can't find the Room adjacent to this Curve.
return(new Outdoors());
}
private static void CreateAnnotations(Document doc, SpatialObjectWrapper so)
{
try
{
const string famName = "2020_BoundaryConditions";
var gaId = BuiltInCategory.OST_GenericAnnotation.GetHashCode();
var loadedFam = new FilteredElementCollector(doc)
.OfClass(typeof(Family))
.Cast <Family>()
.FirstOrDefault(x => x.FamilyCategory.Id.IntegerValue == gaId && x.Name == famName);
if (loadedFam == null)
{
var resourcePath = GetFamilyFromResource(famName);
loadedFam = doc.LoadFamily(doc, new FamilyUtils.FamilyLoadProcessor());
if (string.IsNullOrWhiteSpace(resourcePath) || loadedFam == null)
{
return;
}
}
var symbols = new Dictionary <string, FamilySymbol>();
foreach (var id in loadedFam.GetFamilySymbolIds())
{
if (!(doc.GetElement(id) is FamilySymbol familySymbol))
{
continue;
}
symbols.Add(familySymbol.Name, familySymbol);
}
var floorBoundaries = so.Room2D.FloorBoundary.GetCurves(so.Level.Elevation);
var floorHoles = so.Room2D.FloorHoles.SelectMany(x => x.GetCurves(so.Level.Elevation));
var combinedSegments = new List <Curve>();
combinedSegments.AddRange(floorBoundaries);
combinedSegments.AddRange(floorHoles);
var hasAnnotations = so.Room2D.Annotations.Count == so.Room2D.BoundaryConditions.Count;
for (var i = 0; i < combinedSegments.Count; i++)
{
var curve = combinedSegments[i];
var bCondition = so.Room2D.BoundaryConditions[i];
var annotation = hasAnnotations
? so.Room2D.Annotations[i]
: null;
FamilySymbol fs;
string adjacentRoom;
if (hasAnnotations)
{
fs = doc.GetElement(annotation.FamilySymbolId) as FamilySymbol;
adjacentRoom = annotation.AdjacentRoom;
}
else
{
switch (bCondition)
{
case Surface unused:
fs = symbols["Surface"];
break;
case Outdoors unused:
fs = symbols["Outdoors"];
break;
case Adiabatic unused:
fs = symbols["Adiabatic"];
break;
case Ground unused:
fs = symbols["Ground"];
break;
default:
fs = symbols["Outdoors"];
break;
}
adjacentRoom = (bCondition as Surface)?.BoundaryConditionObjects.Item2;
}
var loc = curve.Evaluate(0.5, true);
var fi = doc.Create.NewFamilyInstance(loc, fs, doc.ActiveView);
fi?.LookupParameter("AdjacentRoom")?.Set(adjacentRoom);
if (so.Room2D.Annotations.Count != combinedSegments.Count)
{
so.Room2D.Annotations.Add(new AnnotationWrapper(fi)
{
AdjacentRoom = adjacentRoom
});
}
else
{
so.Room2D.Annotations[i] = new AnnotationWrapper(fi)
{
AdjacentRoom = adjacentRoom
};
}
}
Messenger.Default.Send(new AnnotationsCreated(so));
}
catch (Exception e)
{
_logger.Fatal(e);
}
}
public AnnotationsCreated(SpatialObjectWrapper sow)
{
SpatialObject = sow;
}
