static internal BRepBuilderSurfaceGeometry ToHost(this Rhino.Geometry.BrepFace faceSurface)
{
using (var nurbsSurface = faceSurface.ToNurbsSurface())
{
{
var domainU = nurbsSurface.Domain(0);
Debug.Assert(!nurbsSurface.GetNextDiscontinuity(0, Continuity.C2_continuous, domainU.Min, domainU.Max, out var tU));
var domainV = nurbsSurface.Domain(1);
Debug.Assert(!nurbsSurface.GetNextDiscontinuity(1, Continuity.C2_continuous, domainV.Min, domainV.Max, out var tV));
}
var degreeU = nurbsSurface.Degree(0);
var degreeV = nurbsSurface.Degree(1);
var knotsU = nurbsSurface.KnotsU.ToHost();
var knotsV = nurbsSurface.KnotsV.ToHost();
var controlPoints = nurbsSurface.Points.ToHost();
Debug.Assert(degreeU >= 1);
Debug.Assert(degreeV >= 1);
Debug.Assert(knotsU.Count >= 2 * (degreeU + 1));
Debug.Assert(knotsV.Count >= 2 * (degreeV + 1));
Debug.Assert(controlPoints.Count == (knotsU.Count - degreeU - 1) * (knotsV.Count - degreeV - 1));
try
{
if (nurbsSurface.IsRational)
{
var weights = new List <double>(controlPoints.Count);
foreach (var p in nurbsSurface.Points)
{
Debug.Assert(p.Weight > 0.0);
weights.Add(p.Weight);
}
return(BRepBuilderSurfaceGeometry.CreateNURBSSurface
(
degreeU, degreeV, knotsU, knotsV, controlPoints, weights, false, null
));
}
else
{
return(BRepBuilderSurfaceGeometry.CreateNURBSSurface
(
degreeU, degreeV, knotsU, knotsV, controlPoints, false, null
));
}
}
catch (Autodesk.Revit.Exceptions.ApplicationException e)
{
Debug.Fail(e.Source, e.Message);
}
}
return(null);
}
static internal BRepBuilderSurfaceGeometry Convert(Rhino.Geometry.Surface faceSurface)
{
switch (faceSurface)
{
case Rhino.Geometry.NurbsSurface nurbsSurface:
var degreeU = nurbsSurface.Degree(0);
var degreeV = nurbsSurface.Degree(1);
var knotsU = Convert(nurbsSurface.KnotsU);
var knotsV = Convert(nurbsSurface.KnotsV);
var controlPoints = Convert(nurbsSurface.Points);
Debug.Assert(degreeU >= 1);
Debug.Assert(degreeV >= 1);
Debug.Assert(knotsU.Count >= 2 * (degreeU + 1));
Debug.Assert(knotsV.Count >= 2 * (degreeV + 1));
Debug.Assert(controlPoints.Count == (knotsU.Count - degreeU - 1) * (knotsV.Count - degreeV - 1));
try
{
if (nurbsSurface.IsRational)
{
var weights = new List <double>(controlPoints.Count);
foreach (var p in nurbsSurface.Points)
{
Debug.Assert(p.Weight > 0.0);
weights.Add(p.Weight);
}
return(BRepBuilderSurfaceGeometry.CreateNURBSSurface
(
degreeU, degreeV, knotsU, knotsV, controlPoints, weights, false, null
));
}
else
{
return(BRepBuilderSurfaceGeometry.CreateNURBSSurface
(
degreeU, degreeV, knotsU, knotsV, controlPoints, false, null
));
}
}
catch (Autodesk.Revit.Exceptions.ApplicationException e)
{
Debug.Fail(e.Source, e.Message);
return(null);
}
}
return(Convert(faceSurface.ToNurbsSurface()));
}
static private BRepBuilderSurfaceGeometry BuildFaceSurface(Rhino.Geometry.BrepFace faceSurface)
{
using (var nurbsSurface = faceSurface.ToNurbsSurface())
{
var degreeU = nurbsSurface.Degree(0);
var degreeV = nurbsSurface.Degree(1);
var knotsU = nurbsSurface.KnotsU.ToHost();
var knotsV = nurbsSurface.KnotsV.ToHost();
var controlPoints = nurbsSurface.Points.ToHost();
Debug.Assert(degreeU >= 1);
Debug.Assert(degreeV >= 1);
Debug.Assert(knotsU.Count >= 2 * (degreeU + 1));
Debug.Assert(knotsV.Count >= 2 * (degreeV + 1));
Debug.Assert(controlPoints.Count == (knotsU.Count - degreeU - 1) * (knotsV.Count - degreeV - 1));
try
{
if (nurbsSurface.IsRational)
{
var weights = new List <double>(controlPoints.Count);
foreach (var p in nurbsSurface.Points)
{
Debug.Assert(p.Weight > 0.0);
weights.Add(p.Weight);
}
return(BRepBuilderSurfaceGeometry.CreateNURBSSurface
(
degreeU, degreeV, knotsU, knotsV, controlPoints, weights, false, null
));
}
else
{
return(BRepBuilderSurfaceGeometry.CreateNURBSSurface
(
degreeU, degreeV, knotsU, knotsV, controlPoints, false, null
));
}
}
catch (Autodesk.Revit.Exceptions.ApplicationException e)
{
Debug.Fail(e.Source, e.Message);
}
}
return(null);
}
private BRepBuilderSurfaceGeometry StartCollectingNURBSFace(IFCBSplineSurfaceWithKnots bSplineSurfaceWithKnots, Transform localTransform)
{
if (bSplineSurfaceWithKnots == null)
{
return(null);
}
IFCRationalBSplineSurfaceWithKnots rationalBSplineSurfaceWithKnots = (bSplineSurfaceWithKnots as IFCRationalBSplineSurfaceWithKnots);
IList <double> knotsU = IFCGeometryUtil.ConvertIFCKnotsToRevitKnots(bSplineSurfaceWithKnots.UMultiplicities, bSplineSurfaceWithKnots.UKnots);
if (knotsU == null || knotsU.Count == 0)
{
throw new InvalidOperationException("No knots in u-direction");
}
IList <double> knotsV = IFCGeometryUtil.ConvertIFCKnotsToRevitKnots(bSplineSurfaceWithKnots.VMultiplicities, bSplineSurfaceWithKnots.VKnots);
if (knotsV == null || knotsV.Count == 0)
{
throw new InvalidOperationException("No knots in v-direction");
}
IList <double> weights = (rationalBSplineSurfaceWithKnots != null) ? rationalBSplineSurfaceWithKnots.WeightsList : null;
IList <XYZ> controlPoints = new List <XYZ>();
foreach (XYZ point in bSplineSurfaceWithKnots.ControlPointsList)
{
controlPoints.Add(localTransform.OfPoint(point));
}
int uDegree = bSplineSurfaceWithKnots.UDegree;
int vDegree = bSplineSurfaceWithKnots.VDegree;
BRepBuilderSurfaceGeometry surfaceGeometry = null;
if (weights == null)
{
surfaceGeometry = BRepBuilderSurfaceGeometry.CreateNURBSSurface(uDegree, vDegree, knotsU, knotsV, controlPoints, false, null);
}
else
{
surfaceGeometry = BRepBuilderSurfaceGeometry.CreateNURBSSurface(uDegree, vDegree, knotsU, knotsV, controlPoints, weights, false, null);
}
return(surfaceGeometry);
}
private static DirectShapeInfo ConvertBrep(Document doc, RhinoObjectInfo rhinoInfo)
{
DirectShapeInfo shapeInfo = new DirectShapeInfo();
try
{
BRepBuilder brepBuilder = null;
Rhino.Geometry.Brep rhinoBrep = rhinoInfo.Geometry as Rhino.Geometry.Brep;
if (rhinoBrep.IsSolid)
{
brepBuilder = new BRepBuilder(BRepType.Solid);
}
else if (rhinoBrep.IsSurface)
{
brepBuilder = new BRepBuilder(BRepType.OpenShell);
}
foreach (Rhino.Geometry.BrepFace brepFace in rhinoBrep.Faces)
{
BRepBuilderGeometryId nurbSplineFaceId = BRepBuilderGeometryId.InvalidGeometryId();
BRepBuilderGeometryId loopId = BRepBuilderGeometryId.InvalidGeometryId();
bool reverse = brepFace.OrientationIsReversed;
if (brepFace.ObjectType == Rhino.DocObjects.ObjectType.Surface)
{
Rhino.Geometry.NurbsSurface nurbsSurface = brepFace.ToNurbsSurface();
Rhino.Geometry.Collections.NurbsSurfacePointList points = nurbsSurface.Points;
int dirU = points.CountU;
int dirV = points.CountV;
int degreeU = nurbsSurface.Degree(0);
int degreeV = nurbsSurface.Degree(1);
// knots
Rhino.Geometry.Collections.NurbsSurfaceKnotList knotsU = nurbsSurface.KnotsU;
Rhino.Geometry.Collections.NurbsSurfaceKnotList knotsV = nurbsSurface.KnotsV;
List <XYZ> controlPoints = new List <XYZ>();
XYZ[][] rvtPoints = new XYZ[dirU][];
double[][] rvtWeights = new double[dirU][];
for (int u = 0; u < dirU; u++)
{
rvtPoints[u] = new XYZ[dirV];
rvtWeights[u] = new double[dirV];
for (int v = 0; v < dirV; v++)
{
// point coordinates at u, v
Rhino.Geometry.Point3d pt = points.GetControlPoint(u, v).Location;
XYZ xyz = new XYZ(pt.X, pt.Y, pt.Z);
rvtPoints[u][v] = xyz;
controlPoints.Add(xyz);
// weights at u, v
rvtWeights[u][v] = points.GetControlPoint(u, v).Weight;
}
}
// knots U
List <double> rvt_knotsU = new List <double>();
rvt_knotsU.Add(knotsU[0]);
for (int i = 0; i < knotsU.Count; i++)
{
rvt_knotsU.Add(knotsU[i]);
}
rvt_knotsU.Add(knotsU[knotsU.Count - 1]);
// knots V
List <double> rvt_knotsV = new List <double>();
rvt_knotsV.Add(knotsV[0]);
for (int i = 0; i < knotsV.Count; i++)
{
rvt_knotsV.Add(knotsV[i]);
}
rvt_knotsV.Add(knotsV[knotsV.Count - 1]);
BRepBuilderSurfaceGeometry brepSurface = BRepBuilderSurfaceGeometry.CreateNURBSSurface(degreeU, degreeV, rvt_knotsU, rvt_knotsV, controlPoints, reverse, null);
nurbSplineFaceId = brepBuilder.AddFace(brepSurface, reverse);
loopId = brepBuilder.AddLoop(nurbSplineFaceId);
}
foreach (Rhino.Geometry.BrepLoop loop in brepFace.Loops)
{
Rhino.Geometry.Curve curve = loop.To3dCurve();
Rhino.Geometry.NurbsCurve nurbsCurve = curve.ToNurbsCurve();
int degree = nurbsCurve.Degree;
List <XYZ> controlPoints = new List <XYZ>();
List <double> weights = new List <double>();
List <double> knots = new List <double>();
for (int i = 0; i < nurbsCurve.Points.Count; i++)
{
Rhino.Geometry.ControlPoint ctrlPoint = nurbsCurve.Points[i];
Rhino.Geometry.Point3d point = ctrlPoint.Location;
XYZ xyz = new XYZ(point.X, point.Y, point.Z);
controlPoints.Add(xyz);
weights.Add(ctrlPoint.Weight);
}
knots.Add(nurbsCurve.Knots[0]);
for (int i = 0; i < nurbsCurve.Knots.Count; i++)
{
double knot = nurbsCurve.Knots[i];
knots.Add(knot);
}
knots.Add(nurbsCurve.Knots[nurbsCurve.Knots.Count - 1]);
Curve rvtCurve = NurbSpline.CreateCurve(degree, knots, controlPoints, weights);
BRepBuilderEdgeGeometry edgeGeo = BRepBuilderEdgeGeometry.Create(rvtCurve);
BRepBuilderGeometryId edgeId = brepBuilder.AddEdge(edgeGeo);
brepBuilder.AddCoEdge(loopId, edgeId, false);
}
brepBuilder.FinishLoop(loopId);
brepBuilder.FinishFace(nurbSplineFaceId);
}
brepBuilder.Finish();
DirectShape shape = DirectShape.CreateElement(doc, new ElementId((int)BuiltInCategory.OST_GenericModel));
shape.ApplicationId = "RhinoBrep";
shape.ApplicationDataId = rhinoInfo.ObjectId.ToString();
if (null != shape)
{
shape.SetShape(brepBuilder);
}
shapeInfo.DirectShapeId = shape.Id;
shapeInfo.RhinoObjectId = rhinoInfo.ObjectId;
}
catch (Exception ex)
{
string message = ex.Message;
MessageBox.Show("Cannot Conver To Brep.\n" + ex.Message);
}
return(shapeInfo);
}
private static GeometryObject ToRevitType(Autodesk.DesignScript.Geometry.Topology topology,
bool performHostUnitConversion,
BRepType type, ElementId materialId)
{
var faces = topology.Faces.ToList();
var brb = new BRepBuilder(type);
var edge2EdgeId = new Dictionary <Edge, BRepBuilderGeometryId>();
//foreach face in solid/surface
foreach (Face protoFace in faces)
{
using (var geom = protoFace.SurfaceGeometry())
{
using (var ngeom = geom.ToNurbsSurface())
{
bool flipped = false;
// Check if the nurbs surface has flipped compared to the original surface
if (geom.NormalAtParameter(.5, .5).Dot(ngeom.NormalAtParameter(.5, .5)) < 0)
{
flipped = true;
}
// Create Revit nurbs surface
var bbface = BRepBuilderSurfaceGeometry.CreateNURBSSurface(ngeom.DegreeU, ngeom.DegreeV,
ngeom.UKnots(), ngeom.VKnots(), ngeom.ControlPoints().SelectMany(x => x.Select(y => y.ToXyz(performHostUnitConversion))).ToList(),
ngeom.Weights().SelectMany(x => x).ToList(),
false,
null);
// Add face
var faceId = brb.AddFace(bbface, flipped);
// Set material
if (materialId != null)
{
brb.SetFaceMaterialId(faceId, materialId);
}
// add loops and connected edges
foreach (var loop in protoFace.Loops)
{
var loopId = brb.AddLoop(faceId);
foreach (var coedge in loop.CoEdges)
{
var edge = coedge.Edge;
BRepBuilderGeometryId edgeId;
if (edge2EdgeId.ContainsKey(edge))
{
edgeId = edge2EdgeId[edge];
}
else
{
var curve = edge.CurveGeometry;
// Revit is already projecting edges onto the surface after checking for loop consistency
// and is quite forgiving even when we use the nurbs surface instead of
// the original surface.
//
// But there are cases when edges ends up slightly outside one of the surfaces and Revit fails.
//
// This is something that we can be improve going forward.
edgeId = brb.AddEdge(BRepBuilderEdgeGeometry.Create(curve.ToRevitType(performHostUnitConversion)));
edge2EdgeId[edge] = edgeId;
}
brb.AddCoEdge(loopId, edgeId, coedge.Reversed);
}
brb.FinishLoop(loopId);
}
brb.FinishFace(faceId);
}
}
}
//clean up everything
edge2EdgeId.ToList().ForEach(x => x.Key.Dispose());
faces.ForEach(x => x.Dispose());
// Get result
var outcome = brb.Finish();
var converted = brb.GetResult();
return(converted);
}
private BRepBuilder CreateNurbsSurface()
{
//Note that we are not creating a closed solid here. It is an open shell.
BRepBuilder brepBuilder = new BRepBuilder(BRepType.OpenShell);
// Create NURBS surface
IList <double> knotsU = new List <double> {
0, 0, 0, 0, 0, 1, 1, 1, 1, 1
};
IList <double> knotsV = new List <double> {
0, 0, 0, 0, 0, 1, 1, 1, 1, 1
};
int degreeU = 4;
int degreeV = 4;
IList <XYZ> controlPoints = new List <XYZ>
{
new XYZ(0, 0, 0), new XYZ(0, 20, 0), new XYZ(0, 40, 0), new XYZ(0, 60, 0), new XYZ(0, 80, 0),
new XYZ(20, 0, 100), new XYZ(20, 20, 200), new XYZ(20, 40, 300), new XYZ(20, 60, 200), new XYZ(20, 80, 100),
new XYZ(40, 0, -100), new XYZ(40, 20, -250), new XYZ(40, 40, -300), new XYZ(40, 60, -250), new XYZ(40, 80, -100),
new XYZ(60, 0, 100), new XYZ(60, 20, 200), new XYZ(60, 40, 300), new XYZ(60, 60, 200), new XYZ(60, 80, 100),
new XYZ(80, 0, 0), new XYZ(80, 20, 0), new XYZ(80, 40, 0), new XYZ(80, 60, 0), new XYZ(80, 80, 0)
};
BRepBuilderSurfaceGeometry nurbsSurface = BRepBuilderSurfaceGeometry.CreateNURBSSurface(degreeU, degreeV, knotsU, knotsV, controlPoints, false /*bReverseOrientation*/, null /*pSurfaceEnvelope*/);
// Create 4 NURBS curves defining the boundary of the NURBS surface that has just been created
IList <double> weights = new List <double> {
1, 1, 1, 1, 1
};
IList <XYZ> backEdgeControlPoints = new List <XYZ> {
new XYZ(0, 0, 0), new XYZ(0, 20, 0), new XYZ(0, 40, 0), new XYZ(0, 60, 0), new XYZ(0, 80, 0)
};
Curve backNurbs = NurbSpline.CreateCurve(4, knotsU, backEdgeControlPoints, weights);
BRepBuilderEdgeGeometry backEdge = BRepBuilderEdgeGeometry.Create(backNurbs);
IList <XYZ> frontEdgeControlPoints = new List <XYZ> {
new XYZ(80, 0, 0), new XYZ(80, 20, 0), new XYZ(80, 40, 0), new XYZ(80, 60, 0), new XYZ(80, 80, 0)
};
Curve frontNurbs = NurbSpline.CreateCurve(4, knotsU, frontEdgeControlPoints, weights);
BRepBuilderEdgeGeometry frontEdge = BRepBuilderEdgeGeometry.Create(frontNurbs);
IList <XYZ> leftEdgeControlPoints = new List <XYZ> {
new XYZ(0, 0, 0), new XYZ(20, 0, 100), new XYZ(40, 0, -100), new XYZ(60, 0, 100), new XYZ(80, 0, 0)
};
Curve leftNurbs = NurbSpline.CreateCurve(4, knotsU, leftEdgeControlPoints, weights);
BRepBuilderEdgeGeometry leftEdge = BRepBuilderEdgeGeometry.Create(leftNurbs);
IList <XYZ> rightEdgeControlPoints = new List <XYZ> {
new XYZ(0, 80, 0), new XYZ(20, 80, 100), new XYZ(40, 80, -100), new XYZ(60, 80, 100), new XYZ(80, 80, 0)
};
Curve rightNurbs = NurbSpline.CreateCurve(4, knotsU, rightEdgeControlPoints, weights);
BRepBuilderEdgeGeometry rightEdge = BRepBuilderEdgeGeometry.Create(rightNurbs);
// Add the geometries to the brepBuilder
BRepBuilderGeometryId nurbSplineFaceId = brepBuilder.AddFace(nurbsSurface, false);
BRepBuilderGeometryId loopId = brepBuilder.AddLoop(nurbSplineFaceId);
BRepBuilderGeometryId backEdgeId = brepBuilder.AddEdge(backEdge);
BRepBuilderGeometryId frontEdgeId = brepBuilder.AddEdge(frontEdge);
BRepBuilderGeometryId leftEdgeId = brepBuilder.AddEdge(leftEdge);
BRepBuilderGeometryId rightEdgeId = brepBuilder.AddEdge(rightEdge);
// Add each edge to the loop
brepBuilder.AddCoEdge(loopId, backEdgeId, true);
brepBuilder.AddCoEdge(loopId, leftEdgeId, false);
brepBuilder.AddCoEdge(loopId, frontEdgeId, false);
brepBuilder.AddCoEdge(loopId, rightEdgeId, true);
brepBuilder.FinishLoop(loopId);
brepBuilder.FinishFace(nurbSplineFaceId);
brepBuilder.Finish();
return(brepBuilder);
}
/***************************************************/
private static bool TryAddSurface(this BRepBuilder brep, NurbsSurface ns)
{
if (ns.IsClosed())
{
BH.Engine.Reflection.Compute.RecordError("Revit does not support closed or periodic nurbs surfaces, convert failed.");
return(false);
}
try
{
List <int> uvCount = ns.UVCount(); // Align to Revit nurbs definition
double[][] weights = new double[uvCount[0]][];
XYZ[][] points = new XYZ[uvCount[0]][];
List <double> uKnots = new List <double>(ns.UKnots);
uKnots.Insert(0, uKnots.First());
uKnots.Add(uKnots.Last());
List <double> vKnots = new List <double>(ns.VKnots);
vKnots.Insert(0, vKnots.First());
vKnots.Add(vKnots.Last());
for (int i = 0; i < uvCount[0]; i++)
{
points[i] = new XYZ[uvCount[1]];
weights[i] = new double[uvCount[1]];
for (int j = 0; j < uvCount[1]; j++)
{
points[i][j] = ns.ControlPoints[j + (uvCount[1] * i)].ToRevit();
weights[i][j] = ns.Weights[j + (uvCount[1] * i)];
}
}
List <XYZ> pointList = new List <XYZ>();
foreach (XYZ[] x in points)
{
pointList.AddRange(x);
}
List <double> weightList = new List <double>();
foreach (double[] x in weights)
{
weightList.AddRange(x);
}
BRepBuilderSurfaceGeometry bbsg = BRepBuilderSurfaceGeometry.CreateNURBSSurface(ns.UDegree, ns.VDegree, uKnots, vKnots, pointList, weightList, false, null);
BRepBuilderGeometryId face = brep.AddFace(bbsg, false);
foreach (SurfaceTrim trim in ns.OuterTrims)
{
BRepBuilderGeometryId loop = brep.AddLoop(face);
foreach (ICurve sp in trim.Curve3d.ISubParts())
{
List <Curve> ccs = sp.IToRevitCurves();
foreach (Curve cc in ccs)
{
BRepBuilderGeometryId edge = brep.AddEdge(BRepBuilderEdgeGeometry.Create(cc));
brep.AddCoEdge(loop, edge, false);
}
}
brep.FinishLoop(loop);
}
foreach (SurfaceTrim trim in ns.InnerTrims)
{
BRepBuilderGeometryId loop = brep.AddLoop(face);
foreach (ICurve sp in trim.Curve3d.ISubParts())
{
List <Curve> ccs = sp.IToRevitCurves();
foreach (Curve cc in ccs)
{
BRepBuilderGeometryId edge = brep.AddEdge(BRepBuilderEdgeGeometry.Create(cc));
brep.AddCoEdge(loop, edge, false);
}
}
brep.FinishLoop(loop);
}
brep.FinishFace(face);
}
catch
{
BH.Engine.Reflection.Compute.RecordError("An attempt to create a nurbs surface failed.");
return(false);
}
return(true);
}
