/// <summary>
///
/// </summary>
/// <param name="param"></param>
/// <returns></returns>
public static string ParamValueToStr(Revit.Parameter param)
{
if (param.StorageType == Revit.StorageType.Double)
return param.AsDouble().ToString();
else if (param.StorageType == Revit.StorageType.ElementId)
return param.AsElementId().ToString();
else if (param.StorageType == Revit.StorageType.Integer)
return param.AsInteger().ToString();
else if (param.StorageType == Revit.StorageType.String)
return param.AsString();
else {
Debug.Assert(false);
return string.Empty;
}
}
SetParameter (Revit.Parameter parameterToSet, Revit.ParameterSet parameterSet)
{
foreach (Revit.Parameter param in parameterSet) {
if (param.Definition.Name == parameterToSet.Definition.Name) {
switch (param.StorageType) {
case Revit.StorageType.Double:
parameterToSet.Set(param.AsDouble());
break;
case Revit.StorageType.ElementId:
Revit.ElementId elemId = param.AsElementId();
parameterToSet.Set(elemId);
break;
case Revit.StorageType.Integer:
parameterToSet.Set(param.AsInteger());
break;
case Revit.StorageType.String:
parameterToSet.Set(param.AsString());
break;
}
return;
}
}
}
/// <summary>
/// Initialize a Room element
/// </summary>
/// <param name="room"></param>
private void InitRoom(DB.Architecture.Room room)
{
InternalSetRoom(room);
}
/// <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));
}
/// <summary>
/// Create from an existing Revit Element
/// </summary>
/// <param name="group">An existing Revit Group</param>
private Group(DB.Group group)
{
SafeInit(() => InitGroup(group));
}
/// <summary>
/// Place a Group in the model
/// </summary>
/// <param name="point">The group instance location</param>
/// <param name="groupType">The type of the group</param>
private void InitGroup(DB.XYZ point,DB.GroupType groupType)
{
DB.Document document = DocumentManager.Instance.CurrentDBDocument;
// This creates a new wall and deletes the old one
TransactionManager.Instance.EnsureInTransaction(document);
//Phase 1 - Check to see if the object exists and should be rebound
var groupElem = ElementBinder.GetElementFromTrace<DB.Group>(document);
if (groupElem == null)
groupElem = document.Create.PlaceGroup(point, groupType);
InternalSetGroup(groupElem);
TransactionManager.Instance.TransactionTaskDone();
if (groupElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
/// <summary>
/// Create a group from an existing reference
/// </summary>
/// <param name="group"></param>
/// <param name="isRevitOwned"></param>
/// <returns></returns>
internal static Group FromExisting(DB.Group group, bool isRevitOwned)
{
return new Group(group)
{
//IsRevitOwned = isRevitOwned
};
}
SetParameters (Revit.ParameterSet parameterSetToSet, Revit.ParameterSet parameterSet)
{
foreach (Revit.Parameter param in parameterSetToSet) {
SetParameter(param, parameterSet);
}
}
/// <summary>
/// Create from an existing Revit Element
/// </summary>
/// <param name="GroupType">An existing Revit GroupType</param>
private GroupType(DB.GroupType GroupType)
{
SafeInit(() => InitGroupType(GroupType));
}
/// <summary>
/// Set the internal Element, ElementId, and UniqueId
/// </summary>
/// <param name="GroupType"></param>
private void InternalSetGroupType(DB.GroupType GroupType)
{
InternalGroupType = GroupType;
InternalElementId = GroupType.Id;
InternalUniqueId = GroupType.UniqueId;
}
/// <summary>
/// Initialize a GroupType element
/// </summary>
/// <param name="GroupType">An existing Revit GroupType</param>
private void InitGroupType(DB.GroupType GroupType)
{
InternalSetGroupType(GroupType);
}
/// <summary>
/// Create a space from an existing reference
/// </summary>
/// <param name="GroupType"></param>
/// <param name="isRevitOwned"></param>
/// <returns></returns>
internal static GroupType FromExisting(DB.GroupType GroupType, bool isRevitOwned)
{
return new GroupType(GroupType)
{
//IsRevitOwned = isRevitOwned
};
}
/// <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();
}
/// <summary>
/// Initialize a Space element
/// </summary>
/// <param name="room"></param>
private void InitSpace(DB.Mechanical.Space room)
{
InternalSetSpace(room);
}
private Space(
DB.Level level,
DB.UV point)
{
SafeInit(() => InitSpace(level, point));
}
private void InitRoom(DB.Level level, DB.UV point)
{
DB.Document document = DocumentManager.Instance.CurrentDBDocument;
// This creates a new wall and deletes the old one
TransactionManager.Instance.EnsureInTransaction(document);
//Phase 1 - Check to see if the object exists and should be rebound
var roomElem = ElementBinder.GetElementFromTrace<DB.Architecture.Room>(document);
if (roomElem == null)
roomElem = document.Create.NewRoom(level, point);
InternalSetRoom(roomElem);
TransactionManager.Instance.TransactionTaskDone();
if (roomElem != null)
{
ElementBinder.CleanupAndSetElementForTrace(document, this.InternalElement);
}
else
{
ElementBinder.SetElementForTrace(this.InternalElement);
}
}
/// <summary>
/// Set the internal Element, ElementId, and UniqueId
/// </summary>
/// <param name="room"></param>
private void InternalSetRoom(DB.Architecture.Room room)
{
InternalRoom = room;
InternalElementId = room.Id;
InternalUniqueId = room.UniqueId;
InternalBoundarySegments = GetBoundarySegment();
InternalTransform = GetTransform();
}
/// <summary>
///
/// </summary>
/// <param name="app"></param>
/// <param name="element"></param>
/// <returns></returns>
public static Revit.Element CloneElement( Application app, Revit.Element element )
{
Opening opening = element as Opening;
if( opening != null )
{
return CloneElement( app, opening );
}
BoundaryConditions boundaryConditions = element as BoundaryConditions;
if( boundaryConditions != null )
{
return CloneElement( app, boundaryConditions );
}
AreaLoad areaLoad = element as AreaLoad;
if( areaLoad != null )
{
return CloneElement( app, areaLoad );
}
AreaReinforcement areaReinforcement = element as AreaReinforcement;
if( areaReinforcement != null )
{
return CloneElement( app, areaReinforcement );
}
BeamSystem beamSystem = element as BeamSystem;
if( beamSystem != null )
{
return CloneElement( app, beamSystem );
}
Dimension dimension = element as Dimension;
if( dimension != null )
{
return CloneElement( app, dimension );
}
FamilyInstance familyInstance = element as FamilyInstance;
if( familyInstance != null )
{
return CloneElement( app, familyInstance );
}
Floor floor = element as Floor;
if( floor != null )
{
return CloneElement( app, floor );
}
Grid grid = element as Grid;
if( grid != null )
{
return CloneElement( app, grid );
}
Group group = element as Group;
if( group != null )
{
return CloneElement( app, group );
}
Level level = element as Level;
if( floor != null )
{
return CloneElement( app, floor );
}
LineLoad lineLoad = element as LineLoad;
if( lineLoad != null )
{
return CloneElement( app, lineLoad );
}
LoadCase loadCase = element as LoadCase;
if( loadCase != null )
{
return CloneElement( app, loadCase );
}
LoadCombination loadCombination = element as LoadCombination;
if( loadCombination != null )
{
return CloneElement( app, loadCombination );
}
LoadNature loadNature = element as LoadNature;
if( loadNature != null )
{
return CloneElement( app, loadNature );
}
LoadUsage loadUsage = element as LoadUsage;
if( loadUsage != null )
{
return CloneElement( app, loadUsage );
}
ModelCurve modelCurve = element as ModelCurve;
if( modelCurve != null )
{
return CloneElement( app, modelCurve );
}
PointLoad pointLoad = element as PointLoad;
if( pointLoad != null )
{
return CloneElement( app, pointLoad );
}
Rebar rebar = element as Rebar;
if( rebar != null )
{
return CloneElement( app, rebar );
}
ReferencePlane referencePlane = element as ReferencePlane;
if( referencePlane != null )
{
return CloneElement( app, referencePlane );
}
Room room = element as Room;
if( room != null )
{
return CloneElement( app, room );
}
RoomTag roomTag = element as RoomTag;
if( roomTag != null )
{
return CloneElement( app, roomTag );
}
SketchPlane sketchPlane = element as SketchPlane;
if( sketchPlane != null )
{
return CloneElement( app, sketchPlane );
}
View3D view3D = element as View3D;
if( view3D != null )
{
return CloneElement( app, view3D );
}
ViewDrafting viewDrafting = element as ViewDrafting;
if( viewDrafting != null )
{
return CloneElement( app, viewDrafting );
}
ViewSection viewSection = element as ViewSection;
if( viewSection != null )
{
return CloneElement( app, viewSection );
}
ViewSheet viewSheet = element as ViewSheet;
if( viewSheet != null )
{
return CloneElement( app, viewSheet );
}
Wall wall = element as Wall;
if( wall != null )
{
return CloneElement( app, wall );
}
// this element has not yet been exposed in the Creation Document class
//Debug.Assert(false);
return null;
}
/// <summary>
///
/// </summary>
/// <param name="parameterSetToSet"></param>
/// <param name="parameterSet"></param>
public static void SetParameters(Revit.ParameterSet parameterSetToSet, Revit.ParameterSet parameterSet)
{
foreach (Revit.Parameter param in parameterSetToSet) {
SetParameter(param, parameterSet);
}
}
/// <summary>
/// Create a space from an existing reference
/// </summary>
/// <param name="room"></param>
/// <param name="isRevitOwned"></param>
/// <returns></returns>
internal static CustomRoom FromExisting(DB.Architecture.Room room, bool isRevitOwned)
{
return new CustomRoom(room)
{
//IsRevitOwned = isRevitOwned
};
}
/// <summary>
/// Create from an existing Revit Element
/// </summary>
/// <param name="room">An existing Revit room</param>
private CustomRoom(DB.Architecture.Room room)
{
SafeInit(() => InitRoom(room));
}
/// <summary>
/// Find the nearest level in the active document
/// </summary>
/// <param name="point">The reference point</param>
/// <returns></returns>
private static DB.Level GetNearestLevel(DB.XYZ point)
{
//find all level in the active document
DB.Document doc = DocumentManager.Instance.CurrentDBDocument;
DB.FilteredElementCollector collector = new DB.FilteredElementCollector(doc);
List<DB.Level> activeLevels = collector.OfCategory(DB.BuiltInCategory.OST_Levels).WhereElementIsNotElementType().ToElements().Cast<DB.Level>().ToList();
DB.Level nearestLevel = activeLevels.FirstOrDefault();
double delta = Math.Abs(nearestLevel.ProjectElevation - point.Z);
foreach (DB.Level currentLevel in activeLevels)
{
if (Math.Abs(currentLevel.ProjectElevation - point.Z) < delta)
{
nearestLevel = currentLevel;
delta = Math.Abs(currentLevel.ProjectElevation - point.Z);
}
}
return nearestLevel;
}
/// <summary>
/// Initialize a group element
/// </summary>
/// <param name="group">An existing Revit Group</param>
private void InitGroup(DB.Group group)
{
InternalSetGroup(group);
}
/// <summary>
/// Retrive family instance hosted in boundary elements
/// This is the base function for Windows and Doors
/// </summary>
/// <param name="cat">The category of hosted elements</param>
/// <returns></returns>
private List<FamilyInstance> BoundaryFamilyInstance(DB.BuiltInCategory cat)
{
List<FamilyInstance> output = new List<FamilyInstance>();
//the document of the room
DB.Document doc = InternalElement.Document; // DocumentManager.Instance.CurrentDBDocument;
//Find boundary elements and their associated document
List<DB.ElementId> boundaryElements = new List<DB.ElementId>();
List<DB.Document> boundaryDocuments = new List<DB.Document>();
foreach (DB.BoundarySegment segment in InternalBoundarySegments)
{
DB.Element boundaryElement = doc.GetElement(segment.ElementId);
if (boundaryElement.GetType() == typeof(DB.RevitLinkInstance))
{
DB.RevitLinkInstance linkInstance = boundaryElement as DB.RevitLinkInstance;
boundaryDocuments.Add(linkInstance.GetLinkDocument());
boundaryElements.Add(segment.LinkElementId);
}
else
{
boundaryDocuments.Add(doc);
boundaryElements.Add(segment.ElementId);
}
}
// Create a category filter
DB.ElementCategoryFilter filter = new DB.ElementCategoryFilter(cat);
// Apply the filter to the elements in these documents,
// Use shortcut WhereElementIsNotElementType() to find family instances in all boundary documents
boundaryDocuments = boundaryDocuments.Distinct().ToList();
List<DB.FamilyInstance> familyInstances = new List<DB.FamilyInstance>();
foreach (DB.Document boundaryDocument in boundaryDocuments)
{
DB.FilteredElementCollector collector = new DB.FilteredElementCollector(boundaryDocument);
familyInstances.AddRange(collector.WherePasses(filter).WhereElementIsNotElementType().ToElements().Cast<DB.FamilyInstance>().ToList());
}
//Find all family instance hosted on a boundary element
IEnumerable<DB.FamilyInstance> boundaryFamilyInstances = familyInstances.Where(s => boundaryElements.Contains(s.Host.Id));
//loop on these boundary family instance to find to and from room
foreach (DB.FamilyInstance boundaryFamilyInstance in boundaryFamilyInstances)
{
DB.Phase familyInstancePhase = boundaryFamilyInstance.Document.GetElement(boundaryFamilyInstance.CreatedPhaseId) as DB.Phase;
if (boundaryFamilyInstance.get_FromRoom(familyInstancePhase) != null)
{
if (boundaryFamilyInstance.get_FromRoom(familyInstancePhase).Id == InternalRoom.Id)
{
output.Add(ElementWrapper.ToDSType(boundaryFamilyInstance, true) as FamilyInstance);
continue;
}
}
if (boundaryFamilyInstance.get_ToRoom(familyInstancePhase) != null)
{
if (boundaryFamilyInstance.get_ToRoom(familyInstancePhase).Id == InternalRoom.Id)
{
output.Add(ElementWrapper.ToDSType(boundaryFamilyInstance, true) as FamilyInstance);
}
}
}
output = output.Distinct().ToList();
return output;
}
/// <summary>
/// Set the internal Element, ElementId, and UniqueId
/// </summary>
/// <param name="group"></param>
private void InternalSetGroup(DB.Group group)
{
InternalGroup = group;
InternalElementId = group.Id;
InternalUniqueId = group.UniqueId;
}
private CustomRoom(
DB.Level level,
DB.UV point)
{
SafeInit(() => InitRoom(level, point));
}
private Group(DB.XYZ point, DB.GroupType groupType)
{
SafeInit(() => InitGroup(point,groupType));
}
/// <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
};
}
