private static double? MaxZIntersectionMethod(Brep brep, double x, double y, double tolerance)
{
double? max_z = null;
var bbox = brep.GetBoundingBox(true);
var max_dist_from_xy = (from corner in bbox.GetCorners() select corner.Z)
// furthest Z from XY plane.
// Here you might be tempted to use .Max() to get the largest Z value but that doesn't work because
// Z might be negative. This custom aggregate returns the max Z independant of the sign. If it had a name
// it could be MaxAbs()
.Aggregate((z1, z2) => Math.Abs(z1) > Math.Abs(z2) ? z1 : z2);
// multiply distance by 2 to make sure line intersects completely
var line_curve = new LineCurve(new Point3d(x, y, 0), new Point3d(x, y, max_dist_from_xy*2));
Curve[] overlap_curves;
Point3d[] inter_points;
if (Intersection.CurveBrep(line_curve, brep, tolerance, out overlap_curves, out inter_points))
{
if (overlap_curves.Length > 0 || inter_points.Length > 0)
{
// grab all the points resulting frem the intersection.
// 1st set: points from overlapping curves,
// 2nd set: points when there was no overlap
// .Aggregate: furthest Z from XY plane.
max_z = (from c in overlap_curves select Math.Abs(c.PointAtEnd.Z) > Math.Abs(c.PointAtStart.Z) ? c.PointAtEnd.Z : c.PointAtStart.Z)
.Union
(from p in inter_points select p.Z)
// Here you might be tempted to use .Max() to get the largest Z value but that doesn't work because
// Z might be negative. This custom aggregate returns the max Z independant of the sign. If it had a name
// it could be MaxAbs()
.Aggregate((z1, z2) => Math.Abs(z1) > Math.Abs(z2) ? z1 : z2);
}
}
return max_z;
}
public void CurveCP(Brep x, Curve y, int V, int U)
{
int u = bitmap1.Size.Width;
int v = bitmap1.Size.Height;
Graphics g = Graphics.FromImage(bitmap1);
g.FillRectangle(new SolidBrush(Color.White), 0, 0, u, v);
System.Drawing.SolidBrush myBrush = new System.Drawing.SolidBrush(Color.Black);
float step1 = u / U;
float step2 = v / V;
for (float i = 25; i < u - 25; i += step1)
{
for (float j = 25; j < v - 25; j += step2)
{
double Umin = x.Faces[0].Domain(0).Min;
double Umax = x.Faces[0].Domain(0).Max;
double Vmin = x.Faces[0].Domain(1).Min;
double Vmax = x.Faces[0].Domain(1).Max;
Point3d pos = x.Faces[0].PointAt(i / u * (Umax - Umin) + Umin, j / v * (Vmax - Vmin) + Vmin);
double t; float R;
if (y.ClosestPoint(pos, out t, 200))
{
double dis = y.PointAt(t).DistanceTo(pos);
dis /= 200;
R = (float)(1 / dis * 2);
if (R > 40) R = 40;
}
else { R = 20; }
g.FillEllipse(myBrush, i - R, v - j - R, R * 2, R * 2);
}
}
myBrush.Dispose();
g.Dispose();
}
/// <summary>
/// Initializes a new instance of the WorldBoxEnvironmentComponent class.
/// </summary>
public PolysurfaceEnvironmentComponent()
: base("Polysurface Environment", "PolysrfEnv",
"A 3D Polysurface Environment.", RS.icon_polysurfaceEnvironment, "646e7585-d3b0-4ebd-8ce3-8efc5cd6b7d9")
{
brep = new Brep();
borderDir = Vector3d.Zero;
}
public static Rhino.Commands.Result AddTwistedCube(Rhino.RhinoDoc doc)
{
Point3d[] points = new Point3d[8];
points[0] = new Point3d(0.0, 0.0, 0.0); // point A = geometry for vertex 0
points[1] = new Point3d(10.0, 0.0, 0.0); // point B = geometry for vertex 1
points[2] = new Point3d(10.0, 8.0, -1.0); // point C = geometry for vertex 2
points[3] = new Point3d(0.0, 6.0, 0.0); // point D = geometry for vertex 3
points[4] = new Point3d(1.0, 2.0, 11.0); // point E = geometry for vertex 4
points[5] = new Point3d(10.0, 0.0, 12.0); // point F = geometry for vertex 5
points[6] = new Point3d(10.0, 7.0, 13.0); // point G = geometry for vertex 6
points[7] = new Point3d(0.0, 6.0, 12.0); // point H = geometry for vertex 7
Brep brep = new Brep();
// Create eight vertices located at the eight points
for (int vi = 0; vi < 8; vi++)
brep.Vertices.Add(points[vi], 0.0);
// Create 3d curve geometry - the orientations are arbitrarily chosen
// so that the end vertices are in alphabetical order.
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[A], points[B])); // line AB
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[B], points[C])); // line BC
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[C], points[D])); // line CD
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[A], points[D])); // line AD
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[E], points[F])); // line EF
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[F], points[G])); // line FG
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[G], points[H])); // line GH
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[E], points[H])); // line EH
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[A], points[E])); // line AE
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[B], points[F])); // line BF
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[C], points[G])); // line CG
brep.Curves3D.Add(TwistedCubeEdgeCurve(points[D], points[H])); // line DH
// Create the 12 edges that connect the corners of the cube.
MakeTwistedCubeEdges(ref brep);
// Create 3d surface geometry - the orientations are arbitrarily chosen so
// that some normals point into the cube and others point out of the cube.
brep.AddSurface(TwistedCubeSideSurface(points[A], points[B], points[C], points[D])); // ABCD
brep.AddSurface(TwistedCubeSideSurface(points[B], points[C], points[G], points[F])); // BCGF
brep.AddSurface(TwistedCubeSideSurface(points[C], points[D], points[H], points[G])); // CDHG
brep.AddSurface(TwistedCubeSideSurface(points[A], points[D], points[H], points[E])); // ADHE
brep.AddSurface(TwistedCubeSideSurface(points[A], points[B], points[F], points[E])); // ABFE
brep.AddSurface(TwistedCubeSideSurface(points[E], points[F], points[G], points[H])); // EFGH
// Create the CRhinoBrepFaces
MakeTwistedCubeFaces(ref brep);
if (brep.IsValid)
{
doc.Objects.AddBrep(brep);
doc.Views.Redraw();
return Rhino.Commands.Result.Success;
}
return Rhino.Commands.Result.Failure;
}
private void RunScript(int x, double y, Brep z, ref object A)
{
List<branch> bls = new List<branch>();
// List<branch> Temp = new List<branch>();
bls.Add(new branch(Plane.WorldXY, length, Math.PI / y));
for (int i = 0; i < x; i++)
{
bls.AddRange(branch.grow(bls, z));
}
A = branch.DisplayBranches(bls);
}
private static DataTree<Brep> BrepArray2DToDatatree(Brep[][] array)
{
DataTree<Brep> tree = new DataTree<Brep>();
GH_Path trunk = new GH_Path();
for (int i = 0; i < array.Length; i++)
{
GH_Path branch = trunk.AppendElement(i);
for (int j = 0; j < array[i].Length; j++)
{
tree.Add(array[i][j], branch);
}
}
return tree;
}
private Brep[] calculateOffsetSolids()
{
Brep[] cappedBreps = new Brep[refMesh.faces.Count];
for (int i = 0; i < offsetEdges.Length; i++)
{
List<Brep> brepsToMerge = new List<Brep>();
refMesh.faces[i].faceNormal.Unitize();
//better to translate and then just create on.
Transform moveToAdjustForThickness = Transform.Translation(Vector3d.Multiply(thickness/2,refMesh.faces[i].faceNormal));
offsetEdges[i].ToNurbsCurve().Transform(moveToAdjustForThickness);
cappedBreps[i] = Surface.CreateExtrusion(offsetEdges[i].ToNurbsCurve(), Vector3d.Multiply(-thickness, refMesh.faces[i].faceNormal)).ToBrep().CapPlanarHoles(0.1);
}
return cappedBreps;
}
private Brep[][] CreateBorderWalls()
{
Curve[] borderCrvs = GetNakedEdges();
int n = borderCrvs.Length;
Point3d[][] edgePtsArray = new Point3d[n][];
for (int i = 0; i < n; i++)
{
edgePtsArray[i] = DivByAngle(borderCrvs[i], 1.0).ToArray();
}
Vector3d[][] normalsArray = new Vector3d[n][];
for (int i = 0; i < n; i++)
{
if (borderDir.Equals(Vector3d.Zero))
{
normalsArray[i] = GetBrepNormals(edgePtsArray[i]).ToArray();
}
else
{
int m = edgePtsArray[i].Length;
normalsArray[i] = new Vector3d[m];
for (int j = 0; j < m; j++)
{
normalsArray[i][j] = borderDir;
}
}
}
double borderSize = environment.GetBoundingBox(Plane.WorldXY).Diagonal.Length / 10;
Brep[][] borderWallsArray = new Brep[n][];
for (int i = 0; i < n; i++)
{
borderWallsArray[i] = GetBorderWalls(borderCrvs[i], edgePtsArray[i], normalsArray[i], borderSize);
}
return borderWallsArray;
}
//Make the extended cone to intersect with
public Cone GetExtendedCone(Brep _brepVoid, Point3d _ptRandom, double _extraBcTangent)
{
var brepVoid = _brepVoid;
var ptRandom = _ptRandom;
var extraBcTangent = _extraBcTangent;
var bb = brepVoid.GetBoundingBox(true);
var sph = new Sphere(bb.Center, (bb.Max.X - bb.Min.X) / 2);
var centerPoint = sph.Center;
var sphereRadius = sph.Radius;
var sphereRadiusExtended = sphereRadius + extraBcTangent;
var vectorCone = centerPoint - ptRandom;
var planeCone = new Plane(ptRandom, vectorCone);
//Cone cone = new Cone(planeCone, vectorCone.Length, sphereRadius);
int iExtend = 10;
Cone coneExtended = new Cone(planeCone, vectorCone.Length * iExtend, sphereRadiusExtended * iExtend);
return(coneExtended);
}
// generate far 5-20
public void buildingGenerator3(double density)
{
// offset 2m
Curve[] outeroffset = this.Outline.ToNurbsCurve().Offset(this.Center, Vector3d.ZAxis, 2, inter_tol, CurveOffsetCornerStyle.Sharp);
this.OuterBorder = outeroffset[0];
// density * offsetmax
double off = density * (this.offsetMax() - 2);
// offset the outerborder
Curve[] inneroffset = outeroffset[0].Offset(this.Center, Vector3d.ZAxis, off, inter_tol, CurveOffsetCornerStyle.Sharp);
this.InnerBorder = inneroffset[0];
// loft, extrude
Brep[] loft = Brep.CreatePlanarBreps(new List <Curve>()
{
this.OuterBorder, this.InnerBorder
}, inter_tol);
//double floor = Math.Floor(this.FAR / density);
double floor = 5;
Brep ex = loft[0].Faces[0].CreateExtrusion(new Line(0, 0, 0, 0, 0, floor * 3).ToNurbsCurve(), true);
this.Structure = ex;
}
/// <summary>
/// This Method converts the two input curvelist to a meshlist
/// </summary>
/// <param name="sidewalkList"></param>
/// <param name="_FootprintList"></param>
/// <returns></returns>
private static List <Mesh> SidewalkCrvToMesh(List <Curve> sidewalkList, List <Curve> _FootprintList)
{
List <Brep> outLine = new List <Brep>();
List <Brep> inLine = new List <Brep>();
foreach (Curve sw in sidewalkList)
{
Curve sidewalk = sw.Simplify(CurveSimplifyOptions.All, 1, 2);
Brep[] planarSidewalkList = Brep.CreatePlanarBreps(sidewalk, 1.0);
outLine.AddRange(from Brep planarSidewalk in planarSidewalkList
select planarSidewalk);
}
Curve[] footprintCrvList = Curve.CreateBooleanUnion(_FootprintList, 1.0);
foreach (Curve footprint in footprintCrvList)
{
Brep[] planarBuildingList = Brep.CreatePlanarBreps(footprint, 1.0);
inLine.AddRange(from Brep planarFootprints in planarBuildingList
select planarFootprints);
}
Brep[] sidewalks = Brep.CreateBooleanDifference(outLine, inLine, 1.0);
List <Mesh> sidewalkMeshes = new List <Mesh>();
foreach (Brep sw in sidewalks)
{
Mesh[] sideWalkMeshList = Mesh.CreateFromBrep(sw, MeshingParameters.FastRenderMesh);
sidewalkMeshes.AddRange(from Mesh mesh in sideWalkMeshList
select mesh);
BrepEdgeList edges = sw.Edges;
}
return(sidewalkMeshes);
}
public void renderPatch()
{
//Brep patchSurface = Brep.CreatePatch(curvelist, 4, 4, mScene.rhinoDoc.ModelAbsoluteTolerance);
Brep patchSurface = Brep.CreatePatch(allPoints, 10, 10, mScene.rhinoDoc.ModelAbsoluteTolerance);
Guid planGuid = UtilOld.addRhinoObjectSceneNode(ref mScene, ref patchSurface, ref mesh_m, "patchSurface", out planeSN);
//clear profile curves
foreach (Guid id in curveGuids)
{
foreach (SceneNode sn in mScene.tableGeometry.children)
{
if (sn.guid == id)
{
mScene.tableGeometry.children.Remove(sn);
break;
}
}
}
allPoints.Clear();
curvelist.Clear();
}
Brep Cube4Pt(Point3d A, Point3d B, Point3d C, Point3d D)
{
List <Brep> srfs = new List <Brep>();
Point3d E = new Point3d(0, 0, 0);
Point3d F = new Point3d(0, 0, 0);
Point3d G = new Point3d(0, 0, 0);
E = Point3d.Add(E, (B + C - A));
F = Point3d.Add(F, (B + D - A));
G = Point3d.Add(G, (C + D - A));
srfs.Add(Brep.TryConvertBrep(Srf3Pt(A, B, C)));
srfs.Add(Brep.TryConvertBrep(Srf3Pt(A, B, D)));
srfs.Add(Brep.TryConvertBrep(Srf3Pt(A, C, D)));
srfs.Add(Brep.TryConvertBrep(Srf3Pt(D, F, G)));
srfs.Add(Brep.TryConvertBrep(Srf3Pt(B, F, E)));
srfs.Add(Brep.TryConvertBrep(Srf3Pt(C, E, G)));
Brep[] Brs = Brep.JoinBreps(srfs, 0.01);
return(Brs[0]);
}
private GH_Brep CreateSlabBrep(double depth, IList <PolylineCurve> curveList, IEnumerable <Point3d> topPts)
{
if (depth > 0)
{
Vector3d normal = Vector3d.CrossProduct(curveList[0].TangentAtEnd, curveList[0].TangentAtStart);
curveList[1] = new PolylineCurve(topPts.Select(pt => pt - normal * depth));
Brep loftBrep = Brep.CreateFromLoft(curveList, Point3d.Unset, Point3d.Unset, LoftType.Straight, false)[0];
Brep capedBrep = loftBrep.CapPlanarHoles(_tolerance[0]);
if (capedBrep == null)
{
return(NonPlanarBrep(depth, curveList));
}
CheckBrepOrientation(capedBrep);
return(new GH_Brep(capedBrep));
}
return(new GH_Brep(curveList[0].IsPlanar()
? Brep.CreatePlanarBreps(curveList[0], _tolerance[0])[0]
: Brep.CreatePatch(new[] { curveList[0] }, 5, 5, _tolerance[0])));
}
public static (Point3d Center, Vector3d Normal) GetSrfCenPtandNormal(this Brep inBrep)
{
var brepFace = inBrep.Faces[0];
double centerU, centerV;
if (brepFace.IsPlanar() && brepFace.IsSurface)
{
centerU = brepFace.Domain(0).Mid;
centerV = brepFace.Domain(1).Mid;
}
else
{
var centroid = AreaMassProperties.Compute(brepFace).Centroid;
brepFace.ClosestPoint(centroid, out centerU, out centerV);
}
Point3d centerPt = brepFace.PointAt(centerU, centerV);
Vector3d normalVector = brepFace.NormalAt(centerU, centerU);
return(centerPt, normalVector);
}
private static bool CheckContainment(Editor ed, Brep brp, Point3d pt, ref List <Point3d> faceBoundary)
{
bool res = false;
// Use the BRep API to get the lowest level
// container for the point
PointContainment pc;
BrepEntity be = brp.GetPointContainment(pt, out pc);
using (be)
{
// Only if the point is on a boundary...
if (pc == PointContainment.OnBoundary)
{
// And only if the boundary is a face...
BrFace face = be as BrFace;
if (face != null)
{
// ... do we attempt to do something
try
{
#if BRX_APP
//faceBoundary.Add(face.BoundBlock.GetMinimumPoint());
//faceBoundary.Add(face.BoundBlock.GetMaximumPoint());
res = true;
#elif ARX_APP
faceBoundary.Add(face.BoundBlock.GetMinimumPoint());
faceBoundary.Add(face.BoundBlock.GetMaximumPoint());
res = true;
#endif
}
catch (BrException)
{
res = false;
}
}
}
}
return(res);
}
private void RhinoDocOnBeforeTransformObjects(object sender, RhinoTransformObjectsEventArgs ea)
{
RhinoObject[] rhinoObjects = ea.Objects;
Vector3d traslation;
Transform transform;
ea.Transform.DecomposeAffine(out transform, out traslation);
transform = transform.Transpose();
for (int i = 0; i < rhinoObjects.Length; i++)
{
//Se il guid é presente nella lista allora fa parte delle jitter forme
if (RigidBodyManager.GuidList.Contains(rhinoObjects[i].Id))
{
int index = RigidBodyManager.GuidList.IndexOf(rhinoObjects[i].Id);
//If it is a rigid transformation (so translation and rotation)
if (ea.Transform.RigidType == TransformRigidType.Rigid)
{ //Rotate the body
JMatrix rotation = RigidBodyManager.RigidBodies[index].Orientation * new JMatrix((float)transform.M00, (float)transform.M01, (float)transform.M02, (float)transform.M10, (float)transform.M11, (float)transform.M12, (float)transform.M20, (float)transform.M21, (float)transform.M22);
RigidBodyManager.RigidBodies[index].Orientation = rotation;
//Move the center of mass of Jitter shape on the center of the BBox of rhino shape
Brep rhinoobj = (Brep)(ea.Objects[i].Geometry).Duplicate();
rhinoobj.Transform(ea.Transform);
Point3d centerBbox = rhinoobj.GetBoundingBox(true).Center;
RigidBodyManager.RigidBodies[index].Position = RigidBodyManager.Point3dtoJVector(centerBbox);
//Find the difference between rhino bbx center and jitter bbox center
JVector bboxjitter = RigidBodyManager.RigidBodies[index].BoundingBox.Center;
JVector diff = bboxjitter - RigidBodyManager.Point3dtoJVector(centerBbox);
//Align the center of both bboxes
RigidBodyManager.RigidBodies[index].Position -= diff;
}
else
{
RhinoApp.WriteLine("You can't apply a non rigid transformation to a shape that has a rigid body property");
rigidTransf = false;
}
}
}
}
private Brep MakeFrameBox(Brep[] frame)
{
Mesh m = new Mesh();
Mesh f = new Mesh();
for (int i = 0; i < meshnodes.Count; i++)
{
for (int j = 0; j < meshnodes[i].Count; j++)
{
if (i < meshnodes.Count - 1 && j < meshnodes[i].Count - 1)
{
List <Point3d> points = new List <Point3d>()
{
meshnodes[i][j].point, meshnodes[i][j + 1].point, meshnodes[i + 1][j + 1].point, meshnodes[i + 1][j].point
};
FourNodeMesh(ref m, points);
List <Point3d> pointsF = new List <Point3d>()
{
frameGrid[i][j], frameGrid[i][j + 1], frameGrid[i + 1][j + 1], frameGrid[i + 1][j]
};
FourNodeMesh(ref f, pointsF);
}
}
}
Brep front = Brep.CreateFromMesh(m, false);
Brep back = Brep.CreateFromMesh(f, false);
List <Brep> breps = new List <Brep>();
breps.Add(front);
breps.Add(back);
foreach (Brep b in frame)
{
breps.Add(b);
}
Brep[] box = Brep.JoinBreps(breps, RhinoDoc.ActiveDoc.ModelAbsoluteTolerance);
return(box[0]);
}
// generat far 0.5-2
public void buildingGenerator1(double density)
{
// density * offsetmax
double off = (1 - density) * this.offsetMax();
Curve[] offset = this.Outline.ToNurbsCurve().Offset(this.Center, Vector3d.ZAxis, off, inter_tol, CurveOffsetCornerStyle.Sharp);
BrepFace basement = Brep.CreatePlanarBreps(offset[0], inter_tol)[0].Faces[0];
double floor = Math.Floor(this.FAR / density);
double len = this.Outline.Length;
if (floor >= 1 && off < len / 20)
{
Brep ex = basement.CreateExtrusion(new Line(0, 0, 0, 0, 0, floor * 3).ToNurbsCurve(), true);
this.Structure = ex;
}
else
{
Brep ex = basement.CreateExtrusion(new Line(0, 0, 0, 0, 0, 3).ToNurbsCurve(), true);
this.Structure = ex;
}
this.OuterBorder = offset[0];
}
public static string GrasshopperExport(Brep brep)
{
RhinoDoc.ActiveDoc.Objects.UnselectAll();
var gh_brep = new GH_Brep(brep);
Guid brepGuid = Guid.Empty;
gh_brep.BakeGeometry(RhinoDoc.ActiveDoc, new ObjectAttributes(), ref brepGuid);
RhinoDoc.ActiveDoc.Objects.Select(brepGuid, true);
string exportName = GetTempFileName("stp");
string exportCmd = "!_-Export _SaveSmall=Yes _GeometryOnly=Yes _SaveTextures=No _SavePlugInData=Yes " + "\"" + exportName + "\"" + " _Schema=AP214AutomotiveDesign _ExportParameterSpaceCurves=Yes _SplitClosedSurfaces=No _LetImportingApplicationSetColorForBlackObjects=Yes " + " _Enter";
RhinoApp.RunScript(exportCmd, false);
RhinoDoc.ActiveDoc.Objects.Delete(brepGuid, true);
return(exportName);
}
private List <Object> ToBrep(Topology topology, double tolerance)
{
IList <Face> faces = topology.Faces;
List <Brep> ghBrepSurfaces = new List <Brep>();
foreach (Face face in faces)
{
Brep ghBrepSurface = ToSurface(face, tolerance);
ghBrepSurfaces.Add(ghBrepSurface);
}
if (ghBrepSurfaces.Count == 0)
{
return(null);
}
Brep[] ghJoinedBreps = Brep.JoinBreps(ghBrepSurfaces, 0.1);
List <Object> ghJoinedBrepsAsObjects = new List <Object>();
ghJoinedBrepsAsObjects.AddRange(ghJoinedBreps);
return(ghJoinedBrepsAsObjects);
}
public static Brep CreateNonPlanarBrep(IEnumerable <Curve> boundary, double startTolerance)
{
// Iterates tolerance values until a valid surface is created!
var tolerance = startTolerance;
var counter = 0;
var myBrep = new Brep[0];
while (counter < 1000)
{
myBrep = Brep.CreatePlanarBreps(boundary, tolerance);
if (myBrep != null)
{
return(myBrep[0]);
}
else
{
tolerance *= 1.1;
counter += 1;
}
}
return(null);
}
/// <summary>
/// Example function
/// </summary>
public static int ExampleFunction(Brep brep, int x, int y, out Point3d[] points, out Line[] lines)
{
if (null == brep)
{
throw new ArgumentNullException(nameof(brep));
}
// Get the native ON_Brep pointer
var const_ptr_brep = Interop.NativeGeometryConstPointer(brep);
// Creates a ON_3dPointArray wrapper class instance
var points_array = new Rhino.Runtime.InteropWrappers.SimpleArrayPoint3d();
// Get a non-const point to this class
var ptr_points_array = points_array.NonConstPointer();
// Creates a ON_SimpleArray<ON_Line> wrapper class instance
var lines_array = new Rhino.Runtime.InteropWrappers.SimpleArrayLine();
// Get a non-const point to this class
var ptr_lines_array = lines_array.NonConstPointer();
var rc = UnsafeNativeMethods.MooseFunction(const_ptr_brep, x, y, ptr_points_array, ptr_lines_array);
if (rc > 0)
{
points = points_array.ToArray();
lines = lines_array.ToArray();
}
else
{
points = new Point3d[0];
lines = new Line[0];
}
points_array.Dispose();
lines_array.Dispose();
return(rc);
}
public static List <Brep> DrawCorridor(Apartment apartment)
{
List <Brep> output = new List <Brep>();
#region P3Corridor
if (apartment.AGtype == "PT-3")
{
List <Brep> courtCorridorBrep = new List <Brep>();
List <Curve> centerLine = apartment.AptLines;
double width = apartment.ParameterSet.Parameters[2];
for (int i = 0; i < apartment.Household.Count; i++)
{
for (int j = 0; j < apartment.Household[i].Count; j++)
{
List <Household> currentDongHouseholds = apartment.Household[i][j];
Curve currentCenterLine = centerLine[j];
Curve currentInnerLine = currentCenterLine.Offset(Plane.WorldXY, width / 2, 1, CurveOffsetCornerStyle.Sharp)[0];
Curve corridorOutline = currentInnerLine.Offset(Plane.WorldXY, Consts.corridorWidth, 1, CurveOffsetCornerStyle.Sharp)[0];
Brep corridorFloorBrep = Brep.CreatePlanarBreps(new List <Curve> {
currentInnerLine, corridorOutline
}).First();
Surface corridorWallSurface = Surface.CreateExtrusion(corridorOutline, Vector3d.Multiply(Vector3d.ZAxis, Consts.corridorWallHeight));
Brep corridorWallBrep = corridorWallSurface.ToBrep();
corridorWallBrep.Translate(Vector3d.Multiply(Vector3d.ZAxis, currentDongHouseholds[0].Origin.Z));
corridorFloorBrep.Translate(Vector3d.Multiply(Vector3d.ZAxis, currentDongHouseholds[0].Origin.Z));
courtCorridorBrep.Add(corridorWallBrep);
courtCorridorBrep.Add(corridorFloorBrep);
}
}
output = courtCorridorBrep;
}
#endregion P3Corridor
return(output);
}
public Surface[] FindSurfaces(List <Point3d> corners, Surface[] surfaces)
{
Surface[] sortedSurfaces = new Surface[6];
corners = RoundPointsList(corners);
Point3d[] surf0 = new Point3d[] { corners[0], corners[1], corners[4], corners[5] };
Point3d[] surf1 = new Point3d[] { corners[1], corners[2], corners[5], corners[6] };
Point3d[] surf2 = new Point3d[] { corners[2], corners[3], corners[6], corners[7] };
Point3d[] surf3 = new Point3d[] { corners[0], corners[3], corners[4], corners[7] };
for (int i = 0; i < surfaces.Length; i++)
{
Brep surf = surfaces[i].ToBrep();
Point3d[] cornerSurf = surf.DuplicateVertices();
cornerSurf = RoundPoints(cornerSurf);
if (cornerSurf.All(surf0.Contains))
{
sortedSurfaces[0] = surfaces[i];
}
if (cornerSurf.All(surf1.Contains))
{
sortedSurfaces[1] = surfaces[i];
}
if (cornerSurf.All(surf2.Contains))
{
sortedSurfaces[2] = surfaces[i];
}
if (cornerSurf.All(surf3.Contains))
{
sortedSurfaces[3] = surfaces[i];
}
}
return(sortedSurfaces);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
//---variables---
List <Curve> curves = new List <Curve>();
MeshGeometry mesh = new MeshGeometry();
//---input---
if (!DA.GetDataList(0, curves))
{
return;
}
if (!DA.GetData(1, ref mesh))
{
return;
}
//---setup---
Brep origBrep = mesh.GetOrigBrep();
double volume = origBrep.GetVolume();
double sqrt3 = (double)1 / 3;
double refLength = Math.Pow(volume, sqrt3);
(List <string> texts, List <Plane> planes) = CreateTextAndPlane(curves, refLength);
Color colorText = Color.Orange;
double size = (double)refLength / 7;
//---output---
DA.SetDataList(0, texts);
DA.SetData(1, size);
DA.SetDataList(2, planes);
DA.SetData(3, colorText);
}
public static Brep GetTrimmedBrep(pps.Surface surface, SurfaceConverter surfConv, CurveConverter curveConv)
{
var rhSurf = surfConv.FromPipe <Surface, pps.Surface>(surface);
var brep = Brep.CreateFromSurface(rhSurf);
if (!brep.IsValid)
{
brep.Repair(Rhino.RhinoMath.ZeroTolerance);
}
if (typeof(pps.NurbsSurface).IsAssignableFrom(surface.GetType()) &&
((pps.NurbsSurface)surface).TrimCurves.Count > 0)
{
List <ppc.Curve> trims = ((pps.NurbsSurface)surface).TrimCurves;
List <ppc.Curve> loops = brep.Faces.First().Loops.Select((l) =>
curveConv.ToPipe <Curve, ppc.Curve>(l.To3dCurve())).ToList();
if (!PipeDataUtil.EqualIgnoreOrder(loops, trims))
{
var rhTrims = trims.Select((c) => {
var cur = curveConv.FromPipe <Curve, ppc.Curve>(c);
var cur2d = rhSurf.Pullback(cur, Rhino.RhinoMath.ZeroTolerance);
return(rhSurf.Pushup(cur2d, Rhino.RhinoMath.ZeroTolerance));
}).ToList();
var faceToSplit = brep.Faces.First();
var brep2 = faceToSplit.Split(rhTrims, Rhino.RhinoMath.ZeroTolerance);
if (brep2 != null && !brep2.IsValid)
{
brep2.Repair(Rhino.RhinoMath.ZeroTolerance);
}
if (brep2 != null && brep2.IsValid)
{
brep = GetEnclosedFacesAsBrep(brep2, rhTrims) ?? brep2;
}
}
}
return(brep);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
Curve curve = null;
Brep brep = new Brep();
if (!DA.GetData(0, ref curve))
{
return;
}
if (!DA.GetData(1, ref brep))
{
return;
}
double sqrt3 = (double)1 / 3;
double refLength = Math.Pow(brep.GetVolume(), sqrt3);
double adjustment = 5 / refLength; //the length should give 5
int surface = Convert.ToInt32(curve.GetLength() * adjustment);
surface = surface > max ? max : surface;
Surface surf = brep.Surfaces[surface];
var tuple = CreateText(curve, refLength);
List <string> text = tuple.Item1;
List <double> size = tuple.Item2;
List <Plane> textPlane = tuple.Item3;
Color color = tuple.Item4;
Sphere sphere = new Sphere(curve.PointAtEnd, (double)(size[0] / 2));
DA.SetData(0, surf);
DA.SetDataList(1, text);
DA.SetDataList(2, size);
DA.SetDataList(3, textPlane);
DA.SetData(4, color);
DA.SetData(5, sphere);
}
public static DB.GeometryObject[] ToShape(this GeometryBase geometry, double factor)
{
switch (geometry)
{
case Point point:
return(new DB.GeometryObject[] { point.ToPoint(factor) });
case PointCloud pointCloud:
return(pointCloud.ToPoints(factor));
case Curve curve:
return(curve.ToCurveMany(factor).SelectMany(x => x.ToBoundedCurves()).OfType <DB.GeometryObject>().ToArray());
case Brep brep:
return(ToGeometryObjectMany(BrepEncoder.ToRawBrep(brep, factor)).OfType <DB.GeometryObject>().ToArray());
case Extrusion extrusion:
return(ToGeometryObjectMany(ExtrusionEncoder.ToRawBrep(extrusion, factor)).OfType <DB.GeometryObject>().ToArray());
case SubD subD:
return(ToGeometryObjectMany(SubDEncoder.ToRawBrep(subD, factor)).OfType <DB.GeometryObject>().ToArray());;
case Mesh mesh:
return(new DB.GeometryObject[] { MeshEncoder.ToMesh(MeshEncoder.ToRawMesh(mesh, factor)) });
default:
if (geometry.HasBrepForm)
{
var brepForm = Brep.TryConvertBrep(geometry);
if (BrepEncoder.EncodeRaw(ref brepForm, factor))
{
return(ToGeometryObjectMany(brepForm).OfType <DB.GeometryObject>().ToArray());
}
}
return(new DB.GeometryObject[0]);
}
}
public void CreateBreps()
{
// Surface At Top
SurfaceAtTop = Brep.CreatePlanarBreps(CurvesAtTop);
// Surface At Bottom
SurfaceAtBottom = Brep.CreatePlanarBreps(CurvesAtBottom);
// Surface At Top Plate
if (PointsAtTopPlate != null)
{
SurfaceAtTopPlate = Brep.CreatePlanarBreps(CurvesAtTopPlate);
}
// Surface At Bottom Plate
if (PointsAtBottomPlate != null)
{
SurfaceAtBottomPlate = Brep.CreatePlanarBreps(CurvesAtBottomPlate);
}
// Surface At Top Plate
SurfaceAtLoop = Brep.CreateFromLoft(CurvesAtLoop, Point3d.Unset, Point3d.Unset, LoftType.Normal, false);
}
public static GH_Structure <GH_Curve> GetJoined(IList <Brep> inBreps)
{
GH_Structure <GH_Curve> joinedCurves = new GH_Structure <GH_Curve>();
for (int i = 0; i < inBreps.Count; i++)
{
GH_Path path = new GH_Path(i);
Brep brep = inBreps[i];
List <Curve> curvesToAdd = new List <Curve>();
curvesToAdd.AddRange(BrepBorderExtractor.GetJoined(brep));
foreach (Curve curve in curvesToAdd)
{
GH_Curve ghCurve = null;
if (GH_Convert.ToGHCurve(curve, GH_Conversion.Both, ref ghCurve))
{
joinedCurves.Append(ghCurve, path);
}
}
}
return(joinedCurves);
}
public DirectShape BrepToDirectShape(Brep brep, BuiltInCategory cat = BuiltInCategory.OST_GenericModel)
{
var revitDs = DirectShape.CreateElement(Doc, new ElementId(cat));
try
{
var solid = BrepToNative(brep);
if (solid == null)
{
throw new Exception("Could not convert Brep to Solid");
}
revitDs.SetShape(new List <GeometryObject> {
solid
});
}
catch (Exception e)
{
var mesh = MeshToNative(brep.displayValue);
revitDs.SetShape(mesh);
ConversionErrors.Add(new Error(e.Message, e.InnerException?.Message ?? "No details available."));
}
return(revitDs);
}
/// <summary>
/// Orient nodes to match the surface normals of a Brep.
/// </summary>
/// <param name="brep">Brep to orient to.</param>
/// <param name="max_range">Maximum search range.</param>
/// <returns>Number of nodes changed.</returns>
public int OrientNodes(Brep brep, double max_range = 0.0)
{
int N = 0;
Vector3d normal;
double s, t;
ComponentIndex ci;
Point3d cp;
Transform rot;
foreach (Node n in NodeList)
{
if (n.Frame.IsValid)
{
if (brep.ClosestPoint(n.Frame.Origin, out cp, out ci, out s, out t, max_range, out normal))
{
rot = Transform.Rotation(n.Frame.ZAxis, normal, n.Frame.Origin);
n.Frame.Transform(rot);
N++;
}
}
}
return(N);
}
private void ProcessSurfaceObject(RhinoObject obj)
{
Brep brp = obj.Geometry as Brep;
if (brp.Surfaces.Count == 1) // test as floor first and then wall if this is a single face brp
{
if (IsViableObject(SupportedSchema.Floor, obj))
{
SchemaDictionary[SupportedSchema.Floor.ToString()].Add(obj);
}
else if (IsViableObject(SupportedSchema.Wall, obj))
{
SchemaDictionary[SupportedSchema.Wall.ToString()].Add(obj);
}
}
else // if multi surface, test if it may be a wall
{
if (IsViableObject(SupportedSchema.Wall, obj))
{
SchemaDictionary[SupportedSchema.Wall.ToString()].Add(obj);
}
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
DA.GetDataTree("nodal_coordinates", out GH_Structure <GH_Number> _r); var r = _r.Branches;
var surfaces = new List <Brep>(); DA.GetDataList("S", surfaces);
var rigid = new GH_Structure <GH_Number>();
for (int i = 0; i < surfaces.Count; i++)
{
var surf = surfaces[i]; var face = surf.Faces[0];
var solid = Brep.CreateFromOffsetFace(face, 0.1, 5e-3, true, true);
var nodes = new List <GH_Number>();
for (int j = 0; j < r.Count; j++)
{
var p = new Point3d(r[j][0].Value, r[j][1].Value, r[j][2].Value);
if (solid.IsPointInside(p, 5e-3, false) == true)
{
nodes.Add(new GH_Number(j));
}
}
rigid.AppendRange(nodes, new GH_Path(i));
}
DA.SetDataTree(0, rigid);
}
public Profile(string name, List <Point3d> points, double tolerance)
{
Tolerance = tolerance;
ProfilePoints = points;
List <Point3d> pointsForPolyline = points;
pointsForPolyline.Add(points[0]);
Polyline polyline = new Polyline(pointsForPolyline);
if (!polyline.IsClosed)
{
throw new ArgumentException("Polyline should be closed");
}
Line[] lines = polyline.GetSegments();
List <Curve> curves = lines.Select(line => line.ToNurbsCurve()).Cast <Curve>().ToList();
BoundarySurfaces = Brep.CreatePlanarBreps(curves, tolerance);
ProfileCurve = polyline.ToNurbsCurve();
Name = name;
}
public static Brep CreateHollowBrep(Curve curve1, Curve curve2)
{
Brep brep1 = Brep.CreatePlanarBreps(new[] { curve1 })[0];
Brep brep2 = Brep.CreatePlanarBreps(new[] { curve2 })[0];
RhinoDoc doc = RhinoDoc.ActiveDoc;
double area = Brep.CreateBooleanUnion(new[] { brep1, brep2 }, 0.001)[0].GetArea();
double brep1Area = brep1.GetArea();
double brep2Area = brep2.GetArea();
if (area > 0.999 * brep1Area && area < 1.001 * brep1Area)
{
return(Brep.CreateBooleanDifference(brep1, brep2, doc.ModelAbsoluteTolerance)[0]);
}
else if (area > 0.999 * brep2Area && area < 1.001 * brep2Area)
{
return(Brep.CreateBooleanDifference(brep1, brep2, doc.ModelAbsoluteTolerance)[0]);
}
else
{
return(null);
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
Brep brep = null;
if (!DA.GetData(0, ref brep))
{
return;
}
Curve[] edges = brep.DuplicateNakedEdgeCurves(true, true);
Curve[] curves = Curve.JoinCurves(edges);
Shape shape = new Shape(curves.ToList());
Graphic graphic = Graphics.FillBlack;
if (DA.GetData(1, ref graphic))
{
shape.Graphic = new Graphic(graphic);
}
;
DA.SetData(0, shape);
}
/// <summary>
/// Draws a shaded mesh representation of a brep.
/// </summary>
/// <param name="brep">Brep to draw.</param>
/// <param name="material">Material to draw faces with.</param>
public void DrawBrepShaded(Brep brep, DisplayMaterial material)
{
IntPtr pBrep = brep.ConstPointer();
IntPtr pMaterial = IntPtr.Zero;
if (null != material)
pMaterial = material.ConstPointer();
UnsafeNativeMethods.CRhinoDisplayPipeline_DrawShadedBrep(m_ptr, pBrep, pMaterial);
}
/// <summary>
/// Compute the VolumeMassProperties for a single Brep.
/// </summary>
/// <param name="brep">Brep to measure.</param>
/// <returns>The VolumeMassProperties for the given Brep or null on failure.</returns>
/// <exception cref="System.ArgumentNullException">When brep is null.</exception>
public static VolumeMassProperties Compute(Brep brep)
{
if (brep == null)
throw new ArgumentNullException("brep");
IntPtr pBrep = brep.ConstPointer();
const double relativeTolerance = 1.0e-6;
const double absoluteTolerance = 1.0e-6;
IntPtr rc = UnsafeNativeMethods.ON_Brep_MassProperties(false, pBrep, relativeTolerance, absoluteTolerance);
return IntPtr.Zero == rc ? null : new VolumeMassProperties(rc, false);
}
internal static GeometryBase CreateGeometryHelper(IntPtr pGeometry, object parent, int subobject_index)
{
if (IntPtr.Zero == pGeometry)
return null;
int type = UnsafeNativeMethods.ON_Geometry_GetGeometryType(pGeometry);
if (type < 0)
return null;
GeometryBase rc = null;
switch (type)
{
case idxON_Curve: //1
rc = new Curve(pGeometry, parent, subobject_index);
break;
case idxON_NurbsCurve: //2
rc = new NurbsCurve(pGeometry, parent, subobject_index);
break;
case idxON_PolyCurve: // 3
rc = new PolyCurve(pGeometry, parent, subobject_index);
break;
case idxON_PolylineCurve: //4
rc = new PolylineCurve(pGeometry, parent, subobject_index);
break;
case idxON_ArcCurve: //5
rc = new ArcCurve(pGeometry, parent, subobject_index);
break;
case idxON_LineCurve: //6
rc = new LineCurve(pGeometry, parent, subobject_index);
break;
case idxON_Mesh: //7
rc = new Mesh(pGeometry, parent);
break;
case idxON_Point: //8
rc = new Point(pGeometry, parent);
break;
case idxON_TextDot: //9
rc = new TextDot(pGeometry, parent);
break;
case idxON_Surface: //10
rc = new Surface(pGeometry, parent);
break;
case idxON_Brep: //11
rc = new Brep(pGeometry, parent);
break;
case idxON_NurbsSurface: //12
rc = new NurbsSurface(pGeometry, parent);
break;
case idxON_RevSurface: //13
rc = new RevSurface(pGeometry, parent);
break;
case idxON_PlaneSurface: //14
rc = new PlaneSurface(pGeometry, parent);
break;
case idxON_ClippingPlaneSurface: //15
rc = new ClippingPlaneSurface(pGeometry, parent);
break;
case idxON_Annotation2: // 16
rc = new AnnotationBase(pGeometry, parent);
break;
case idxON_Hatch: // 17
rc = new Hatch(pGeometry, parent);
break;
case idxON_TextEntity2: //18
rc = new TextEntity(pGeometry, parent);
break;
case idxON_SumSurface: //19
rc = new SumSurface(pGeometry, parent);
break;
case idxON_BrepFace: //20
{
int faceindex = -1;
IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref faceindex);
if (pBrep != IntPtr.Zero && faceindex >= 0)
{
Brep b = new Brep(pBrep, parent);
rc = b.Faces[faceindex];
}
}
break;
case idxON_BrepEdge: // 21
{
int edgeindex = -1;
IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref edgeindex);
if (pBrep != IntPtr.Zero && edgeindex >= 0)
{
Brep b = new Brep(pBrep, parent);
rc = b.Edges[edgeindex];
}
}
break;
case idxON_InstanceDefinition: // 22
rc = new InstanceDefinitionGeometry(pGeometry, parent);
break;
case idxON_InstanceReference: // 23
rc = new InstanceReferenceGeometry(pGeometry, parent);
break;
#if USING_V5_SDK
case idxON_Extrusion: //24
rc = new Extrusion(pGeometry, parent);
break;
#endif
case idxON_LinearDimension2: //25
rc = new LinearDimension(pGeometry, parent);
break;
case idxON_PointCloud: // 26
rc = new PointCloud(pGeometry, parent);
break;
case idxON_DetailView: // 27
rc = new DetailView(pGeometry, parent);
break;
case idxON_AngularDimension2: // 28
rc = new AngularDimension(pGeometry, parent);
break;
case idxON_RadialDimension2: // 29
rc = new RadialDimension(pGeometry, parent);
break;
case idxON_Leader: // 30
rc = new Leader(pGeometry, parent);
break;
case idxON_OrdinateDimension2: // 31
rc = new OrdinateDimension(pGeometry, parent);
break;
case idxON_Light: //32
rc = new Light(pGeometry, parent);
break;
case idxON_PointGrid: //33
rc = new Point3dGrid(pGeometry, parent);
break;
case idxON_MorphControl: //34
rc = new MorphControl(pGeometry, parent);
break;
case idxON_BrepLoop: //35
{
int loopindex = -1;
IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref loopindex);
if (pBrep != IntPtr.Zero && loopindex >= 0)
{
Brep b = new Brep(pBrep, parent);
rc = b.Loops[loopindex];
}
}
break;
case idxON_BrepTrim: // 36
{
int trimindex = -1;
IntPtr pBrep = UnsafeNativeMethods.ON_BrepSubItem_Brep(pGeometry, ref trimindex);
if (pBrep != IntPtr.Zero && trimindex >= 0)
{
Brep b = new Brep(pBrep, parent);
rc = b.Trims[trimindex];
}
}
break;
default:
rc = new UnknownGeometry(pGeometry, parent, subobject_index);
break;
}
return rc;
}
/// <summary>
/// Intersects a Brep and a Surface.
/// </summary>
/// <param name="brep">A brep to be intersected.</param>
/// <param name="surface">A surface to be intersected.</param>
/// <param name="tolerance">A tolerance value.</param>
/// <param name="intersectionCurves">The intersection curves array argument. This out reference is assigned during the call.</param>
/// <param name="intersectionPoints">The intersection points array argument. This out reference is assigned during the call.</param>
/// <returns>true on success; false on failure.</returns>
public static bool BrepSurface(Brep brep, Surface surface, double tolerance, out Curve[] intersectionCurves, out Point3d[] intersectionPoints)
{
intersectionCurves = new Curve[0];
intersectionPoints = new Point3d[0];
Runtime.InteropWrappers.SimpleArrayPoint3d outputPoints = new Runtime.InteropWrappers.SimpleArrayPoint3d();
IntPtr outputPointsPtr = outputPoints.NonConstPointer();
Runtime.InteropWrappers.SimpleArrayCurvePointer outputCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer();
IntPtr outputCurvesPtr = outputCurves.NonConstPointer();
IntPtr brepPtr = brep.ConstPointer();
IntPtr surfacePtr = surface.ConstPointer();
bool rc = UnsafeNativeMethods.ON_Intersect_BrepSurface(brepPtr, surfacePtr, tolerance, outputCurvesPtr, outputPointsPtr);
if (rc)
{
intersectionCurves = outputCurves.ToNonConstArray();
intersectionPoints = outputPoints.ToArray();
}
outputPoints.Dispose();
outputCurves.Dispose();
return rc;
}
static void MakeTwistedCubeTrimmingLoop( ref Brep brep, ref BrepFace face, // Indices of corner vertices listed in SW, SE, NW, NE order
int eSi, // index of edge on south side of surface
int eS_dir, // orientation of edge with respect to surface trim
int eEi, // index of edge on south side of surface
int eE_dir, // orientation of edge with respect to surface trim
int eNi, // index of edge on south side of surface
int eN_dir, // orientation of edge with respect to surface trim
int eWi, // index of edge on south side of surface
int eW_dir // orientation of edge with respect to surface trim
)
{
Surface srf = brep.Surfaces[face.SurfaceIndex];
var loop = brep.Loops.Add(BrepLoopType.Outer, face);
// Create trimming curves running counter clockwise around the surface's domain.
// Start at the south side
// side: 0=south, 1=east, 2=north, 3=west
for (int side = 0; side < 4; side++)
{
Curve trimming_curve = TwistedCubeTrimmingCurve(srf, side);
int curve_index = brep.Curves2D.Add(trimming_curve);
int ei = 0;
bool reverse = false;
IsoStatus iso = IsoStatus.None;
switch (side)
{
case 0: // south
ei = eSi;
reverse = (eS_dir == -1);
iso = IsoStatus.South;
break;
case 1: // east
ei = eEi;
reverse = (eE_dir == -1);
iso = IsoStatus.East;
break;
case 2: // north
ei = eNi;
reverse = (eN_dir == -1);
iso = IsoStatus.North;
break;
case 3: // west
ei = eWi;
reverse = (eW_dir == -1);
iso = IsoStatus.West;
break;
}
BrepEdge edge = brep.Edges[ei];
BrepTrim trim = brep.Trims.Add(edge, reverse, loop, curve_index);
trim.IsoStatus = iso;
trim.TrimType = BrepTrimType.Mated; // This b-rep is closed, so all trims have mates.
trim.SetTolerances(0, 0); // This simple example is exact - for models with
// non-exact data, set tolerance as explained in
// definition of BrepTrim.
}
}
/// <summary>
/// Projects a Curve onto a Brep along a given direction.
/// </summary>
/// <param name="curve">Curve to project.</param>
/// <param name="brep">Brep to project onto.</param>
/// <param name="direction">Direction of projection.</param>
/// <param name="tolerance">Tolerance to use for projection.</param>
/// <returns>An array of projected curves or empty array if the projection set is empty.</returns>
public static Curve[] ProjectToBrep(Curve curve, Brep brep, Vector3d direction, double tolerance)
{
IntPtr brep_ptr = brep.ConstPointer();
IntPtr curve_ptr = curve.ConstPointer();
using (SimpleArrayCurvePointer rc = new SimpleArrayCurvePointer())
{
IntPtr rc_ptr = rc.NonConstPointer();
return UnsafeNativeMethods.RHC_RhinoProjectCurveToBrep(brep_ptr, curve_ptr, direction, tolerance, rc_ptr) ? rc.ToNonConstArray() : new Curve[0];
}
}
public TestSurfaceDirConduit(Brep brep)
{
m_brep = brep;
Flip = false;
const int SURFACE_ARROW_COUNT = 5;
int face_count = m_brep.Faces.Count;
int capacity = face_count * SURFACE_ARROW_COUNT * SURFACE_ARROW_COUNT;
m_points = new List<Point3d>(capacity);
m_normals = new List<Vector3d>(capacity);
for (int i = 0; i < face_count; i++)
{
var face = brep.Faces[i];
var loop = face.OuterLoop;
if (loop == null)
continue;
var udomain = face.Domain(0);
var vdomain = face.Domain(1);
var loop_bbox = loop.GetBoundingBox(true);
if (loop_bbox.IsValid)
{
Interval domain = new Interval(loop_bbox.Min.X, loop_bbox.Max.X);
domain = Interval.FromIntersection(domain, udomain);
if (domain.IsIncreasing)
udomain = domain;
domain = new Interval(loop_bbox.Min.Y, loop_bbox.Max.Y);
domain = Interval.FromIntersection(domain, vdomain);
if (domain.IsIncreasing)
vdomain = domain;
}
bool bUntrimmed = face.IsSurface;
bool bRev = face.OrientationIsReversed;
for (double u = 0; u < SURFACE_ARROW_COUNT; u += 1.0)
{
double d = u / (SURFACE_ARROW_COUNT - 1.0);
double s = udomain.ParameterAt(d);
var intervals = face.TrimAwareIsoIntervals(1, s);
if (bUntrimmed || intervals.Length > 0)
{
for (double v = 0; v < SURFACE_ARROW_COUNT; v += 1.0)
{
d = v / (SURFACE_ARROW_COUNT - 1.0);
double t = vdomain.ParameterAt(d);
bool bAdd = bUntrimmed;
for (int k = 0; !bAdd && k < intervals.Length; k++)
{
if (intervals[k].IncludesParameter(t))
bAdd = true;
}
if (bAdd)
{
var pt = face.PointAt(s, t);
var vec = face.NormalAt(s, t);
m_points.Add(pt);
if (bRev)
vec.Reverse();
m_normals.Add(vec);
}
}
}
}
}
}
/// <summary>
/// Draws all the wireframe curves of a brep object.
/// </summary>
/// <param name="brep">Brep to draw.</param>
/// <param name="color">Color of Wireframe curves.</param>
public void DrawBrepWires(Brep brep, System.Drawing.Color color)
{
DrawBrepWires(brep, color, 1);
}
public Polyline Project(Polyline pl, Brep sf)
{
Mesh[] meshes = Mesh.CreateFromBrep(sf);
if (meshes.Length > 0) return Project(pl, meshes[0]);
return null;
}
static void MakeTwistedCubeFaces(ref Brep brep)
{
MakeTwistedCubeFace(ref brep,
ABCD, // Index of surface ABCD
+1, // Indices of vertices listed in SW,SE,NW,NE order
AB, +1, // South side edge and its orientation with respect to
// to the trimming curve. (AB)
BC, +1, // South side edge and its orientation with respect to
// to the trimming curve. (BC)
CD, +1, // South side edge and its orientation with respect to
// to the trimming curve (CD)
AD, -1 // South side edge and its orientation with respect to
// to the trimming curve (AD)
);
MakeTwistedCubeFace(ref brep,
BCGF, // Index of surface BCGF
-1, // Indices of vertices listed in SW,SE,NW,NE order
BC, +1, // South side edge and its orientation with respect to
// to the trimming curve. (BC)
CG, +1, // South side edge and its orientation with respect to
// to the trimming curve. (CG)
FG, -1, // South side edge and its orientation with respect to
// to the trimming curve (FG)
BF, -1 // South side edge and its orientation with respect to
// to the trimming curve (BF)
);
MakeTwistedCubeFace(ref brep,
CDHG, // Index of surface CDHG
-1, // Indices of vertices listed in SW,SE,NW,NE order
CD, +1, // South side edge and its orientation with respect to
// to the trimming curve. (CD)
DH, +1, // South side edge and its orientation with respect to
// to the trimming curve. (DH)
GH, -1, // South side edge and its orientation with respect to
// to the trimming curve (GH)
CG, -1 // South side edge and its orientation with respect to
// to the trimming curve (CG)
);
MakeTwistedCubeFace(ref brep,
ADHE, // Index of surface ADHE
+1, // Indices of vertices listed in SW,SE,NW,NE order
AD, +1, // South side edge and its orientation with respect to
// to the trimming curve. (AD)
DH, +1, // South side edge and its orientation with respect to
// to the trimming curve. (DH)
EH, -1, // South side edge and its orientation with respect to
// to the trimming curve (EH)
AE, -1 // South side edge and its orientation with respect to
// to the trimming curve (AE)
);
MakeTwistedCubeFace(ref brep,
ABFE, // Index of surface ABFE
-1, // Indices of vertices listed in SW,SE,NW,NE order
AB, +1, // South side edge and its orientation with respect to
// to the trimming curve. (AB)
BF, +1, // South side edge and its orientation with respect to
// to the trimming curve. (BF)
EF, -1, // South side edge and its orientation with respect to
// to the trimming curve (EF)
AE, -1 // South side edge and its orientation with respect to
// to the trimming curve (AE)
);
MakeTwistedCubeFace(ref brep,
EFGH, // Index of surface EFGH
-1, // Indices of vertices listed in SW,SE,NW,NE order
EF, +1, // South side edge and its orientation with respect to
// to the trimming curve. (EF)
FG, +1, // South side edge and its orientation with respect to
// to the trimming curve. (FG)
GH, +1, // South side edge and its orientation with respect to
// to the trimming curve (GH)
EH, -1 // South side edge and its orientation with respect to
// to the trimming curve (EH)
);
}
// ====================================================================
//---- END CONSTRUCTOR-------------------------------------------------
// ====================================================================
// Added by Gene
public void RunSingleSrf()
{
Point3d pLeft = curvesLeft.PointAtStart;
Point3d pRight = curvesRight.PointAtStart;
LineCurve rail = new LineCurve(pLeft, pRight);
Point3d pLeft2 = curvesLeft.PointAtEnd;
Point3d pRight2 = curvesRight.PointAtEnd;
LineCurve rail2 = new LineCurve(pLeft2, pRight2);
loop = Brep.CreateFromSweep(curvesLeft, curvesRight, new List<Curve>() { rail, rail2 }, false, documentTolerance)[0];
//loop = Brep.CreateFromLoftRebuild(new List<Curve>() { curvesLeft, curvesRight }, Point3d.Unset, Point3d.Unset, LoftType.Normal, false, 50)[0];
//loop = Brep.CreateFromLoft(new List<Curve>() { curvesLeft, curvesRight }, Point3d.Unset, Point3d.Unset, LoftType.Normal, false )[0];
Brep[] loops;
double offsetAmount = 0.002;
//double offsetAmount2 = 0.02;
Vector3d normal1, normal2;
normal1 = Vector3d.CrossProduct(cuttingPts[0] - cuttingPts[4], cuttingPts[0] - cuttingPts[2]);
normal2 = Vector3d.CrossProduct(cuttingPts[1] - cuttingPts[3], cuttingPts[1] - cuttingPts[5]);
Point3d A_ = cuttingPts[7] + offsetAmount * normal2;
Point3d B_ = cuttingPts[6] + offsetAmount * normal1;
//Brep cutter1 = Brep.CreateFromCornerPoints(cuttingPts[0], cuttingPts[1], cuttingPts[2], cuttingPts[3], documentTolerance);
//Brep cutter2 = Brep.CreateFromCornerPoints(cuttingPts[0], cuttingPts[1], cuttingPts[4], cuttingPts[5], documentTolerance);
loops = loop.Trim(new Plane(A_, cuttingPts[1], cuttingPts[3]), documentTolerance);
//loops = loop.Trim(cutter1, documentTolerance);
if (loops.Length > 0) loop = loops[0];
//else { return; }
loops = loop.Trim(new Plane(A_, cuttingPts[5], cuttingPts[1]), documentTolerance);
if (loops.Length > 0) loop = loops[0];
//else { return; }
loops = loop.Trim(new Plane(B_, cuttingPts[2], cuttingPts[0]), documentTolerance);
if (loops.Length > 0) loop = loops[0];
loops = loop.Trim(new Plane(B_, cuttingPts[0], cuttingPts[4]), documentTolerance);
if (loops.Length > 0) loop = loops[0];
}
static void MakeTwistedCubeEdges(ref Brep brep)
{
// In this simple example, the edge indices exactly match the 3d curve
// indices. In general,the correspondence between edge and curve indices
// can be arbitrary. It is permitted for multiple edges to use different
// portions of the same 3d curve. The orientation of the edge always
// agrees with the natural parametric orientation of the curve.
brep.Edges.Add(A, B, AB, 0); // Edge that runs from A to B
brep.Edges.Add(B, C, BC, 0); // Edge that runs from B to C
brep.Edges.Add(C, D, CD, 0); // Edge that runs from C to D
brep.Edges.Add(A, D, AD, 0); // Edge that runs from A to D
brep.Edges.Add(E, F, EF, 0); // Edge that runs from E to F
brep.Edges.Add(F, G, FG, 0); // Edge that runs from F to G
brep.Edges.Add(G, H, GH, 0); // Edge that runs from G to H
brep.Edges.Add(E, H, EH, 0); // Edge that runs from E to H
brep.Edges.Add(A, E, AE, 0); // Edge that runs from A to E
brep.Edges.Add(B, F, BF, 0); // Edge that runs from B to F
brep.Edges.Add(C, G, CG, 0); // Edge that runs from C to G
brep.Edges.Add(D, H, DH, 0); // Edge that runs from D to H
}
/// <summary>
/// Draws all the wireframe curves of a brep object.
/// </summary>
/// <param name="brep">Brep to draw.</param>
/// <param name="color">Color of Wireframe curves.</param>
/// <param name="wireDensity">
/// "Density" of wireframe curves.
/// <para>-1 = no internal wires.</para>
/// <para> 0 = default internal wires.</para>
/// <para>>0 = custom high density.</para>
/// </param>
public void DrawBrepWires(Brep brep, System.Drawing.Color color, int wireDensity)
{
int argb = color.ToArgb();
IntPtr pBrep = brep.ConstPointer();
UnsafeNativeMethods.CRhinoDisplayPipeline_DrawBrep(m_ptr, pBrep, argb, wireDensity);
}
/// <summary>
/// Copies the unmanaged array to a managed counterpart.
/// </summary>
/// <returns>The managed array.</returns>
public Geometry.Brep[] ToNonConstArray()
{
int count = Count;
if (count < 1)
return new Geometry.Brep[0]; //MSDN guidelines prefer empty arrays
IntPtr ptr = ConstPointer();
Brep[] rc = new Brep[count];
for (int i = 0; i < count; i++)
{
IntPtr pBrep = UnsafeNativeMethods.ON_BrepArray_Get(ptr, i);
if (IntPtr.Zero != pBrep)
rc[i] = new Brep(pBrep, null);
}
return rc;
}
public bool lineWithinRegion(Brep region, LineCurve line)
{
//Check if line is completely within a planar region
int agreement = 0;
Point3d midPt = line.PointAt((line.Domain.Max-line.Domain.Min)/2);
foreach (BrepLoop loop in region.Loops)
{
if (loop.LoopType == BrepLoopType.Outer)
{
Curve iLoop = loop.To3dCurve();
PointContainment ptcontain = iLoop.Contains(midPt);
if (ptcontain != PointContainment.Inside)
{
agreement += 1;
}
}
if (loop.LoopType == BrepLoopType.Inner)
{
Curve iLoop = loop.To3dCurve();
PointContainment ptcontain = iLoop.Contains(midPt);
if (ptcontain != PointContainment.Outside)
{
agreement += 1;
}
}
if (loop.LoopType == BrepLoopType.Slit)
{
break;
}
if (loop.LoopType == BrepLoopType.Unknown)
{
break;
}
}
if (agreement == 0)
{
bool inside = true;
return inside;
}
else
{
bool inside = false;
return inside;
}
}
/// <summary>
/// Intersects a Brep with an (infinite) plane.
/// </summary>
/// <param name="brep">Brep to intersect.</param>
/// <param name="plane">Plane to intersect with.</param>
/// <param name="tolerance">Tolerance to use for intersections.</param>
/// <param name="intersectionCurves">The intersection curves will be returned here.</param>
/// <param name="intersectionPoints">The intersection points will be returned here.</param>
/// <returns>true on success, false on failure.</returns>
public static bool BrepPlane(Brep brep, Plane plane, double tolerance, out Curve[] intersectionCurves, out Point3d[] intersectionPoints)
{
intersectionPoints = null;
intersectionCurves = null;
//David sez: replace this logic with the dedicated Geometry/Plane intersector methods in Rhino5.
if (!plane.IsValid)
return false;
PlaneSurface section = ExtendThroughBox(plane, brep.GetBoundingBox(false), 1.0); //should this be 1.0 or 100.0*tolerance?
bool rc = false;
if (section != null)
{
rc = BrepSurface(brep, section, tolerance, out intersectionCurves, out intersectionPoints);
section.Dispose();
}
return rc;
}
/// <summary>
/// Splits a curve into pieces using a polysurface.
/// </summary>
/// <param name="cutter">A cutting surface or polysurface.</param>
/// <param name="tolerance">A tolerance for computing intersections.</param>
/// <returns>An array of curves. This array can be empty.</returns>
public Curve[] Split(Brep cutter, double tolerance)
{
if (cutter == null) throw new ArgumentNullException("cutter");
IntPtr pConstThis = ConstPointer();
IntPtr pConstBrep = cutter.ConstPointer();
using (Rhino.Runtime.InteropWrappers.SimpleArrayCurvePointer pieces = new SimpleArrayCurvePointer())
{
IntPtr pPieces = pieces.NonConstPointer();
UnsafeNativeMethods.RHC_RhinoCurveSplit(pConstThis, pConstBrep, tolerance, pPieces);
return pieces.ToNonConstArray();
}
}
/// <summary>
/// Intersects a curve with a Brep. This function returns the 3D points of intersection
/// and 3D overlap curves. If an error occurs while processing overlap curves, this function
/// will return false, but it will still provide partial results.
/// </summary>
/// <param name="curve">Curve for intersection.</param>
/// <param name="brep">Brep for intersection.</param>
/// <param name="tolerance">Fitting and near miss tolerance.</param>
/// <param name="overlapCurves">The overlap curves will be returned here.</param>
/// <param name="intersectionPoints">The intersection points will be returned here.</param>
/// <returns>true on success, false on failure.</returns>
/// <example>
/// <code source='examples\vbnet\ex_elevation.vb' lang='vbnet'/>
/// <code source='examples\cs\ex_elevation.cs' lang='cs'/>
/// <code source='examples\py\ex_elevation.py' lang='py'/>
/// </example>
public static bool CurveBrep(Curve curve, Brep brep, double tolerance, out Curve[] overlapCurves, out Point3d[] intersectionPoints)
{
overlapCurves = new Curve[0];
intersectionPoints = new Point3d[0];
Runtime.InteropWrappers.SimpleArrayPoint3d outputPoints = new Runtime.InteropWrappers.SimpleArrayPoint3d();
IntPtr outputPointsPtr = outputPoints.NonConstPointer();
Runtime.InteropWrappers.SimpleArrayCurvePointer outputCurves = new Runtime.InteropWrappers.SimpleArrayCurvePointer();
IntPtr outputCurvesPtr = outputCurves.NonConstPointer();
IntPtr curvePtr = curve.ConstPointer();
IntPtr brepPtr = brep.ConstPointer();
bool rc = UnsafeNativeMethods.ON_Intersect_CurveBrep(curvePtr, brepPtr, tolerance, outputCurvesPtr, outputPointsPtr);
if (rc)
{
overlapCurves = outputCurves.ToNonConstArray();
intersectionPoints = outputPoints.ToArray();
}
outputPoints.Dispose();
outputCurves.Dispose();
return rc;
}
protected CustomBrepObject(Brep brep)
: base(true)
{
IntPtr pConstBrep = brep.ConstPointer();
m_pRhinoObject = UnsafeNativeMethods.CRhinoCustomObject_New2(pConstBrep);
}
static void MakeTwistedCubeFace( ref Brep brep, int surfaceIndex,
int s_dir, // Indices of corner vertices listed in SW, SE, NW, NE order
int southEdgeIndex,
int eS_dir, // orientation of edge with respect to surface trim
int eastEdgeIndex,
int eE_dir, // orientation of edge with respect to surface trim
int northEdgeIndex,
int eN_dir, // orientation of edge with respect to surface trim
int westEdgeIndex,
int eW_dir // orientation of edge with respect to surface trim
)
{
var face = brep.Faces.Add(surfaceIndex);
MakeTwistedCubeTrimmingLoop(
ref brep,
ref face,
southEdgeIndex, eS_dir,
eastEdgeIndex, eE_dir,
northEdgeIndex, eN_dir,
westEdgeIndex, eW_dir
);
face.OrientationIsReversed = (s_dir == -1);
}
public override void Register_Edges(IEnumerable<Hare.Geometry.Point> S, IEnumerable<Hare.Geometry.Point> R)
{
//Collect Edge Curves
List<Curve> Naked_Edges = new List<Curve>();
List<Brep> Naked_Breps = new List<Brep>();
List<double> Lengths = new List<double>();
List<double[]> EdgeDomains = new List<double[]>();
List<int> Brep_IDS = new List<int>();
//Brep.JoinBreps()
for (int q = 0; q < BrepList.Count; q++)
{
foreach (BrepEdge be in BrepList[q].Edges)
{
int[] EdgeMembers = be.AdjacentFaces();
switch (be.Valence)
{
case EdgeAdjacency.Interior:
///This probably doesn't do any work anymore... Kept for future reference (and because it is harmless to do so...).
if (be.IsLinear())
{
if (be.IsSmoothManifoldEdge()) continue; //ignore this condition...
if (BrepList[q].Faces[EdgeMembers[0]].IsPlanar() && BrepList[q].Faces[EdgeMembers[1]].IsPlanar())
{
//Curve is straight, and surfaces are planar (Monolithic Edge)
//Determine if surfaces are coplanar.//////////
Brep[] BR = new Brep[2] { BrepList[q].Faces[EdgeMembers[0]].DuplicateFace(false), BrepList[q].Faces[EdgeMembers[1]].DuplicateFace(false) };
//Rhino.RhinoDoc.ActiveDoc.Objects.Add(BR[0]);
//Rhino.RhinoDoc.ActiveDoc.Objects.Add(BR[1]);
Edge_Nodes.Add(new Edge_Straight(ref S, ref R, this.Env_Prop, BR, new int[2]{q, q}, be));///TODO: Confirm SoundSpeed Approach suitability...
}
else
{
///Edge Curved Condition
Brep[] BR = new Brep[2] { BrepList[q].Faces[EdgeMembers[0]].DuplicateFace(false), BrepList[q].Faces[EdgeMembers[1]].DuplicateFace(false) };
Edge_Nodes.Add(new Edge_Curved(ref S, ref R, this.Env_Prop, BR, new int[2]{q, q}, be));///TODO: Confirm SoundSpeed Approach suitability...
}
}
break;
case EdgeAdjacency.Naked:
//Sorted edges allow us to assume a relationship between curves...
double l = be.GetLength();
bool register_anyway = true;
for (int i = 0; i < Naked_Edges.Count; i++)
{
if (l < Lengths[i])
{
Naked_Breps.Insert(0, BrepList[q].Faces[EdgeMembers[0]].DuplicateFace(false));
Naked_Edges.Insert(0, be);
EdgeDomains.Insert(0, new double[] { be.Domain[0], be.Domain[1] });
Lengths.Insert(0, l);
Brep_IDS.Insert(0, q);
register_anyway = false;
////////////////
//Rhino.RhinoDoc.ActiveDoc.Objects.AddCurve(be);
////////////////
break;
}
}
if (register_anyway)
{
Naked_Breps.Add(BrepList[q].Faces[EdgeMembers[0]].DuplicateFace(false));
Naked_Edges.Add(be);
EdgeDomains.Add(new double[] { be.Domain[0], be.Domain[1] });
Lengths.Add(l);
Brep_IDS.Add(q);
////////////////
//Rhino.RhinoDoc.ActiveDoc.Objects.AddCurve(be);
////////////////
}
break;
case EdgeAdjacency.None:
//Ignore this edge...
//What kind of edge, is neither Naked, nor Interior, nor NonManifold??
continue;
case EdgeAdjacency.NonManifold:
//Ignore tnis edge, but alert the user...
System.Windows.Forms.MessageBox.Show("Non-Manifold Edges. Could you please send a copy of this model to [email protected]? Also - if you know how you built this, please don't do it again...");
break;
}
}
}
///In descending order by length - first edge will always be the longer one.
Naked_Breps.Reverse();
Naked_Edges.Reverse();
EdgeDomains.Reverse();
Brep_IDS.Reverse();
Lengths.Reverse();
//Handle Naked Edges... (this is now probably the only work being done by this function... this is where the magic happens...)
double tolerance = 0.001;
List<Curve> Orphaned_Edge = new List<Curve>();
List<Brep> Orphaned_Brep = new List<Brep>();
while (Naked_Edges.Count > 0)
{
bool orphaned = true; //Orphaned until proven otherwise...
while (Naked_Edges[0] == null)
{
Naked_Edges.RemoveAt(0);
Naked_Breps.RemoveAt(0);
EdgeDomains.RemoveAt(0);
Lengths.RemoveAt(0);
Brep_IDS.RemoveAt(0);
continue;
}
List<Curve> ToAdd = new List<Curve>();
List<Brep> ToAddMembers = new List<Brep>();
List<int> ToAddIDS = new List<int>();
for (int shortid = 1; shortid < Naked_Edges.Count; shortid++)
{
Brep[] BR = new Brep[2] { Naked_Breps[shortid], Naked_Breps[0] };
int[] B_IDS = new int[2] { Brep_IDS[shortid], Brep_IDS[0] };
//Check for Match Case: (simplest edge coincidence)
if (Naked_Edges[0].GetLength() - Naked_Edges[shortid].GetLength() < 0.01)
{
//Curves are effectively the same length... this might be very easy.
if (((Naked_Edges[0].PointAtStart - Naked_Edges[shortid].PointAtStart).SquareLength < 0.0001) && ((Naked_Edges[0].PointAtEnd - Naked_Edges[shortid].PointAtEnd).SquareLength < 0.0001) ||
((Naked_Edges[0].PointAtStart - Naked_Edges[shortid].PointAtEnd).SquareLength < 0.0001) && ((Naked_Edges[0].PointAtEnd - Naked_Edges[shortid].PointAtStart).SquareLength < 0.0001))
{
//Curves are effectively coincident...
if (Naked_Edges[shortid].IsLinear()) Edge_Nodes.Add(new Edge_Straight(ref S, ref R, this.Env_Prop, BR, B_IDS, Naked_Edges[shortid]));
else Edge_Nodes.Add(new Edge_Curved(ref S, ref R, this.Env_Prop, BR, B_IDS, Naked_Edges[0]));
Naked_Edges.RemoveAt(shortid);
Naked_Breps.RemoveAt(shortid);
EdgeDomains.RemoveAt(shortid);
Lengths.RemoveAt(shortid);
Brep_IDS.RemoveAt(shortid);
Naked_Edges.RemoveAt(0);
Naked_Breps.RemoveAt(0);
EdgeDomains.RemoveAt(0);
Lengths.RemoveAt(0);
Brep_IDS.RemoveAt(0);
orphaned = false;
break;
}
}
//if (Naked_Edges[shortid] == null) continue;
//Does start or end point fall on longer curve...
double t1;
double dir;
double domstart;
Point3d Start;
if (Naked_Edges[0].ClosestPoint(Naked_Edges[shortid].PointAtStart, out t1, tolerance) && Naked_Edges[0].TangentAt(t1).IsParallelTo(Naked_Edges[shortid].TangentAtStart) > 0)
{
//Does start id on short curve intersect?
//if (Naked_Edges[shortid].TangentAt(t1).IsParallelTo(Naked_Edges[0].TangentAtStart) == 0) continue;
dir = .1;
Start = Naked_Edges[shortid].PointAtStart;
domstart = EdgeDomains[shortid][0];
}
else if (Naked_Edges[0].ClosestPoint(Naked_Edges[shortid].PointAtEnd, out t1, tolerance) && Naked_Edges[0].TangentAt(t1).IsParallelTo(Naked_Edges[shortid].TangentAtEnd) > 0)
{
//Does end point on short curve intersect?
//if (Naked_Edges[shortid].TangentAt(t1).IsParallelTo(Naked_Edges[0].TangentAtEnd) == 0) continue;
Start = Naked_Edges[shortid].PointAtEnd;
dir = -.1;
domstart = EdgeDomains[shortid][1];
}
else
{
//Does any point on curves intersect?
int g;
Point3d p1, p2;
if (!Naked_Edges[0].ClosestPoints(new Curve[] { Naked_Edges[shortid] }, out p1, out p2, out g, 0.01)) continue;
dir = .1;
Start = Naked_Edges[shortid].PointAtStart;
t1 = Naked_Edges[shortid].Domain.T0;
domstart = EdgeDomains[shortid][0];
}
//Iterate across curves, Dog-Man style.
double tsS = t1, tsE = t1;
while (true)
{
////if curves are not merged
//////Go to the next point on the short curve and keep looking, till the short curve is exhausted.
tsS = tsE;
double tlS;
Point3d pt = Naked_Edges[shortid].PointAt(tsS);
if (!Naked_Edges[0].ClosestPoint(pt, out tlS, 0.02))
{
//They don't match up.
if (Naked_Edges[0].Domain.IncludesParameter(tsS))
{
//We are still on the long curve: Keep checking in case it may match up later...
tsE += dir;
continue;
}
break;
}
double tlE = tlS;
if (Math.Abs(Rhino.Geometry.Vector3d.Multiply(Naked_Edges[shortid].TangentAt(tsS), Naked_Edges[0].TangentAt(tlS))) < 0.98)
{
// edges may meet here, but the curves are not even remotely parallel... they might be some kind of corner junction. Go to the next curve.
tsE += dir;
continue;
}
////If curves are merged, iterate through points until curves do not merge, or entire section of one or other is exhausted.
tsE += dir;
pt = Naked_Edges[shortid].PointAt(tsE);
double tl2, ts2 = t1;
while (Naked_Edges[0].ClosestPoint(pt, out tl2, 0.01))
{
double d = Naked_Edges[0].PointAt(tl2).DistanceTo(pt);
if (d > 0.01) break;
//Curves are merged - increment check and try again.
tlE = tl2;
tsE = ts2;
ts2 += dir;
pt = Naked_Edges[shortid].PointAt(tsE);
}
if (tsS > tsE)
{
double t = tsE;
tsE = tsS;
tsS = t;
}
if (tlS > tlE)
{
double t = tlE;
tlE = tlS;
tlS = t;
}
Curve newEdge = Naked_Edges[shortid].Trim(new Interval(tsS, tsE));
if (newEdge == null || newEdge.GetLength() < 0.01) continue;
if (newEdge.IsLinear()) Edge_Nodes.Add(new Edge_Straight(ref S, ref R, this.Env_Prop, BR, B_IDS, newEdge));
else Edge_Nodes.Add(new Edge_Curved(ref S, ref R, this.Env_Prop, BR, B_IDS, newEdge));
newEdge = Naked_Edges[shortid].Trim(new Interval(tsE, Naked_Edges[shortid].Domain.T1));
if (newEdge != null)
{
ToAdd.Add(newEdge);
ToAddMembers.Add(Naked_Breps[shortid]);
ToAddIDS.Add(Brep_IDS[shortid]);
}
newEdge = Naked_Edges[shortid].Trim(new Interval(Naked_Edges[shortid].Domain.T0, tsS));
if (newEdge != null)
{
ToAdd.Add(newEdge);
ToAddMembers.Add(Naked_Breps[shortid]);
ToAddIDS.Add(Brep_IDS[shortid]);
}
newEdge = Naked_Edges[0].Trim(new Interval(tlE, Naked_Edges[0].Domain.T1));
if (newEdge != null)
{
ToAdd.Add(newEdge);
ToAddMembers.Add(Naked_Breps[0]);
ToAddIDS.Add(Brep_IDS[0]);
}
newEdge = Naked_Edges[0].Trim(new Interval(Naked_Edges[0].Domain.T0, tlS));
if (newEdge != null)
{
ToAdd.Add(newEdge);
ToAddMembers.Add(Naked_Breps[0]);
ToAddIDS.Add(Brep_IDS[0]);
}
///////If curves diverge... trim merged extent from one, and record as edge. Cut this portion out of existing curves, and re-enter into sorted curve list.
orphaned = false;
Naked_Edges.RemoveAt(shortid);
Naked_Breps.RemoveAt(shortid);
EdgeDomains.RemoveAt(shortid);
Brep_IDS.RemoveAt(shortid);
Lengths.RemoveAt(shortid);
Naked_Edges.RemoveAt(0);
Naked_Breps.RemoveAt(0);
EdgeDomains.RemoveAt(0);
Brep_IDS.RemoveAt(0);
Lengths.RemoveAt(0);
for (int k = 0; k < ToAdd.Count; k++)
{
bool added = false;
///////////
Rhino.RhinoDoc.ActiveDoc.Objects.AddCurve(ToAdd[k]);
///////////
double l = ToAdd[k].GetLength();
for (int i = 0; i < Naked_Edges.Count; i++)
{
if (l < Lengths[i])
{
Naked_Breps.Insert(i, ToAddMembers[k]);
Naked_Edges.Insert(i, ToAdd[k]);
EdgeDomains.Insert(i, new double[] { ToAdd[k].Domain.T0, ToAdd[k].Domain.T1 });
Lengths.Insert(i, l);
Brep_IDS.Insert(i, ToAddIDS[k]);
added = true;
break;
}
}
if (added) continue;
Naked_Breps.Add(ToAddMembers[k]);
Naked_Edges.Add(ToAdd[k]);
EdgeDomains.Add(new double[] { ToAdd[k].Domain[0], ToAdd[k].Domain[1] });
Lengths.Add(l);
Brep_IDS.Add(ToAddIDS[k]);
}
break;
}
if (ToAdd.Count > 0) break;
}
if (orphaned)
{
//Check for intersecting geometry. (T-section)
for (int i = 0; i < this.BrepList.Count; i++ )
{
Curve[] crv;
Point3d[] pts;
Rhino.Geometry.Intersect.Intersection.CurveBrep(Naked_Edges[0], BrepList[i], 0.01, out crv, out pts);
}
Rhino.RhinoApp.WriteLine("Orphaned Edge... Assuming thin plate in free air. (Warning: T-Intersects not yet implemented.)");
//Create thin plate...
Brep Converse = Naked_Breps[0].Duplicate() as Brep;
Converse.Surfaces[0].Reverse(0, true);
if (Naked_Edges[0].IsLinear()) Edge_Nodes.Add(new Edge_Straight(ref S, ref R, this.Env_Prop, new Brep[] { Naked_Breps[0], Naked_Breps[0] }, new int[2] { Brep_IDS[0], Brep_IDS[0] }, Naked_Edges[0]));
else Edge_Nodes.Add(new Edge_Curved(ref S, ref R, this.Env_Prop, new Brep[] { Naked_Breps[0], Converse }, new int[2] { Brep_IDS[0], Brep_IDS[0] }, Naked_Edges[0]));
//Remove this edge from Naked_Edges
Naked_Edges.RemoveAt(0);
Naked_Breps.RemoveAt(0);
EdgeDomains.RemoveAt(0);
Brep_IDS.RemoveAt(0);
Lengths.RemoveAt(0);
}
}
}
protected CustomBrepObject(Brep brep)
: base(true)
{
Guid type_id = GetType().GUID;
IntPtr pConstBrep = brep.ConstPointer();
m_pRhinoObject = UnsafeNativeMethods.CRhinoCustomObject_New2(type_id, pConstBrep);
}
