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);
}
}
}
/***************************************************/
/**** 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);
}
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}", ". ")}");
}
}
}
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);
}
}
}