public static Curve GenerateSplitCurve(Brep zone, Curve core)
{
Point3d zoneCenter = Utils.GetRegionCenter(zone);
Point3d coreCenter = Utils.GetRegionCenter(Brep.CreatePlanarBreps(core)[0]);
Vector3d vectorToCore = new Vector3d(coreCenter - zoneCenter);
bool isVerticalProportion = Confirm.VectorProportionIsVertical(vectorToCore);
double componentToCheck = (isVerticalProportion) ? vectorToCore.Y : vectorToCore.X;
bool isPositive = (componentToCheck > 0) ? true : false;
Point3d coreMin = Brep.CreatePlanarBreps(core)[0].GetBoundingBox(Plane.WorldXY).Min;
Point3d coreMax = Brep.CreatePlanarBreps(core)[0].GetBoundingBox(Plane.WorldXY).Max;
Point3d coreExtent = (isPositive) ? coreMin : coreMax;
double coreExtentValue = (isVerticalProportion) ? coreExtent.Y : coreExtent.X;
Point3d zoneMin = zone.GetBoundingBox(Plane.WorldXY).Min;
Point3d zoneMax = zone.GetBoundingBox(Plane.WorldXY).Max;
Point3d zoneExtent = (isPositive) ? zoneMin : zoneMax;
double zoneExtentValue = (isVerticalProportion) ? zoneExtent.Y : zoneExtent.X;
double curveOffset = (zoneExtentValue - coreExtentValue) * 0.20; //Make this a function of zone proportionality.
double curveStart = coreExtentValue + curveOffset;
Curve splitCurve = (isVerticalProportion) ? new LineCurve(new Point2d(zoneMin.X, curveStart), new Point2d(zoneMax.X, curveStart)) : new LineCurve(new Point2d(curveStart, zoneMin.Y), new Point2d(curveStart, zoneMax.Y));
return(splitCurve);
}
// iterate through the grid in the x directions
/// <summary>
/// Iterate through the grid and add voxels that are inside the Brep
/// </summary>
/// <param name="brepVolume"></param>
/// <param name="vg"></param>
public void AddSolidBrep(Brep brepVolume, ref VoxelGrid3D vg)
{
// get the axis direction for each point
var pt1 = vg.EvaluatePoint(new Point3i(0, 0, 0));
var pt2 = vg.EvaluatePoint(new Point3i(1, 0, 0));
var pln = new Plane(pt1, (pt2 - pt1));
for (var x = 0; x < vg.SizeUVW.X; x++)
{
pln.Origin = vg.EvaluatePoint(new Point3i(x, 0, 0));
Intersection.BrepPlane(brepVolume, pln, DocumentHelper.GetModelTolerance(), out var sections, out var pts);
var surfaces = Brep.CreatePlanarBreps(sections);
// perhaps check first if the points are inside the bounding box of the surface.
if (surfaces == null)
{
continue;
}
for (var y = 0; y < vg.SizeUVW.Y; y++)
{
for (var z = 0; z < vg.SizeUVW.Z; z++)
{
var pt = vg.EvaluatePoint(new Point3i(x, y, z));
var hasPixel = surfaces.Any(t => t.ClosestPoint(pt).DistanceTo(pt) < DocumentHelper.GetModelTolerance());
if (hasPixel)
{
vg.SetValue(new Point3i(x, y, z), true);
}
}
}
}
}
public static Brep BuildBrep(PolyCurve externalEdge, List <PolyCurve> voidCurves = null, double tolerance = -1)
{
if (tolerance < 0)
{
tolerance = 0.1; //Tolerance.RhinoDocTolerance();
}
Rhino.Collections.CurveList curves = new Rhino.Collections.CurveList
{
externalEdge
};
if (voidCurves != null)
{
curves.AddRange(voidCurves);
}
Brep[] brep = Brep.CreatePlanarBreps(curves, tolerance);
if (brep == null)
{
Brep brep2 = Brep.CreateEdgeSurface(curves);
if (brep == null)
{
return(null);
}
else
{
return(brep2);
}
}
else
{
return(brep[0]);
}
}
static public IList <Brep> ToRhino(this Solid geomObj)
{
Solid geomSolid = geomObj as Solid;
if (null != geomSolid)
{
var brepSrfs = new List <Brep>();
foreach (Face geomFace in geomSolid.Faces) // get the faces from the solid
{
var facePts = new List <Point3d>();
var edgeLp = geomFace.EdgeLoops.get_Item(0);
//int c = 0;
foreach (Edge edge in edgeLp) // get edges from edges
{
var crv = edge.AsCurve();
XYZ p1 = edge.Evaluate(0); // extract start point
var point = p1.ToRhino(); // convert to rhino poing
facePts.Add(point); // save pt to list
//if (c == geomEdges.Size)
//if (c == edgeLp.Size-1)
//{
// XYZ p2 = edge.Evaluate(1); // get the last point in the edge loop
// var endPt = p2.ToRhino();
// facePts.Add(endPt);
//}
// c++;
}
var lastEdge = edgeLp.get_Item(edgeLp.Size - 1);
XYZ p2 = lastEdge.Evaluate(1.0);
var endPt = p2.ToRhino();
facePts.Add(endPt);
TaskDialog.Show("FacePts nums: ", facePts.Count.ToString());
Rhino.Geometry.Curve tempCurve = Rhino.Geometry.Curve.CreateInterpolatedCurve(facePts, 1);
if (!tempCurve.IsClosed)
{
facePts.Add(facePts[0]);
tempCurve = Rhino.Geometry.Curve.CreateInterpolatedCurve(facePts, 1);
}
List <Brep> breps = new List <Brep>();
Brep[] planarBreps = Brep.CreatePlanarBreps(tempCurve, 0.01);
//outVals.Add(planarBreps.Count().ToString());
if (planarBreps != null)
{
brepSrfs.Add(planarBreps[0]);
}
}
var joinedBrep = Rhino.Geometry.Brep.JoinBreps(brepSrfs, 0.01);
return(joinedBrep);
//var ghB = new GH_Brep(joinedBrep);
//ghbreps.Add(ghB);
}
else
{
return(new List <Brep>());
}
}
protected override Result RunCommand(RhinoDoc doc, RunMode mode)
{
ObjRef sRef;
Result r = RhinoGet.GetOneObject("Pick closed curve", false, ObjectType.Curve, out sRef);
if (r != Result.Success || null == sRef)
{
return(r);
}
RhinoObject obj = sRef.Object();
obj.Attributes.SetUserString("Name", "Concrete");
Curve selectedCurve = sRef.Curve();
//if the curve is not closed do nothing
if (!selectedCurve.IsClosed)
{
Rhino.RhinoApp.WriteLine("The curve was not closed!!");
return(Result.Success);
}
List <Brep> breps = new List <Brep>();
List <Curve> cuttedCurves = CurveAndBrepManipulation.cutCurve(selectedCurve, Plane.WorldXY, Axis.XAxis);
foreach (Curve curve in cuttedCurves)
{
breps.AddRange(Brep.CreatePlanarBreps(curve));
}
DrawAndSaveUserAttr(breps, doc, obj);
return(Result.Success);
}
private Brep PlaneToBrep(Plane plane)
{
var boundary = plane.Boundary;
if (boundary.Count == 0)
{
return(null);
}
var polyline = Curve.CreateControlPointCurve(boundary, 1);
var tolerance = Rhino.RhinoDoc.ActiveDoc.ModelAbsoluteTolerance;
var breps = Brep.CreatePlanarBreps(polyline, tolerance);
if (breps == null)
{
return(null);
}
if (breps.Length != 1)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Created more or less than one brep.");
}
return(breps[0]);
}
// Casting to GH Data Types
public Brep ToPlanarBrep()
{
var sEdges = from e in Edges
select e.ToCurve();
return(Brep.CreatePlanarBreps(Curve.JoinCurves(sEdges), 0.01)[0]);
}
public Brep buildHelical(Curve Sectioin, Circle C, double Deg, double H, bool Solid)
{
double angle = (H / Math.Tan(toRadian(Deg))) / (C.Radius * 2 * Math.PI);
List <Curve> gears = new List <Curve>();
double step = 3;
for (int i = 0; i < (int)step + 1; i++)
{
Curve thisC = Sectioin.DuplicateCurve();
Transform rotate = Transform.Rotation(angle * (double)i / step, C.Normal, C.Center);
Transform move = Transform.Translation(C.Normal * H * (double)i / step);
thisC.Transform(rotate);
thisC.Transform(move);
gears.Add(thisC);
}
Brep profile = Brep.CreateFromLoft(gears, Point3d.Unset, Point3d.Unset, LoftType.Normal, false)[0];
if (Solid)
{
Brep top = Brep.CreatePlanarBreps(gears[0], 1)[0];
Brep buttom = Brep.CreatePlanarBreps(gears[(int)step], 1)[0];
List <Brep> breps = new List <Brep> {
buttom, profile, top
};
return(Brep.CreateSolid(breps, 1.0)[0]);
}
else
{
return(profile);
}
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
var tbeam = (FirstHalf.Element as BeamElement).Beam;
var mbeam = (SecondHalf.Element as BeamElement).Beam;
var tplane = tbeam.GetPlane(FirstHalf.Parameter);
var mplane = mbeam.GetPlane(SecondHalf.Parameter);
var splicePlane = new Plane((tplane.Origin + mplane.Origin) / 2, tplane.XAxis, tplane.YAxis);
var spliceCutter = Brep.CreatePlanarBreps(new Curve[] {
new Rectangle3d(splicePlane, new Interval(-300, 300), new Interval(-300, 300)).ToNurbsCurve()
}, 0.01);
FirstHalf.Geometry.AddRange(spliceCutter);
SecondHalf.Geometry.AddRange(spliceCutter);
return(true);
}
// Do not generate extrusion from curve => Potential Rhinocommon Bugs.
// note: curve orientation might cause some trouble...
public static Brep Extrude(Curve curve, Vector3d vector, double tolerance)
{
var planar = Brep.CreatePlanarBreps(curve, tolerance)[0];
Brep extrusion = Extrude(planar, vector, tolerance);
return(extrusion);
}
public override bool Construct(bool append = false)
{
if (!append)
{
foreach (var part in Parts)
{
part.Geometry.Clear();
}
}
var tbeam = (Tenon.Element as BeamElement).Beam;
var mbeam = (Mortise.Element as BeamElement).Beam;
var trimInterval = new Interval(-TrimPlaneSize, TrimPlaneSize);
var mplane = mbeam.GetPlane(Mortise.Parameter);
var tplane = tbeam.GetPlane(Tenon.Parameter);
var vec = tbeam.Centreline.PointAt(tbeam.Centreline.Domain.Mid) - tbeam.Centreline.PointAt(Tenon.Parameter);
int sign = 1;
if (vec * mplane.XAxis < 0)
{
sign = -sign;
}
var tz = tplane.ZAxis;
if (tz * vec > 0)
{
tz = -tz;
}
var trimPlane = new Plane(mplane.Origin + mplane.XAxis * mbeam.Width * 0.5 * sign, mplane.ZAxis, mplane.YAxis);
var trimmer = Brep.CreatePlanarBreps(new Curve[] { new Rectangle3d(trimPlane,
trimInterval, trimInterval).ToNurbsCurve() }, 0.01);
Tenon.Geometry.AddRange(trimmer);
var projTrim = trimPlane.ProjectAlongVector(tplane.ZAxis);
for (int i = -1; i < 2; i += 2)
{
//Point3d dp = new Point3d(tplane.Origin + tplane.YAxis * (tbeam.Height * i - DowelOffset));
Point3d dp = new Point3d(tplane.Origin + tplane.YAxis * (DowelOffset * i));
dp.Transform(projTrim);
dp.Transform(Transform.Translation(-tz * DowelLength * 0.5));
var dowelPlane = new Plane(dp, tz);
var cyl = new Cylinder(
new Circle(dowelPlane, DowelDiameter * 0.5), DowelLength + DowelLengthExtra).ToBrep(true, true);
Tenon.Geometry.Add(cyl);
Mortise.Geometry.Add(cyl);
}
return(true);
}
/// <summary>
/// This function creates a brep from planar curves
/// </summary>
///
///
public static Brep[] XCreateBrepFromPlanarCurves(CurveList curves, RhinoDoc doc)
{
return(Brep.CreatePlanarBreps(curves, doc.ModelAbsoluteTolerance));
//it's a bit odd for us to create our own method XCreateBrepFromPlanarCurves that
//simply calls the RhinoCommon CreatePlanarBreps method, but for the purpose of the
//exercise, we'll let it go.
}
//private Brep ToNonPlanarBrep()
//{
// // Returns a Nurbs Surface of Degree 2
// //var srfc = Rhino.Geometry.NurbsSurface.CreateFromPoints(ControlPoints.OfType<Point3d>().ToList(), ControlPoints.GetLength(0), ControlPoints.GetLength(1), 2, 2);
// // return srfc.ToBrep();
// return Rhino.Geometry.Brep.CreateEdgeSurface(Edges.Select(x => x.ToCurve())).Faces[0].Brep;
//}
public Boolean IsPlanar()
{
if (Brep.CreatePlanarBreps(Edges.Select(x => x.ToCurve()), 0.0005) != null)
{
return(true);
}
return(false);
}
public void OverlappingSquareAndSquareRegion_ReturnsTrue()
{
Curve testCurve = CurvesFactory.RectangleCWH(Point3d.Origin, 1, 1);
Brep testRegion = Brep.CreatePlanarBreps(testCurve, 0.1)[0];
bool result = Logic.Relationships.Confirm.CurveRegionIntersection(testCurve, testRegion);
Assert.IsTrue(result);
}
public void PointOutsideUnitSquare_ReturnsFalse()
{
Brep testRegion = Brep.CreatePlanarBreps(CurvesFactory.RectangleCWH(Point3d.Origin, 1, 1), 0.1)[0];
Point3d testPoint = new Point3d(5, 5, 0);
bool result = Logic.Relationships.Confirm.PointInRegion(testRegion, testPoint);
Assert.IsFalse(result);
}
public override Brep ToBrep(double offset = 0.0)
{
int N = Math.Max(Data.Samples, 6);
GenerateCrossSectionPlanes(N, out Plane[] frames, out double[] parameters, Data.InterpolationType);
var cross_section_profile = new Polyline(GenerateCorners(offset));
cross_section_profile.Add(cross_section_profile[0]);
Transform xform;
var profiles = new List <Curve>();
for (int i = 0; i < parameters.Length; ++i)
{
//frames[i] = frames[i].FlipAroundYAxis();
xform = Rhino.Geometry.Transform.PlaneToPlane(Plane.WorldXY, frames[i]);
var temp_profile = cross_section_profile.Duplicate().ToNurbsCurve();
temp_profile.Transform(xform);
profiles.Add(temp_profile);
}
if (profiles.Count < 1)
{
throw new Exception("FreeformGlulam.ToBrep(): profiles was null");
}
var body = Brep.CreateFromLoft(profiles, Point3d.Unset, Point3d.Unset, LoftType.Tight, false);
var start_cap = Brep.CreatePlanarBreps(profiles.First(), Tolerance);
var end_cap = Brep.CreatePlanarBreps(profiles.Last(), Tolerance);
if (body == null)
{
throw new Exception("FreeformGlulam.ToBrep(): body was null");
}
else if (start_cap == null)
{
throw new Exception("FreeformGlulam.ToBrep(): start_cap was null");
}
else if (end_cap == null)
{
throw new Exception("FreeformGlulam.ToBrep(): end_cap was null");
}
var joined = Brep.JoinBreps(body.Concat(start_cap).Concat(end_cap), Tolerance);
if (joined.Length > 0)
{
joined[0].Faces.SplitKinkyFaces(0.1, true);
return(joined[0]);
}
else
{
throw new Exception("FreeformGlulam.ToBrep(): Joined Brep failed.");
}
}
//this is for when the runs are parallel
private Brep getSurfaceTypeA()
{
//making decisions based on the lateral displacement
Point3d corner1, corner2;
Vector3d xVec;
Vector3d yVec = this.bottomRun.RunDirection;
Vector3d diagonal;
string startingAt;
if (this.BottomEdge.From.DistanceTo(this.TopEdge.To) >= this.BottomEdge.To.DistanceTo(this.TopEdge.From))
{
corner1 = this.BottomEdge.From;
corner2 = this.TopEdge.To;
xVec = new Vector3d(this.BottomEdge.To - this.BottomEdge.From);
diagonal = new Vector3d(this.TopEdge.To - this.BottomEdge.From);
startingAt = "from";
}
else
{
corner1 = this.BottomEdge.To;
corner2 = this.TopEdge.From;
xVec = new Vector3d(this.BottomEdge.From - this.BottomEdge.To);
diagonal = new Vector3d(this.TopEdge.From - this.BottomEdge.To);
startingAt = "to";
}
yVec.Unitize();
xVec.Unitize();
//now making the surface
List <Point3d> railPts1 = new List <Point3d>();
List <Point3d> railPts2 = new List <Point3d>();
List <Point3d> ptList = new List <Point3d>();
ptList.Add(corner1); railPts1.Add(corner1);
double distX = diagonal * xVec;
double distY = this.BottomEdge.DistanceTo(this.TopEdge.From, false);
Point3d pt = corner1 + (yVec * distY);
ptList.Add(pt); railPts1.Add(pt); railPts1.Add(pt + xVec * (distX - this.topRun.Width));
pt += xVec * distX;
ptList.Add(pt); railPts2.Add(pt);
pt += distY * (-yVec);
ptList.Add(pt); railPts2.Add(pt); railPts2.Add(pt - xVec * (distX - this.bottomRun.Width));
ptList.Add(corner1);
Curve edge = Curve.CreateInterpolatedCurve(ptList, 1);
edge.MakeClosed(0);
Curve railEdge1 = Curve.CreateInterpolatedCurve(railPts1, 1);
Curve railEdge2 = Curve.CreateInterpolatedCurve(railPts2, 1);
this.RightRailEdge = (startingAt == "from") ? railEdge1 : railEdge2;
this.LeftRailEdge = (startingAt == "to") ? railEdge1 : railEdge2;
Brep[] breps = Brep.CreatePlanarBreps(edge);
return(breps[0]);
}
// cut the area with pri/sec lines
public void getSecTowerBase(double density)
{
// brp of self
if (this.SecLns.Count == 0)
{
return;
}
Brep[] brp = Brep.CreatePlanarBreps(this.OuterBorder, inter_tol);
// ensure no duplicated curves here !important
List <Curve> joins = new List <Curve>();
List <Point3d> start = new List <Point3d>();
List <Point3d> end = new List <Point3d>();
foreach (Curve cv in this.SecLns)
{
if (start.Contains(cv.PointAtStart))
{
continue;
}
if (end.Contains(cv.PointAtEnd))
{
continue;
}
start.Add(cv.PointAtStart);
end.Add(cv.PointAtEnd);
joins.Add(cv);
}
Curve[] c = Curve.JoinCurves(joins, inter_tol);
double off = density * (this.offsetMax() - 2);
Curve[] offset = c[0].Offset(this.Center, Vector3d.ZAxis, off, inter_tol, CurveOffsetCornerStyle.Sharp);
if (!offset[0].IsValid)
{
return;
}
Curve extended = offset[0].Extend(CurveEnd.Both, extent, CurveExtensionStyle.Line);
Brep[] cutted = brp[0].Split(new List <Curve> {
extended
}, inter_tol);
cutted = cutted.Where(brptmp => brptmp != null).ToArray();
if (cutted.Length == 0)
{
return;
}
List <double> areas = new List <double>();
List <Brep> parts = new List <Brep>();
foreach (Brep cut in cutted)
{
AreaMassProperties amp = AreaMassProperties.Compute(cut);
areas.Add(amp.Area);
parts.Add(cut);
}
this.TowerS = parts[areas.IndexOf(areas.Min())];
}
//[TestMethod]
public void DisjointSquareAndSquareRegion_ReturnsFalse()
{
Curve testCurve = CurvesFactory.RectangleCWH(Point3d.Origin, 1, 1);
Curve regionCurve = CurvesFactory.RectangleCWH(new Point3d(5, 5, 0), 1, 1);
Brep testRegion = Brep.CreatePlanarBreps(regionCurve, 0.1)[0];
bool result = Logic.Relationships.Confirm.CurveRegionIntersection(testCurve, testRegion);
Assert.IsFalse(result);
}
public void AdjacentSquareAndSquareRegion_ReturnsTrue()
{
Curve testCurve = CurvesFactory.RectangleCWH(new Point3d(1, 0, 0), 2, 2);
Curve regionCurve = CurvesFactory.RectangleCWH(new Point3d(-1, 0, 0), 2, 2);
Brep testRegion = Brep.CreatePlanarBreps(regionCurve, 0.1)[0];
bool result = Logic.Relationships.Confirm.CurveRegionIntersection(testCurve, testRegion);
Assert.IsTrue(result);
}
private static Brep drawWall(Curve baseCurve, double height, double wallDepth)
{
Vector3d tempPlusVector = new Vector3d(baseCurve.PointAt(1) - baseCurve.PointAt(0));
tempPlusVector = tempPlusVector / tempPlusVector.Length;
Plane tempPlane = new Plane(Point3d.Origin, tempPlusVector, Vector3d.ZAxis);
Curve baseRectangle = offsetOneSide(baseCurve, height, Vector3d.ZAxis);
Curve pathCurve = new LineCurve(Point3d.Origin, new Point3d(tempPlane.ZAxis * wallDepth));
return(Brep.CreatePlanarBreps(baseRectangle)[0].Faces[0].CreateExtrusion(pathCurve, true));
}
/// <summary>
/// Returns the unjoined, planar faces
/// </summary>
public Brep[] Faces()
{
var e = Edges();
if (EdgeCount != e.Length)
{
return(null);
}
return(Brep.CreatePlanarBreps(e, 0.001));
}
public void UnitSquare_ContainedCurve_ReturnsOne()
{
Brep testSquare = Brep.CreatePlanarBreps(CurvesFactory.RectangleCWH(Point3d.Origin, 5, 5), 0.1)[0];
List <Curve> testCurves = new List <Curve>();
testCurves.Add(CurvesFactory.CenteredYCurve());
List <Brep> resultGeometry = Logic.Transformations.Breps.SplitByCurves(testSquare, testCurves);
Assert.AreEqual(1, resultGeometry.Count);
}
public void UnitSquare_DisjointCurve_ReturnsOne()
{
Brep testSquare = Brep.CreatePlanarBreps(CurvesFactory.RectangleCWH(Point3d.Origin, 1, 1), 0.1)[0];
List <Curve> testCurves = new List <Curve>();
testCurves.Add(CurvesFactory.LineSDL(new Point2d(10, 10), new Vector2d(1, 1), 1));
List <Brep> resultGeometry = Logic.Transformations.Breps.SplitByCurves(testSquare, testCurves);
Assert.AreEqual(1, resultGeometry.Count);
}
public static List <Brep> CircleInSquare()
{
List <Brep> TestEnvironment = new List <Brep>();
Brep testCircle = Brep.CreatePlanarBreps(RegionsFactory.CenteredCircleRadius(1), .1)[0];
Brep testSquare = Brep.CreatePlanarBreps(RegionsFactory.RectangleWHC(5, 5, Point3d.Origin), .1)[0];
TestEnvironment.Add(testCircle);
TestEnvironment.Add(testSquare);
return(TestEnvironment);
}
public static Brep ToAllPlaneBrep(this Brep roomBrep, double tolerance = 0.0001)
{
var tol = tolerance;
var surfs = roomBrep.Faces;
surfs.ShrinkFaces();
var checkedSrfs = new List <Brep>();
foreach (var srf in surfs)
{
var s = srf.UnderlyingSurface();
if (s is PlaneSurface ps)
{
checkedSrfs.Add(ps.ToBrep());
}
else if (srf.IsPlanar())
{
var cv = srf.OuterLoop.To3dCurve();
var p = Brep.CreatePlanarBreps(cv, tol).First();
checkedSrfs.Add(p);
}
else
{
throw new ArgumentException("Non-planar surfaces are not accepted!");
}
}
//Method 1
var solid = Brep.CreateSolid(checkedSrfs, tol).OrderBy(_ => _.Faces.Count).LastOrDefault();
if (solid.IsSolid)
{
return(solid);
}
//Method 2
solid = new Brep();
checkedSrfs.ToList().ForEach(_ => solid.Append(_));
solid.JoinNakedEdges(tol);
if (solid.IsSolid)
{
return(solid);
}
//Method 3
var joined = Brep.JoinBreps(checkedSrfs, tol).OrderBy(_ => _.Faces.Count).ToList();
if (!joined.LastOrDefault().IsSolid)
{
solid = joined.Select(_ => _.CapPlanarHoles(tol)).SkipWhile(_ => _ == null).FirstOrDefault();
}
return(solid);
}
// find the shortest offset value
public double offsetMax()
{
Brep[] brp = Brep.CreatePlanarBreps(this.Outline.ToNurbsCurve(), inter_tol);
List <double> dists = new List <double>();
foreach (BrepEdge ed in brp[0].Edges)
{
Line ln = new Line(ed.PointAtStart, ed.PointAtEnd);
dists.Add(ln.DistanceTo(this.Center, false));
}
return(dists.Min());
}
public void TestCreateGsaMem2dFromBrep()
{
// create a list of corner points
List <Point3d> pts = new List <Point3d>();
pts.Add(new Point3d(-3, -4, 0));
pts.Add(new Point3d(5, -2, 0));
pts.Add(new Point3d(6, 7, 0));
pts.Add(new Point3d(-1, 2, 0));
pts.Add(pts[0]); // add initial point to close curve
Polyline pol = new Polyline(pts); // create edge-crv from pts
// create planar brep from polyline
Brep brep = Brep.CreatePlanarBreps(pol.ToNurbsCurve(), 0.001)[0];
// empty lists for inclusion points and lines
List <Point3d> inclpts = new List <Point3d>();
List <Curve> inclcrvs = new List <Curve>();
// create 2d member from brep
GsaMember2d mem = new GsaMember2d(brep, inclcrvs, inclpts);
// set some members
mem.Colour = System.Drawing.Color.White;
mem.ID = 4;
mem.Member.MeshSize = 0.56;
mem.Member.Name = "meminem";
mem.Member.IsDummy = true;
mem.Member.Offset.Z = -0.45;
mem.Member.Property = 2;
mem.Member.Type2D = AnalysisOrder.LINEAR;
mem.Member.Type = MemberType.SLAB;
Assert.AreEqual(mem.Brep.Vertices[0].Location.X, mem.Topology[0].X);
Assert.AreEqual(mem.Brep.Vertices[0].Location.Y, mem.Topology[0].Y);
Assert.AreEqual(mem.Brep.Vertices[1].Location.X, mem.Topology[1].X);
Assert.AreEqual(mem.Brep.Vertices[1].Location.Y, mem.Topology[1].Y);
Assert.AreEqual(mem.Brep.Vertices[2].Location.X, mem.Topology[2].X);
Assert.AreEqual(mem.Brep.Vertices[2].Location.Y, mem.Topology[2].Y);
Assert.AreEqual(mem.Brep.Vertices[3].Location.X, mem.Topology[3].X);
Assert.AreEqual(mem.Brep.Vertices[3].Location.Y, mem.Topology[3].Y);
Assert.AreEqual(mem.Brep.Vertices[0].Location.X, mem.Topology[4].X);
Assert.AreEqual(mem.Brep.Vertices[0].Location.Y, mem.Topology[4].Y);
Assert.AreEqual(System.Drawing.Color.FromArgb(255, 255, 255, 255), mem.Member.Colour);
Assert.AreEqual(4, mem.ID);
Assert.AreEqual(0.56, mem.Member.MeshSize);
Assert.AreEqual("meminem", mem.Member.Name);
Assert.IsTrue(mem.Member.IsDummy);
Assert.AreEqual(-0.45, mem.Member.Offset.Z);
Assert.AreEqual(2, mem.Member.Property);
Assert.AreEqual(AnalysisOrder.LINEAR, mem.Member.Type2D);
Assert.AreEqual(MemberType.SLAB, mem.Member.Type);
}
public static bool CoreIsSmaller(TestFitPackage tf)
{
Brep floor = Brep.CreatePlanarBreps(tf.FloorPlanPackage.FloorProfile)[0];
Brep core = Brep.CreatePlanarBreps(tf.FloorPlanPackage.CoreProfile)[0];
double floorArea = floor.GetArea();
double coreArea = core.GetArea();
bool isSmaller = (coreArea < floorArea) ? true : false;
return(isSmaller);
}
public static List <Brep> SquareWithCircumscribedCircle()
{
List <Brep> TestEnvironment = new List <Brep>();
Brep testCircle = Brep.CreatePlanarBreps(RegionsFactory.CenteredCircleRadius(Math.Sqrt(2) / 2), .01)[0];
Brep testSquare = Brep.CreatePlanarBreps(RegionsFactory.RectangleWHC(1, 1, Point3d.Origin), .01)[0];
TestEnvironment.Add(testSquare);
TestEnvironment.Add(testCircle);
return(TestEnvironment);
}
