//increase the whole letter of a multi segmented grid
private void increaseWholeLetter(Document doc, ref MultiSegmentGrid currentMultiSegGrid, ref char letter, ref char subLetter, ref bool prevGridIsSub)
{
currentMultiSegGrid.Name = WholeName;
subLetter = 'a';
foreach (ElementId eID in currentMultiSegGrid.GetGridIds())
{
Grid currentGridInMultiSegGrid = doc.GetElement(eID) as Grid;
currentGridInMultiSegGrid.Name = WholeName;
}
if (letter != 90)
{
letter++;
WholeName = WholeName.Remove(WholeName.Length - 1) + letter.ToString();
}
else
{
letter = 'A';
char first = WholeName.First();
if (first == 90)
{
WholeName = "A" + letter.ToString();
}
else
{
first++;
WholeName = WholeName.Remove(0);
WholeName = first.ToString() + WholeName + letter.ToString();
}
}
prevGridIsSub = false;
}
// 获取链接模型中多段轴网信息
private void GetAllMultiSegmentGridInfoInLinkDoc()
{
foreach (RevitLinkInstance revitLinkInstance in m_lstLinkInst)
{
Document linkDocument = revitLinkInstance.GetLinkDocument();
if (linkDocument != null && m_doc.ActiveView.ViewType != ViewType.Section)
{
try
{
FilteredElementCollector filteredElementCollector = new FilteredElementCollector(linkDocument, m_uiDoc.ActiveView.Id);
filteredElementCollector.OfClass(typeof(MultiSegmentGrid));
foreach (Element element in filteredElementCollector)
{
MultiSegmentGrid multiSegmentGrid = element as MultiSegmentGrid;
if (multiSegmentGrid != null)
{
ICollection <ElementId> gridIds = multiSegmentGrid.GetGridIds();
foreach (ElementId elementId in gridIds)
{
Grid grid = m_doc.GetElement(elementId) as Grid;
if (grid != null)
{
DrawElement item = new DrawElement(grid, ElemType._MultiSegGrid);
m_DrawElems.Add(item);
}
}
}
}
}
catch (Exception)
{
}
}
}
}
/***************************************************/
public static IBHoMObject FromRevit(this MultiSegmentGrid grid, Discipline discipline, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
switch (discipline)
{
default:
return(grid.GridFromRevit(settings, refObjects));
}
}
//get the total length of the multisegment grid providing the multisegment grid
private double getMultiGridTotalLength(Document doc, MultiSegmentGrid targetMultiSegGrid)
{
double totalLength = 0;
foreach (ElementId eID in targetMultiSegGrid.GetGridIds())
{
Grid currentGrid = doc.GetElement(eID) as Grid;
totalLength += getTheoricalLengthOfTheGrid(currentGrid);
}
return(totalLength);
}
private void increaseSubLetter(Document doc, ref MultiSegmentGrid currentMultiSegGrid, ref Grid prevGrid, ref char subLetter, ref bool prevGridIsSub)
{
currentMultiSegGrid.Name = prevGrid.Name.ElementAt(0).ToString() + "." + subLetter;
foreach (ElementId eID in currentMultiSegGrid.GetGridIds())
{
Grid currentGridInMultiSegGrid = doc.GetElement(eID) as Grid;
currentGridInMultiSegGrid.Name = prevGrid.Name.ElementAt(0).ToString() + "." + subLetter;
}
prevGridIsSub = true;
subLetter++;
}
//increase the whole number of a multi segmented grid
private void increaseWholeNumber(Document doc, ref MultiSegmentGrid currentMultiSegGrid, ref int counter, ref int subCounter, ref bool prevGridIsSub)
{
currentMultiSegGrid.Name = (counter + 1).ToString();
subCounter = 1;
foreach (ElementId eID in currentMultiSegGrid.GetGridIds())
{
Grid currentGridInMultiSegGrid = doc.GetElement(eID) as Grid;
currentGridInMultiSegGrid.Name = (counter + 1).ToString();
}
counter++;
prevGridIsSub = false;
}
//get the length of only the Grids that have the same orientation that the main grid
private double getMultiGridLengthSameOrientationMainGrid(Document doc, MultiSegmentGrid targetMultiSegGrid, Grid targetMainGrid)
{
double totalLength = 0;
foreach (ElementId eID in targetMultiSegGrid.GetGridIds())
{
Grid currentMultiSegGrid = doc.GetElement(eID) as Grid;
if (verifyGridOrientation(currentMultiSegGrid) == verifyGridOrientation(targetMainGrid))
{
Grid currentGrid = doc.GetElement(eID) as Grid;
totalLength += getTheoricalLengthOfTheGrid(currentGrid);
}
}
return(totalLength);
}
/***************************************************/
public static IBHoMObject FromRevit(this MultiSegmentGrid grid, Discipline discipline, Transform transform = null, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
IElement1D result = null;
switch (discipline)
{
default:
result = grid.GridFromRevit(settings, refObjects);
break;
}
if (result != null && transform?.IsIdentity == false)
{
TransformMatrix bHoMTransform = transform.FromRevit();
result = result.ITransform(bHoMTransform);
}
return(result as IBHoMObject);
}
/***************************************************/
public static BH.oM.Geometry.SettingOut.Grid GridFromRevit(this MultiSegmentGrid revitGrid, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
settings = settings.DefaultIfNull();
oM.Geometry.SettingOut.Grid grid = refObjects.GetValue <oM.Geometry.SettingOut.Grid>(revitGrid.Id);
if (grid != null)
{
return(grid);
}
List <Grid> gridSegments = revitGrid.GetGridIds().Select(x => revitGrid.Document.GetElement(x) as Grid).ToList();
if (gridSegments.Count == 0)
{
return(null);
}
else if (gridSegments.Count == 1)
{
return(gridSegments[0].GridFromRevit(settings, refObjects));
}
else
{
List <BH.oM.Geometry.PolyCurve> joinedGridCurves = BH.Engine.Geometry.Compute.IJoin(gridSegments.Select(x => x.Curve.IFromRevit()).ToList());
if (joinedGridCurves.Count != 1)
{
BH.Engine.Reflection.Compute.RecordError(String.Format("Revit grid consists of disjoint segments. Element id: {0}", revitGrid.Id));
return(null);
}
grid = BH.Engine.Geometry.SettingOut.Create.Grid(joinedGridCurves[0]);
grid.Name = revitGrid.Name;
}
//Set identifiers, parameters & custom data
grid.SetIdentifiers(revitGrid);
grid.CopyParameters(revitGrid, settings.ParameterSettings);
grid.SetProperties(revitGrid, settings.ParameterSettings);
refObjects.AddOrReplace(revitGrid.Id, grid);
return(grid);
}
internal IList <GridInfo> RenumberTable(IList <GridInfo> allOrganizedSingleGrids)
{
IList <GridInfo> allOrganizedHorizontalGrids = new List <GridInfo>();
IList <GridInfo> allOrganizedVerticalGrids = new List <GridInfo>();
try
{
foreach (GridInfo currentGrid in allOrganizedSingleGrids)
{
if (currentGrid.orientation == "Horizontal")
{
allOrganizedHorizontalGrids.Add(currentGrid);
}
else
{
allOrganizedVerticalGrids.Add(currentGrid);
}
}
IList <Element> allMultiGrids = new FilteredElementCollector(uidoc.Document).OfClass(typeof(MultiSegmentGrid)).ToElements();
IList <ElementId> allMultiGridsIDs = new List <ElementId>();
foreach (Element e in allMultiGrids)
{
MultiSegmentGrid currentMultiSegGrid = e as MultiSegmentGrid;
allMultiGridsIDs.Add(currentMultiSegGrid.Id);
}
bool isNumber = isVerticalGridsNumbered;
doTheRenumberingOrLettering(uidoc.Document, allOrganizedVerticalGrids, allMultiGridsIDs, isNumber);
isNumber = isNumber ? false : true;
doTheRenumberingOrLettering(uidoc.Document, allOrganizedHorizontalGrids, allMultiGridsIDs, isNumber);
}
catch (Exception excep)
{
ExceptionManager eManager = new ExceptionManager(excep);
}
return(allOrganizedHorizontalGrids.Union(allOrganizedVerticalGrids).ToList());
}
//获取多段轴网信息
private void GetAllMultiSegmentGridInfo()
{
FilteredElementCollector filteredElementCollector = new FilteredElementCollector(m_doc, m_uiDoc.ActiveView.Id);
filteredElementCollector.OfClass(typeof(MultiSegmentGrid));
foreach (Element element in filteredElementCollector)
{
MultiSegmentGrid multiSegmentGrid = element as MultiSegmentGrid;
if (multiSegmentGrid != null)
{
ICollection <ElementId> gridIds = multiSegmentGrid.GetGridIds();
foreach (ElementId elementId in gridIds)
{
Grid grid = m_doc.GetElement(elementId) as Grid;
if (grid != null)
{
DrawElement item = new DrawElement(grid, ElemType._MultiSegGrid);
m_DrawElems.Add(item);
}
}
}
}
}
void ReconstructGridByCurve
(
Document doc,
ref Autodesk.Revit.DB.Element element,
Rhino.Geometry.Curve curve,
Optional <Autodesk.Revit.DB.GridType> type,
Optional <string> name
)
{
var scaleFactor = 1.0 / Revit.ModelUnits;
curve = curve.ChangeUnits(scaleFactor);
SolveOptionalType(ref type, doc, ElementTypeGroup.GridType, nameof(type));
var parametersMask = name == Optional.Nothig ?
new BuiltInParameter[]
{
BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM,
BuiltInParameter.ELEM_FAMILY_PARAM,
BuiltInParameter.ELEM_TYPE_PARAM
} :
new BuiltInParameter[]
{
BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM,
BuiltInParameter.ELEM_FAMILY_PARAM,
BuiltInParameter.ELEM_TYPE_PARAM,
BuiltInParameter.DATUM_TEXT
};
if (curve.TryGetLine(out var line, Revit.VertexTolerance))
{
ReplaceElement(ref element, Grid.Create(doc, line.ToHost()), parametersMask);
ChangeElementTypeId(ref element, type.Value.Id);
}
else if (curve.TryGetArc(out var arc, Revit.VertexTolerance))
{
ReplaceElement(ref element, Grid.Create(doc, arc.ToHost()), parametersMask);
ChangeElementTypeId(ref element, type.Value.Id);
}
else
{
using (var curveLoop = new CurveLoop())
using (var polyline = curve.ToArcsAndLines(Revit.VertexTolerance, Revit.AngleTolerance, Revit.ShortCurveTolerance, double.PositiveInfinity))
{
int count = polyline.SegmentCount;
for (int s = 0; s < count; ++s)
{
var segment = polyline.SegmentCurve(s);
if (segment is Rhino.Geometry.LineCurve l)
{
curveLoop.Append(l.ToHost());
}
else if (segment is Rhino.Geometry.ArcCurve a)
{
curveLoop.Append(a.ToHost());
}
else
{
ThrowArgumentException(nameof(curve), "Invalid curve type.");
}
}
curve.TryGetPlane(out var plane);
var sketchPlane = SketchPlane.Create(doc, plane.ToHost());
ReplaceElement(ref element, doc.GetElement(MultiSegmentGrid.Create(doc, type.Value.Id, curveLoop, sketchPlane.Id)), parametersMask);
}
}
if (name != Optional.Nothig && element != null)
{
try { element.Name = name.Value; }
catch (Autodesk.Revit.Exceptions.ArgumentException e)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, $"{e.Message.Replace($".{Environment.NewLine}", ". ")}");
}
}
}
protected GCGridMulti(MultiSegmentGrid grid)
: base(grid)
{
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static Element ToRevitGrid(this oM.Geometry.SettingOut.Grid grid, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null)
{
Element revitGrid = refObjects.GetValue <Grid>(document, grid.BHoM_Guid);
if (revitGrid != null)
{
return(revitGrid);
}
settings = settings.DefaultIfNull();
if (BH.Engine.Geometry.Query.IIsClosed(grid.Curve))
{
BH.Engine.Reflection.Compute.RecordError("Element could not be created: Revit allows only open curve-based grids. BHoM_Guid: " + grid.BHoM_Guid);
return(null);
}
List <BH.oM.Geometry.ICurve> gridCurves = BH.Engine.Geometry.Query.ISubParts(grid.Curve).ToList();
if (gridCurves.Count == 0)
{
return(null);
}
else if (gridCurves.Count == 1)
{
Curve curve = grid.Curve.IToRevit();
if (curve is Line)
{
revitGrid = Grid.Create(document, (Line)curve);
}
else if (curve is Arc)
{
revitGrid = Grid.Create(document, (Arc)curve);
}
else
{
BH.Engine.Reflection.Compute.RecordError("Element could not be created: Revit allows only line- and arc-based grids. BHoM_Guid: " + grid.BHoM_Guid);
return(null);
}
}
else
{
CurveLoop loop = new CurveLoop();
foreach (BH.oM.Geometry.ICurve curve in gridCurves)
{
Curve revitCurve = curve.IToRevit();
if (revitCurve is Line || revitCurve is Arc)
{
loop.Append(revitCurve);
}
else
{
BH.Engine.Reflection.Compute.RecordError("Element could not be created: Revit allows only line- and arc-based grids. BHoM_Guid: " + grid.BHoM_Guid);
return(null);
}
}
Plane plane;
try
{
plane = loop.GetPlane();
}
catch
{
BH.Engine.Reflection.Compute.RecordError("Grid curves need to be coplanar. BHoM_Guid: " + grid.BHoM_Guid);
return(null);
}
SketchPlane sketchPlane = SketchPlane.Create(document, plane);
ElementId gridTypeId = document.GetDefaultElementTypeId(ElementTypeGroup.GridType);
ElementId gridId = MultiSegmentGrid.Create(document, gridTypeId, loop, sketchPlane.Id);
revitGrid = document.GetElement(gridId);
}
revitGrid.CheckIfNullPush(grid);
if (revitGrid == null)
{
return(null);
}
try
{
revitGrid.Name = grid.Name;
}
catch
{
BH.Engine.Reflection.Compute.RecordWarning(String.Format("Grid name '{0}' was not unique, name '{1}' has been assigned instead. BHoM_Guid: {2}", grid.Name, revitGrid.Name, grid.BHoM_Guid));
}
// Copy parameters from BHoM object to Revit element
revitGrid.CopyParameters(grid, settings);
refObjects.AddOrReplace(grid, revitGrid);
return(revitGrid);
}
private void doTheRenumberingOrLettering(Document doc, IList <GridInfo> targetListOfGrids, IList <ElementId> allMultiGridsIDs, bool isNumber)
{
Grid prevGrid = null;
bool prevGridIsSub = false;
int counter = 0;
int subCounter = 1;
char letter = 'A';
char subLetter = 'a';
WholeName = "A";
double currentGridLength = 0;
double prevGridLength = 0;
IList <ElementId> allMultiGridSubGridsIDs = new List <ElementId>();
foreach (ElementId currentMultiGridId in allMultiGridsIDs)
{
allMultiGridSubGridsIDs = allMultiGridSubGridsIDs.Union((uidoc.Document.GetElement(currentMultiGridId) as MultiSegmentGrid).GetGridIds()).ToList();
}
foreach (GridInfo currentGridInfo in targetListOfGrids)
{
Grid currentGrid = null;
currentGrid = uidoc.Document.GetElement(new ElementId(currentGridInfo.Id)) as Grid;
if (allMultiGridSubGridsIDs.Contains(new ElementId(currentGridInfo.Id)))
{
MultiSegmentGrid currentMultiSegGrid = doc.GetElement(MultiSegmentGrid.GetMultiSegementGridId(currentGrid)) as MultiSegmentGrid;
currentGridLength = getMultiGridLengthSameOrientationMainGrid(doc, currentMultiSegGrid, currentGrid);
}
else
{
currentGridLength = getTheoricalLengthOfTheGrid(currentGrid);
}
if (prevGrid != null)
{
if (allMultiGridsIDs.Contains(MultiSegmentGrid.GetMultiSegementGridId(prevGrid)))
{
MultiSegmentGrid PrevMultiSegGrid = doc.GetElement(MultiSegmentGrid.GetMultiSegementGridId(prevGrid)) as MultiSegmentGrid;
prevGridLength = getMultiGridLengthSameOrientationMainGrid(doc, PrevMultiSegGrid, prevGrid);
}
else
{
prevGridLength = getTheoricalLengthOfTheGrid(prevGrid);
}
GridInfo prevGridInfo = targetListOfGrids.Where(g => g.Id == prevGrid.Id.IntegerValue).FirstOrDefault();
if (canUseSubNumering)
{
if (CompareGridLength(prevGridLength, currentGridLength) == GridLength.Equal)
{
if (prevGridIsSub == false)
{
if (isNumber)
{
currentGridInfo.newName = increaseWholeNumber(doc, currentGridInfo, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGridInfo.newName = increaseWholeLetter(doc, currentGridInfo, ref letter, ref subLetter, ref prevGridIsSub);
}
}
if (prevGridIsSub == true)
{
if (isNumber)
{
currentGridInfo.newName = increaseSubNumber(doc, currentGridInfo, ref prevGridInfo, ref subCounter, ref prevGridIsSub);
}
else
{
currentGridInfo.newName = increaseSubLetter(doc, currentGridInfo, ref prevGridInfo, ref subLetter, ref prevGridIsSub);
}
}
}
if (CompareGridLength(prevGridLength, currentGridLength) == GridLength.Bigger)
{
if (isNumber)
{
currentGridInfo.newName = increaseSubNumber(doc, currentGridInfo, ref prevGridInfo, ref subCounter, ref prevGridIsSub);
}
else
{
currentGridInfo.newName = increaseSubLetter(doc, currentGridInfo, ref prevGridInfo, ref subLetter, ref prevGridIsSub);
}
}
if (CompareGridLength(prevGridLength, currentGridLength) == GridLength.Smaller)
{
if (isNumber)
{
currentGridInfo.newName = increaseWholeNumber(doc, currentGridInfo, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGridInfo.newName = increaseWholeLetter(doc, currentGridInfo, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
if (isNumber)
{
currentGridInfo.newName = increaseWholeNumber(doc, currentGridInfo, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGridInfo.newName = increaseWholeLetter(doc, currentGridInfo, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
if (isNumber)
{
currentGridInfo.newName = increaseWholeNumber(doc, currentGridInfo, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGridInfo.newName = increaseWholeLetter(doc, currentGridInfo, ref letter, ref subLetter, ref prevGridIsSub);
}
}
prevGrid = currentGrid;
}
}
internal void ApplyTheRenumberingOnTheActualGrids(IList <GridInfo> targetGridInfoList)
{
IList <Element> allMultiGrids = new FilteredElementCollector(uidoc.Document).OfClass(typeof(MultiSegmentGrid)).ToElements();
IList <ElementId> allMultiGridsIDs = new List <ElementId>();
foreach (Element currentMultiGridElement in allMultiGrids)
{
MultiSegmentGrid currentMultiGrid = currentMultiGridElement as MultiSegmentGrid;
if (currentMultiGrid == null)
{
continue;
}
allMultiGridsIDs = allMultiGridsIDs.Union(currentMultiGrid.GetGridIds()).ToList();
}
foreach (GridInfo currentGridInfo in targetGridInfoList)
{
bool isCurrentGridPartOfMultiGridItem = false;
Grid currentGrid = uidoc.Document.GetElement(new ElementId(currentGridInfo.Id)) as Grid;
if (currentGrid == null)
{
isCurrentGridPartOfMultiGridItem = false;
continue;
}
if (allMultiGridsIDs.Contains(currentGrid.Id))
{
isCurrentGridPartOfMultiGridItem = true;
}
if (isCurrentGridPartOfMultiGridItem)
{
ElementId multisegGridID = MultiSegmentGrid.GetMultiSegementGridId(currentGrid);
MultiSegmentGrid multiSegGrid = uidoc.Document.GetElement(multisegGridID) as MultiSegmentGrid;
if (multiSegGrid == null)
{
continue;
}
foreach (ElementId currentMultiSegGridMemberID in multiSegGrid.GetGridIds())
{
Grid currentMultiSegGrid = uidoc.Document.GetElement(currentMultiSegGridMemberID) as Grid;
if (currentMultiSegGrid == null)
{
continue;
}
currentMultiSegGrid.Name = currentGridInfo.newName;
}
multiSegGrid.Name = currentGridInfo.newName;
}
else
{
if (currentGrid == null)
{
continue;
}
currentGrid.Name = currentGridInfo.newName;
}
}
}
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIDocument uidoc = commandData.Application.ActiveUIDocument;
Document doc = uidoc.Document;
Selection sel = uidoc.Selection;
IList <Element> allGrids = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Grids).WhereElementIsNotElementType().ToElements();
IList <Element> allMultiGrids = new FilteredElementCollector(doc).OfClass(typeof(MultiSegmentGrid)).ToElements();
IList <ElementId> allMultiGridsIDs = new List <ElementId>();
IList <Grid> allSingleGrids = new List <Grid>();
IList <string> allGridNames = new List <string>();
try
{
if (allGrids.Count == 0)
{
message = "Não foi possível encontrar eixos no projeto, por favor crie-os e rode o comando novamente";
return(Result.Failed);
}
RenumberGridsUI currentGridUI = new RenumberGridsUI();
currentGridUI.ShowDialog();
if (currentGridUI.DialogResult == false)
{
return(Result.Cancelled);
}
foreach (Element e in allMultiGrids)
{
MultiSegmentGrid currentMultiSegGrid = e as MultiSegmentGrid;
allMultiGridsIDs.Add(currentMultiSegGrid.Id);
}
foreach (Element e in allGrids)
{
Grid currentGrid = e as Grid;
if (allGridNames.Contains(currentGrid.Name))
{
continue;
}
allGridNames.Add(currentGrid.Name);
allSingleGrids.Add(currentGrid);
}
IList <Grid> allOrganizedSingleGrids = new List <Grid>();
foreach (Grid currentGrid in allSingleGrids)
{
if (allMultiGridsIDs.Contains(MultiSegmentGrid.GetMultiSegementGridId(currentGrid)))
{
continue;
}
allOrganizedSingleGrids.Add(currentGrid);
}
IList <Grid> allOrganizedHorizontalGrids = new List <Grid>();
IList <Grid> allOrganizedVerticalGrids = new List <Grid>();
IList <Grid> allOrganizedHorizontalMainGridsFromMultiGrids = new List <Grid>();
IList <Grid> allOrganizedVerticalMainGridsFromMultiGrids = new List <Grid>();
foreach (Grid currentGrid in allOrganizedSingleGrids)
{
if (verifyGridOrientation(currentGrid) == "isVertical")
{
allOrganizedVerticalGrids.Add(currentGrid);
}
else
{
allOrganizedHorizontalGrids.Add(currentGrid);
}
}
foreach (Element e in allMultiGrids)
{
MultiSegmentGrid curentMultiGrid = e as MultiSegmentGrid;
IList <ElementId> GridsIds = curentMultiGrid.GetGridIds().ToList();
IList <Curve> gridCurves = new List <Curve>();
Grid MainGrid = null;
foreach (ElementId eID in GridsIds)
{
gridCurves.Add((doc.GetElement(eID) as Grid).Curve);
}
XYZ farAwayPoint = new XYZ(9999999, -9999999, 9999999);
gridCurves = gridCurves.Where(c => c is Curve).OrderBy(p => p.Distance(farAwayPoint)).ToList();
Curve lastCurve = gridCurves.Last();
//Organize the lists to the order of positioning
//I dont know why, but I had to put a "where" query that always pass just to make "OrderBy" and "OrderByDescending" work
ElementId MainGridID = allGrids.Where(g => g is Grid).OrderBy(d => lastCurve.Distance((d as Grid).Curve.GetEndPoint(1))).First().Id;
MainGrid = doc.GetElement(MainGridID) as Grid;
if (verifyGridOrientation(MainGrid) == "isVertical")
{
allOrganizedVerticalMainGridsFromMultiGrids.Add(MainGrid);
}
else
{
allOrganizedHorizontalMainGridsFromMultiGrids.Add(MainGrid);
}
}
//Organize the lists to the order of positioning
//I dont know why, but I had to put a "where" query that always pass just to make "OrderBy" and "OrderByDescending" work
allOrganizedHorizontalGrids = allOrganizedHorizontalGrids.Union(allOrganizedHorizontalMainGridsFromMultiGrids).Where(g => g is Grid).OrderByDescending(f => f.Curve.GetEndPoint(0).Y).ToList();
allOrganizedVerticalGrids = allOrganizedVerticalGrids.Union(allOrganizedVerticalMainGridsFromMultiGrids).Where(g => g is Grid).OrderBy(f => f.Curve.GetEndPoint(0).X).ToList();
using (TransactionGroup tG = new TransactionGroup(doc, "Renumerar Eixos"))
{
tG.Start();
using (Transaction RenameAllGrids = new Transaction(doc, "Ajustar Nomes"))
{
RenameAllGrids.Start();
for (int i = 0; i < allGrids.Count; i++)
{
Grid currentGrid = allGrids.ElementAt(i) as Grid;
currentGrid.Name = string.Format("ONBOX {0}", i.ToString());
}
RenameAllGrids.Commit();
}
using (Transaction RenumberVerticalGrids = new Transaction(doc, "Renumerar Eixos Verticais"))
{
RenumberVerticalGrids.Start();
bool isNumber = true;
if (isVerticalGridsNumbered == false)
{
isNumber = false;
}
doTheRenumberingOrLettering(doc, allOrganizedVerticalGrids, allOrganizedVerticalMainGridsFromMultiGrids, allMultiGridsIDs, isNumber);
RenumberVerticalGrids.Commit();
}
using (Transaction RenumberHorizontalGrids = new Transaction(doc, "Renumerar Eixos Verticais"))
{
RenumberHorizontalGrids.Start();
bool isNumber = false;
if (isVerticalGridsNumbered == false)
{
isNumber = true;
}
doTheRenumberingOrLettering(doc, allOrganizedHorizontalGrids, allOrganizedHorizontalMainGridsFromMultiGrids, allMultiGridsIDs, isNumber);
RenumberHorizontalGrids.Commit();
}
using (Transaction regenerate = new Transaction(doc, "Regen"))
{
regenerate.Start();
doc.Regenerate();
uidoc.RefreshActiveView();
regenerate.Commit();
}
tG.Assimilate();
}
Debug.Print("end");
}
catch (Exception excep)
{
ExceptionManager eManager = new ExceptionManager(excep);
return(Result.Cancelled);
}
return(Result.Succeeded);
}
private void doTheRenumberingOrLettering(Document doc, IList <Grid> targetListOfGrids, IList <Grid> targetListOfGridsFromMultiSegGrids, IList <ElementId> allMultiGridsIDs, bool isNumber)
{
Grid prevGrid = null;
bool prevGridIsSub = false;
int counter = 0;
int subCounter = 1;
char letter = 'A';
char subLetter = 'a';
double currentGridLength = 0;
double prevGridLength = 0;
foreach (Grid currentGrid in targetListOfGrids)
{
if (targetListOfGridsFromMultiSegGrids.Contains(currentGrid))
{
MultiSegmentGrid currentMultiSegGrid = doc.GetElement(MultiSegmentGrid.GetMultiSegementGridId(currentGrid)) as MultiSegmentGrid;
currentGridLength = getMultiGridLengthSameOrientationMainGrid(doc, currentMultiSegGrid, currentGrid);
if (prevGrid != null)
{
if (allMultiGridsIDs.Contains(MultiSegmentGrid.GetMultiSegementGridId(prevGrid)))
{
MultiSegmentGrid PrevMultiSegGrid = doc.GetElement(MultiSegmentGrid.GetMultiSegementGridId(prevGrid)) as MultiSegmentGrid;
prevGridLength = getMultiGridLengthSameOrientationMainGrid(doc, PrevMultiSegGrid, prevGrid);
}
else
{
prevGridLength = getTheoricalLengthOfTheGrid(prevGrid);
}
if (canUseSubNumering)
{
if (isBiggerEqualSmaller(prevGridLength, currentGridLength) == "isEqual")
{
if (prevGridIsSub == false)
{
if (isNumber)
{
increaseWholeNumber(doc, ref currentMultiSegGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
increaseWholeLetter(doc, ref currentMultiSegGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
if (prevGridIsSub == true)
{
if (isNumber)
{
increaseSubNumber(doc, ref currentMultiSegGrid, ref prevGrid, ref subCounter, ref prevGridIsSub);
}
else
{
increaseSubLetter(doc, ref currentMultiSegGrid, ref prevGrid, ref subLetter, ref prevGridIsSub);
}
}
}
if (isBiggerEqualSmaller(prevGridLength, currentGridLength) == "isBigger")
{
if (isNumber)
{
increaseSubNumber(doc, ref currentMultiSegGrid, ref prevGrid, ref subCounter, ref prevGridIsSub);
}
else
{
increaseSubLetter(doc, ref currentMultiSegGrid, ref prevGrid, ref subLetter, ref prevGridIsSub);
}
}
if (isBiggerEqualSmaller(prevGridLength, currentGridLength) == "isSmaller")
{
if (isNumber)
{
increaseWholeNumber(doc, ref currentMultiSegGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
increaseWholeLetter(doc, ref currentMultiSegGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
if (isNumber)
{
increaseWholeNumber(doc, ref currentMultiSegGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
increaseWholeLetter(doc, ref currentMultiSegGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
if (isNumber)
{
increaseWholeNumber(doc, ref currentMultiSegGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
increaseWholeLetter(doc, ref currentMultiSegGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
currentGridLength = getTheoricalLengthOfTheGrid(currentGrid);
if (prevGrid != null)
{
if (allMultiGridsIDs.Contains(MultiSegmentGrid.GetMultiSegementGridId(prevGrid)))
{
MultiSegmentGrid PrevMultiSegGrid = doc.GetElement(MultiSegmentGrid.GetMultiSegementGridId(prevGrid)) as MultiSegmentGrid;
prevGridLength = getMultiGridLengthSameOrientationMainGrid(doc, PrevMultiSegGrid, prevGrid);
}
else
{
prevGridLength = getTheoricalLengthOfTheGrid(prevGrid);
}
if (canUseSubNumering)
{
if (isBiggerEqualSmaller(prevGridLength, currentGridLength) == "isEqual")
{
if (prevGridIsSub == false)
{
if (isNumber)
{
currentGrid.Name = increaseWholeNumber(doc, currentGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGrid.Name = increaseWholeLetter(doc, currentGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
if (prevGridIsSub == true)
{
if (isNumber)
{
currentGrid.Name = increaseSubNumber(doc, currentGrid, ref prevGrid, ref subCounter, ref prevGridIsSub);
}
else
{
currentGrid.Name = increaseSubLetter(doc, currentGrid, ref prevGrid, ref subLetter, ref prevGridIsSub);
}
}
}
if (isBiggerEqualSmaller(prevGridLength, currentGridLength) == "isBigger")
{
if (isNumber)
{
currentGrid.Name = increaseSubNumber(doc, currentGrid, ref prevGrid, ref subCounter, ref prevGridIsSub);
}
else
{
currentGrid.Name = increaseSubLetter(doc, currentGrid, ref prevGrid, ref subLetter, ref prevGridIsSub);
}
}
if (isBiggerEqualSmaller(prevGridLength, currentGridLength) == "isSmaller")
{
if (isNumber)
{
currentGrid.Name = increaseWholeNumber(doc, currentGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGrid.Name = increaseWholeLetter(doc, currentGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
if (isNumber)
{
currentGrid.Name = increaseWholeNumber(doc, currentGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGrid.Name = increaseWholeLetter(doc, currentGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
else
{
if (isNumber)
{
currentGrid.Name = increaseWholeNumber(doc, currentGrid, ref counter, ref subCounter, ref prevGridIsSub);
}
else
{
currentGrid.Name = increaseWholeLetter(doc, currentGrid, ref letter, ref subLetter, ref prevGridIsSub);
}
}
}
prevGrid = currentGrid;
}
}
void ReconstructGridByCurve
(
Document doc,
ref Autodesk.Revit.DB.Element element,
Rhino.Geometry.Curve curve,
Optional <Autodesk.Revit.DB.GridType> type
)
{
var scaleFactor = 1.0 / Revit.ModelUnits;
if (scaleFactor != 1.0)
{
curve.Scale(scaleFactor);
}
SolveOptionalType(ref type, doc, ElementTypeGroup.GridType, nameof(type));
if (curve.TryGetLine(out var line, Revit.VertexTolerance))
{
ReplaceElement(ref element, Grid.Create(doc, line.ToHost()));
ChangeElementTypeId(ref element, type.Value.Id);
}
else if (curve.TryGetArc(out var arc, Revit.VertexTolerance))
{
ReplaceElement(ref element, Grid.Create(doc, arc.ToHost()));
ChangeElementTypeId(ref element, type.Value.Id);
}
else
{
using (var curveLoop = new CurveLoop())
using (var polyline = curve.ToArcsAndLines(Revit.VertexTolerance, Revit.AngleTolerance, Revit.ShortCurveTolerance, double.PositiveInfinity))
{
int count = polyline.SegmentCount;
for (int s = 0; s < count; ++s)
{
var segment = polyline.SegmentCurve(s);
if (segment is Rhino.Geometry.LineCurve l)
{
curveLoop.Append(l.ToHost());
}
else if (segment is Rhino.Geometry.ArcCurve a)
{
curveLoop.Append(a.ToHost());
}
else
{
ThrowArgumentException(nameof(curve), "Invalid curve type.");
}
}
curve.TryGetPlane(out var plane);
var sketchPlane = SketchPlane.Create(doc, plane.ToHost());
var parametersMask = new BuiltInParameter[]
{
BuiltInParameter.ELEM_FAMILY_AND_TYPE_PARAM,
BuiltInParameter.ELEM_FAMILY_PARAM,
BuiltInParameter.ELEM_TYPE_PARAM
};
ReplaceElement(ref element, doc.GetElement(MultiSegmentGrid.Create(doc, type.Value.Id, curveLoop, sketchPlane.Id)), parametersMask);
}
}
}
void CommitInstance
(
Document doc, IGH_DataAccess DA, int Iteration,
Rhino.Geometry.Curve axis,
GridType gridType
)
{
var element = PreviousElement(doc, Iteration);
if (!element?.Pinned ?? false)
{
ReplaceElement(doc, DA, Iteration, element);
}
else
{
try
{
var scaleFactor = 1.0 / Revit.ModelUnits;
if (scaleFactor != 1.0)
{
axis.Scale(scaleFactor);
}
{
if (axis is Rhino.Geometry.PolyCurve polycurve && polycurve.SegmentCount == 1)
{
axis = polycurve.SegmentCurve(0);
}
if (axis is Rhino.Geometry.LineCurve line)
{
element = CopyParametersFrom(Grid.Create(doc, line.ToHost()), element);
}
else if (axis is Rhino.Geometry.ArcCurve arc)
{
element = CopyParametersFrom(Grid.Create(doc, arc.ToHost()), element);
}
else
{
using (var curveLoop = new CurveLoop())
using (var polyline = axis.ToArcsAndLines(Revit.VertexTolerance * 10.0, Revit.AngleTolerance, Revit.ShortCurveTolerance, double.PositiveInfinity))
{
int count = polyline.SegmentCount;
for (int s = 0; s < count; ++s)
{
var segment = polyline.SegmentCurve(s);
if (segment is Rhino.Geometry.LineCurve l)
{
curveLoop.Append(l.ToHost());
}
else if (segment is Rhino.Geometry.ArcCurve a)
{
curveLoop.Append(a.ToHost());
}
else
{
throw new ArgumentException();
}
}
axis.TryGetPlane(out var plane);
var sketchPlane = SketchPlane.Create(doc, plane.ToHost());
element = CopyParametersFrom(doc.GetElement(MultiSegmentGrid.Create(doc, gridType.Id, curveLoop, sketchPlane.Id)), element);
}
}
}
if (gridType.Id != element.GetTypeId())
{
var newElmentId = element.ChangeTypeId(gridType.Id);
if (newElmentId != ElementId.InvalidElementId)
{
element = doc.GetElement(newElmentId);
}
}
ReplaceElement(doc, DA, Iteration, element);
}
catch (Exception e)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, e.Message);
ReplaceElement(doc, DA, Iteration, null);
}
}
}
protected AGCGridBase(MultiSegmentGrid grid)
: base(grid)
{
}