public static List <LinearPath> EntitiesIntersectingSemelleGet(LinearPath semelleLinPath, List <LinearPath> lstCadFooting, out List <Line> lstSemelleLongLine)
{
//intersected footings
HashSet <LinearPath> lstIntersectingEntity = new HashSet <LinearPath>();
Line[] lstSemelleLine = semelleLinPath.ConvertToLines();
lstSemelleLongLine = new List <Line>();
for (int i = 0; i < lstSemelleLine.Length; i++)
{
int counter = 0;
for (int j = 0; j < lstCadFooting.Count; j++)
{
if (MathHelper.IsLineSegmentIntersectingPolygon(lstCadFooting[j], lstSemelleLine[i]) /*&& (lstCadFooting[j] != semelleLinPath)*/)
{
counter++;
lstIntersectingEntity.Add(lstCadFooting[j]);
}
}
if (counter >= 2)
{
lstSemelleLongLine.Add(lstSemelleLine[i]);
}
}
return(lstIntersectingEntity.ToList());
}
public void LstRebarPopulate()
{
List <Point3D> points = new List <Point3D>();
LstRebar = new List <Rebar>();
LinearPath stirrupLinPath = (LinearPath)CadColumn.ColPath.Offset(-CadColumn.Cover * 1.2);
Line[] stirrupBranches = stirrupLinPath.ConvertToLines();
for (int i = 0; i < stirrupBranches.Length; i++)
{
Line branch = stirrupBranches[i];
Rebar rebarCorner1, rebarCorner2, rebarMid;
if (!points.Contains(branch.StartPoint))
{
rebarCorner1 = new Rebar(branch.StartPoint);
LstRebar.Add(rebarCorner1);
}
if (!points.Contains(branch.EndPoint))
{
rebarCorner2 = new Rebar(branch.EndPoint);
LstRebar.Add(rebarCorner2);
}
rebarMid = new Rebar(branch.MidPoint);
LstRebar.Add(rebarMid);
points.AddRange(branch.Vertices);
}
}
public static bool IsInsidePolygon(Point3D pt, LinearPath outer)
{
Line[] outerLines = outer.ConvertToLines();
Line l = new Line(pt,
new Point3D(CADConfig.Units == linearUnitsType.Meters ? pt.X + 1000 : pt.X + 100000, pt.Y, pt.Z));
int countIntersect = 0;
for (int j = 0; j < outerLines.Length; j++)
{
if (IsLineSegmentsIntersected(l, outerLines[j]))
{
countIntersect++;
}
}
if (countIntersect % 2 == 0)
{
return(false);
}
return(true);
}
public static bool IsInsidePolygon(LinearPath inner, LinearPath outer)
{
Line[] outerLines = outer.ConvertToLines();
for (int i = 0; i < inner.Vertices.Length; i++)
{
Line l = new Line(inner.Vertices[i],
new Point3D(CADConfig.Units == linearUnitsType.Meters ? inner.Vertices[i].X + 1000
: inner.Vertices[i].X + 100000, inner.Vertices[i].Y, inner.Vertices[i].Z));
bool colinear = false;
int countIntersect = 0;
for (int j = 0; j < outerLines.Length; j++)
{
if (IsLineSegmentsIntersected(l, outerLines[j], ref colinear))
{
countIntersect++;
}
}
if (!colinear && countIntersect % 2 == 0)
{
return(false);
}
}
return(true);
}
public void LstRebarPopulate()
{
LinearPath rftPath = CadWall.LinPathWall.Offset(DefaultValues.WallCover * -1) as LinearPath;
Line[] rftPathLines = rftPath.ConvertToLines();
Line longDirLine = null;
Line shortDirLine = null;
double longDirLength = double.MinValue;
double shortDirLength = double.MaxValue;
for (int i = 0; i < rftPathLines.Length; i++)
{
if (rftPathLines[i].Length() > longDirLength)
{
longDirLine = rftPathLines[i];
longDirLength = rftPathLines[i].Length();
}
if (rftPathLines[i].Length() < shortDirLength)
{
shortDirLine = rftPathLines[i];
shortDirLength = rftPathLines[i].Length();
}
}
Vector3D uvLength = MathHelper.UnitVector3DFromPt1ToPt2(longDirLine.StartPoint, longDirLine.EndPoint);
double dia = DefaultValues.BarDiameter;
Vector3D uvWidth;
if (longDirLine.Vertices.Contains(shortDirLine.StartPoint))
{
uvWidth = MathHelper.UnitVector3DFromPt1ToPt2(shortDirLine.StartPoint, shortDirLine.EndPoint);
}
else
{
uvWidth = MathHelper.UnitVector3DFromPt1ToPt2(shortDirLine.EndPoint, shortDirLine.StartPoint);
}
//placement
int nRebar = Convert.ToInt32(longDirLine.Length() / DefaultValues.LongBarSpacing);
for (int i = 0; i < nRebar; i++)
{
Point3D locationPt1 = longDirLine.StartPoint + uvLength * DefaultValues.LongBarSpacing * i;
Point3D locationPt2 = locationPt1 + uvWidth * shortDirLength;
Rebar rebar1 = new Rebar(locationPt1);
Rebar rebar2 = new Rebar(locationPt2);
LstRebar.Add(rebar1);
LstRebar.Add(rebar2);
}
}
internal static bool IsLineSegmentIntersectingPolygon(LinearPath linPath, Line line2)
{
foreach (Line line1 in linPath.ConvertToLines())
{
//double a1 = line1.EndPoint.Y - line1.StartPoint.Y;
//double b1 = line1.StartPoint.X - line1.EndPoint.X;
//double c1 = a1 * line1.StartPoint.X + b1 * line1.StartPoint.Y;
//double a2 = line2.EndPoint.Y - line2.StartPoint.Y;
//double b2 = line2.StartPoint.X - line2.EndPoint.X;
//double c2 = a2 * line2.StartPoint.X + b2 * line2.StartPoint.Y;
//double delta = a1 * b2 - a2 * b1;
//if (Math.Abs(delta) > 0.0001) // !=0
//{
int o1 = orientation(line1.StartPoint, line1.EndPoint, line2.StartPoint);
int o2 = orientation(line1.StartPoint, line1.EndPoint, line2.EndPoint);
int o3 = orientation(line2.StartPoint, line2.EndPoint, line1.StartPoint);
int o4 = orientation(line2.StartPoint, line2.EndPoint, line1.EndPoint);
if (o1 != o2 && o3 != o4)
{
return(true);
}
// Special Cases
// p1, q1 and p2 are colinear and p2 lies on segment p1q1
if (o1 == 0 && onSegment(line1.StartPoint, line2.StartPoint, line1.EndPoint))
{
return(true);
}
// p1, q1 and q2 are colinear and q2 lies on segment p1q1
if (o2 == 0 && onSegment(line1.StartPoint, line2.EndPoint, line1.EndPoint))
{
return(true);
}
// p2, q2 and p1 are colinear and p1 lies on segment p2q2
if (o3 == 0 && onSegment(line2.StartPoint, line1.StartPoint, line2.EndPoint))
{
return(true);
}
// p2, q2 and q1 are colinear and q1 lies on segment p2q2
if (o4 == 0 && onSegment(line2.StartPoint, line1.EndPoint, line2.EndPoint))
{
return(true);
}
//}
}
return(false); // Doesn't fall in any of the above cases
}
public static Line ShortestLineGet(LinearPath linPath)
{
Line[] lineArr = linPath.ConvertToLines();
Line shortestLine = null;
double length = double.MaxValue;
for (int j = 0; j < lineArr.Length; j++)
{
shortestLine = lineArr[j].Length() < length ? lineArr[j] : shortestLine;
}
return(shortestLine);
}
internal static List <Point3D> PointsIntersectOfLineSegmentWithPolygon(LinearPath linPath, Line line2)
{
List <Point3D> lstIntersecionPts = new List <Point3D>();
foreach (Line line1 in linPath.ConvertToLines())
{
Point3D intersectionPt = IntersectionOfTwoLineSegments(line1, line2);
if (intersectionPt != null)
{
lstIntersecionPts.Add(intersectionPt);
}
}
return(lstIntersecionPts); // Doesn't fall in any of the above cases
}
public void LstRebarPopulate()
{
VlRebar = new List <Rebar>();
LinearPath linPathRFT = (LinearPath)ShearWall.ProfilePath.Offset(-DefaultValues.ShearWallCover);
Line[] RFTlines = linPathRFT.ConvertToLines();
for (int i = 0; i < RFTlines.Length; i++)
{
Vector3D uv = MathHelper.UnitVector3DFromPt1ToPt2(RFTlines[i].StartPoint, RFTlines[i].EndPoint);
int rebarCount = Convert.ToInt32(RFTlines[i].Length() / DefaultValues.LongBarSpacing);
for (int j = 0; j < rebarCount; j++)
{
Point3D location = RFTlines[i].StartPoint + uv * j * DefaultValues.LongBarSpacing;
Rebar rebar = new Rebar(location);
VlRebar.Add(rebar);
}
}
}
internal static List <Point3D> PointsIntersectOfLineWithPolygon(LinearPath linPath, Line line2)
{
List <Point3D> lstIntersectionPts = new List <Point3D>();
Line[] arrLine = linPath.ConvertToLines();
for (int i = 0; i < arrLine.Length; i++)
{
try
{
Point3D intersectionPt = IntersectionOfTwoLines(arrLine[i], line2);
if (Double.IsNaN(intersectionPt.X))
{
throw new Exception();
}
lstIntersectionPts.Add(intersectionPt);
}
catch (Exception)
{
continue;
}
}
return(lstIntersectionPts);
}
private void PopulateRft()
{
if (RcFooting == null)
{
return;
}
if (!MathHelper.IsRectangle(RcFooting.ProfilePath, 0.02))
{
PopulateRftStripFooting();
}
else
{
LinearPath linPathFooting = (LinearPath)RcFooting.ProfilePath.Offset(-1 * DefaultValues.FootingCover);
//Mesh mesg = linPathFooting.mesh;
for (int i = 0; i < linPathFooting.Vertices.Count(); i++)
{
linPathFooting.Vertices[i].Z += DefaultValues.FootingCover /* + DefaultValues.PCFootingThinkess*/;
}
Line[] pathLines = linPathFooting.ConvertToLines();
int numRebarLong = Convert.ToInt32(pathLines[0].Length() / DefaultValues.LongBarSpacing);
int numRebarTransverse = Convert.ToInt32(pathLines[1].Length() / DefaultValues.LongBarSpacing);
Vector3D uvLong = MathHelper.UnitVector3DFromPt1ToPt2(pathLines[1].StartPoint, pathLines[1].EndPoint);
Vector3D uvTransverse = MathHelper.UnitVector3DFromPt1ToPt2(pathLines[0].EndPoint, pathLines[0].StartPoint);
for (int i = 0; i < numRebarLong; i++)
{
//Transverse Rebars
Point3D stPtTrans = pathLines[0].EndPoint + uvTransverse * DefaultValues.LongBarSpacing * i;
Point3D endPtTrans = stPtTrans + pathLines[1].Length() * uvLong;
Point3D stPtZTrans = stPtTrans + Vector3D.AxisZ * (DefaultValues.RCFootingThinkess - DefaultValues.FootingCover);
Point3D endPtZTrans = endPtTrans + Vector3D.AxisZ * (DefaultValues.RCFootingThinkess - DefaultValues.FootingCover);
LinearPath linePathTransverse = new LinearPath(stPtZTrans, stPtTrans, endPtTrans, endPtZTrans);
//LinearPath linePathTransverse = new LinearPath(stPtZTrans,stPtTrans, endPtTrans);
TransverseRft.Add(new Rebar(linePathTransverse));
}
for (int i = 0; i < numRebarTransverse; i++)
{
//Longitudinal Rebars
Point3D stPtLong = pathLines[1].StartPoint + uvLong * DefaultValues.LongBarSpacing * i;
Point3D endPtLong = stPtLong + pathLines[0].Length() * uvTransverse;
Point3D stPZtLong = stPtLong + Vector3D.AxisZ * (DefaultValues.RCFootingThinkess - DefaultValues.FootingCover);
Point3D endPtZLong = endPtLong + Vector3D.AxisZ * (DefaultValues.RCFootingThinkess - DefaultValues.FootingCover);
LinearPath linePathLong = new LinearPath(stPZtLong, stPtLong, endPtLong, endPtZLong);
//LinearPath linePathLong = new LinearPath(stPtLong, endPtLong);
LongRft.Add(new Rebar(linePathLong));
}
}
}
