private void keep(R.Raud reinf, G.Edge edge, G.Corner corner1, G.Corner corner2)
{
if (edge != null)
{
if (!setEdges.Keys.Contains(edge))
{
setEdges[edge] = reinf;
}
}
if (corner1 != null)
{
if (!setCorners.Keys.Contains(corner1))
{
setCorners[corner1] = reinf;
}
}
if (corner2 != null)
{
if (!setCorners.Keys.Contains(corner2))
{
setCorners[corner2] = reinf;
}
}
knownReinforcement.Add(reinf);
}
private void create_valid_D()
{
List <G.Edge> emptyEdges = allEdges.Where(x => !setEdges.Keys.Contains(x)).ToList();
emptyEdges = emptyEdges.OrderBy(b => b.Line.Length()).Reverse().ToList();
foreach (G.Edge e in emptyEdges)
{
G.Corner sc = e.StartCorner;
G.Corner ec = e.EndCorner;
G.Edge side1Edge = sc.getOtherEdge(e);
G.Edge side2Edge = ec.getOtherEdge(e);
bool c1 = !setCorners.Keys.Contains(sc);
bool c2 = !setCorners.Keys.Contains(ec);
bool c3 = sc.Angle < Math.PI;
bool c4 = ec.Angle < Math.PI;
bool c5 = setEdges.Keys.Contains(side1Edge);
bool c6 = setEdges.Keys.Contains(side2Edge);
if (c1 && c2 && c3 && c4 && c5 && c6)
{
define_simple_D(e, side1Edge, side2Edge);
}
}
}
private void create_all_side_reinforcement()
{
if (_V_.X_REINFORCEMENT_NUMBER > 1)
{
List <LineSegment> allSegments = new List <LineSegment>();
for (int i = allEdges.Count - 1; i >= 0; i--)
{
G.Edge e = allEdges[i];
List <LineSegment> segments = line_segmentator(e);
allSegments.AddRange(segments);
}
foreach (LineSegment cur in allSegments)
{
if (cur.hasOtherEdge())
{
define_side_U(cur);
}
else
{
define_side_D(cur);
}
}
}
}
private void create_extended_B()
{
List <G.Edge> emptyEdges = allEdges.Where(x => !setEdges.Keys.Contains(x)).ToList();
emptyEdges = emptyEdges.OrderBy(b => b.Line.Length()).Reverse().ToList();
foreach (G.Edge e in emptyEdges)
{
G.Corner sc = e.StartCorner;
G.Corner ec = e.EndCorner;
bool c1 = sc.Angle > Math.PI;
bool c2 = ec.Angle > Math.PI;
if (c1 && c2)
{
continue;
}
if (!c1 && !c2)
{
continue;
}
if (c1) //startCorner >> math.pi
{
G.Edge otherEdge = ec.getOtherEdge(e);
define_B(otherEdge, e);
}
else if (c2) //endCorner >> math.pi
{
G.Edge otherEdge = sc.getOtherEdge(e);
define_B(e, otherEdge);
}
}
}
private void create_diagonal_A()
{
List <G.Corner> emptyCorners = allCorners.Where(x => !setCorners.Keys.Contains(x)).ToList();
foreach (G.Corner ec in emptyCorners)
{
G.Edge se = ec.StartEdge;
G.Edge ee = ec.EndEdge;
bool c1 = setEdges.Keys.Contains(se) && setEdges.Keys.Contains(ee);
bool c2 = ec.Angle > Math.PI;
if (c1 && c2)
{
G.Vector v1 = se.Line.getOffsetVector();
G.Vector v2 = ee.Line.getOffsetVector();
G.Vector v3 = (v1 + v2).rotate(Math.PI / 2);
G.Point centerPoint = ec.getCornerPoint(se, _V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1);
G.Line tester = new G.Line(centerPoint, _V_.X_REINFORCEMENT_DIAGONAL_ANCHOR_LENGTH, v3);
if (denier(tester))
{
diagonalRotater(centerPoint, v3, 1, 1, ref tester);
}
A_handler(tester.Start, tester.End, null, ec, _V_.X_REINFORCEMENT_DIAGONAL_DIAMETER);
}
}
}
public bool define_simple_B(G.Edge startEdge, G.Edge endEdge)
{
double cover1 = _V_.X_CONCRETE_COVER_2;
double cover2 = _V_.X_CONCRETE_COVER_2;
double mainDist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
double sideDist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
G.Corner sharedCorner = null;
G.Point IP = getCornerPoint(startEdge, endEdge, cover1, cover2, ref sharedCorner);
G.Vector v1 = endEdge.Line.getOffsetVector();
G.Vector v2 = startEdge.Line.getCoolVector(v1);
G.Vector v3 = startEdge.Line.getOffsetVector();
G.Vector v4 = endEdge.Line.getCoolVector(v3);
G.Point mainEndPoint = IP.move(mainDist, v2);
G.Point sidePoint = IP.move(sideDist, v4);
//A_handler_debug(IP, mainEndPoint);
//A_handler_debug(sidePoint, IP);
bool success = B_vs_C_handler(IP, mainEndPoint, sidePoint, null, sharedCorner);
return(success);
}
private bool trimmer_basepoint(G.Line extendedLine, G.Point fixedPoint, ref G.Edge trimmer)
{
bool trimmed = false;
G.Line trimmedLine = extendedLine.Copy();
foreach (G.Edge eg in allEdges)
{
G.Line offsetLine = eg.edgeOffset(0, 0, 0);
if (G.Line.hasIntersection(trimmedLine, offsetLine))
{
G.Line interLine = eg.edgeOffset(0, 0, 0);
G.Point ip = G.Line.getIntersectionPoint(trimmedLine, interLine);
if (fixedPoint == extendedLine.End)
{
trimmedLine = new G.Line(ip, extendedLine.End);
}
else
{
trimmedLine = new G.Line(extendedLine.Start, ip);
}
trimmed = true;
trimmer = eg;
}
}
return(trimmed);
}
public LineSegment(G.Point start, G.Edge parent, G.Edge other = null)
{
_start = start;
_end = start;
_parent = parent;
_other = other;
}
private void keep_double(R.Raud reinf, G.Edge edge)
{
if (edge != null)
{
if (!setEdges.Keys.Contains(edge))
{
setEdges[edge] = reinf;
}
}
}
private List <LineSegment> line_segmentator(G.Edge e)
{
List <LineSegment> tempList = new List <LineSegment>();
List <LineSegment> segmentList = new List <LineSegment>();
G.Line main = e.Line.Offset(G._Variables.EQUALS_TOLERANCE + 0.001);
G.Vector d1 = e.Line.getDirectionVector();
G.Vector o1 = e.Line.getOffsetVector();
double delta = _V_.M_LINE_SEGMENTATOR_STEP;
double j = 1;
double len = main.Length() - (j * 2);
while (j < len)
{
G.Point checkStartPoint = main.Start.move(j, d1);
G.Point checkEndPoint = checkStartPoint.move(_V_.Y_STIRRUP_MAX_LENGTH, o1);
G.Line checkLine = new G.Line(checkStartPoint, checkEndPoint);
G.Edge trimmerEdge = null;
bool check = trimmer_basepoint(checkLine, checkStartPoint, ref trimmerEdge);
if (tempList.Count == 0)
{
LineSegment temp = new LineSegment(checkStartPoint, e, trimmerEdge);
tempList.Add(temp);
}
else
{
if (tempList[tempList.Count - 1].compareSegments(trimmerEdge))
{
tempList[tempList.Count - 1].updateSegment(checkStartPoint);
}
else
{
LineSegment temp = new LineSegment(checkStartPoint, e, trimmerEdge);
tempList.Add(temp);
}
}
j = j + delta;
}
foreach (LineSegment temp in tempList)
{
if (temp.checkValid())
{
segmentList.Add(temp);
}
}
return(segmentList);
}
public G.Point getCornerPoint(G.Edge e, double offset_main, double offset_side, double alfa = 100000)
{
G.Line startLine = e.Line.Offset(offset_main);
G.Line otherLine = getOtherEdge(e).Line.Offset(offset_side);
G.Line extendedStart = startLine.extendDouble(alfa);
G.Line extendedOther = otherLine.extendDouble(alfa);
G.Point ip = G.Line.getIntersectionPoint(extendedStart, extendedOther);
return(ip);
}
private void create_oversized_D()
{
List <G.Edge> emptyEdges = allEdges.Where(x => !setEdges.Keys.Contains(x)).ToList();
emptyEdges = emptyEdges.OrderBy(b => b.Line.Length()).Reverse().ToList();
foreach (G.Edge e in emptyEdges)
{
G.Corner sc = e.StartCorner;
G.Corner ec = e.EndCorner;
G.Edge side1Edge = sc.getOtherEdge(e);
G.Edge side2Edge = ec.getOtherEdge(e);
bool c1 = !setCorners.Keys.Contains(sc);
bool c2 = !setCorners.Keys.Contains(ec);
bool c3 = sc.Angle < Math.PI;
bool c4 = ec.Angle < Math.PI;
bool c5 = setEdges.Keys.Contains(side1Edge);
bool c6 = setEdges.Keys.Contains(side2Edge);
if (c1 && c2 && c3 && c4)
{
if (!c5 && !c6)
{
if (side1Edge.Line.Length() < _V_.Y_REINFORCEMENT_MAIN_MIN_LENGTH)
{
if (side2Edge.Line.Length() < _V_.Y_REINFORCEMENT_MAIN_MIN_LENGTH)
{
define_simple_D(e, side1Edge, side2Edge);
}
}
}
else if (!c5)
{
if (side1Edge.Line.Length() < _V_.Y_REINFORCEMENT_MAIN_MIN_LENGTH)
{
define_simple_D(e, side1Edge, side2Edge);
}
}
else if (!c6)
{
if (side2Edge.Line.Length() < _V_.Y_REINFORCEMENT_MAIN_MIN_LENGTH)
{
define_simple_D(e, side1Edge, side2Edge);
}
}
}
}
}
//A HANDLE
public bool A_handler(G.Point mainPoint, G.Point mainEnd, G.Edge e, G.Corner c, int d)
{
G.Line main = new G.Line(mainPoint, mainEnd);
//Debugerrint(main.ToString());
//reinf_geometry_debug.Add(main);
R.A_Raud reinf = new R.A_Raud(main, _V_.X_REINFORCEMENT_NUMBER, d, _V_.X_REINFORCEMENT_MARK);
if (denier(reinf.makeLine()))
{
return(false);
}
keep(reinf, e, c, null);
return(true);
}
public G.Edge getOtherEdge(G.Edge one)
{
if (one == edge1)
{
return(edge2);
}
else if (one == edge2)
{
return(edge1);
}
else
{
throw new G.EdgeNotInDefinedCornerException();
}
}
private G.Point getCornerPoint(G.Edge one, G.Edge two, double cover1, double cover2, ref G.Corner sharedCorner)
{
bool realCorner = G.Edge.getSharedCorner(one, two, ref sharedCorner);
if (realCorner)
{
G.Point IP = sharedCorner.getCornerPoint(one, cover1, cover2);
return(IP);
}
else
{
PseudoCorner pc = new PseudoCorner(one, two);
G.Point IP = pc.getCornerPoint(one, cover1, cover2);
return(IP);
}
}
private void create_valid_B()
{
List <G.Corner> emptyCorners = allCorners.Where(x => !setCorners.Keys.Contains(x)).ToList();
foreach (G.Corner ec in emptyCorners)
{
G.Edge se = ec.StartEdge;
G.Edge ee = ec.EndEdge;
bool c1 = setEdges.Keys.Contains(se) && setEdges.Keys.Contains(ee);
bool c2 = ec.Angle < Math.PI;
if (c1 && c2)
{
define_simple_B(se, ee);
}
}
}
private bool denier(G.Line final, G.Edge e)
{
foreach (G.Edge eg in allEdges)
{
if (eg == e)
{
continue;
}
double o = _V_.X_CONCRETE_COVER_1 - _V_.X_DENIER_MINIMUM_DELTA;
G.Line offsetLine = eg.edgeOffset(o, o, o);
if (G.Line.hasIntersection(final, offsetLine))
{
return(true);
}
}
return(false);
}
private bool narrow_denier(G.Edge e)
{
G.Line main = e.Line.Copy();
G.Vector v1 = main.getOffsetVector();
G.Point cp = main.getCenterPoint();
G.Point ep1 = main.Start.move(_V_.X_CONCRETE_COVER_1 * 2, v1);
G.Point ep2 = cp.move(_V_.X_CONCRETE_COVER_1 * 2, v1);
G.Point ep3 = main.End.move(_V_.X_CONCRETE_COVER_1 * 2, v1);
G.Line testLine1 = new G.Line(main.Start, ep1);
G.Line testLine2 = new G.Line(cp, ep2);
G.Line testLine3 = new G.Line(main.End, ep3);
if (denier(testLine1, e) && denier(testLine2, e) && denier(testLine3, e))
{
return(true);
}
return(false);
}
public bool compareSegments(G.Edge other)
{
if (_other == null && other == null)
{
return(true);
}
if (_other == null)
{
return(false);
}
if (other == null)
{
return(false);
}
if (_other == other)
{
return(true);
}
return(false);
}
//D HANDLE
private bool D_vs_E_handler(G.Point mainPoint, G.Point mainEnd, G.Point side1Start, G.Point side2End, G.Edge e, G.Corner c1, G.Corner c2, int parand, G.Edge other = null, G.Edge other2 = null)
{
G.Line main = new G.Line(mainPoint, mainEnd);
G.Line side1 = new G.Line(side1Start, mainPoint);
G.Line side2 = new G.Line(mainEnd, side2End);
if (main.Length() < _V_.Y_REINFORCEMENT_MAIN_RADIUS * 1.99)
{
return(false);
}
//reinf_geometry_debug.Add(main);
//reinf_geometry_debug.Add(side1);
//reinf_geometry_debug.Add(side2);
G.Vector v1 = main.getDirectionVector();
G.Vector v2 = side1.getDirectionVector();
G.Vector v3 = side2.getDirectionVector();
double ang1 = G.Converter.AngleDeltaCW(v1, v2);
double ang2 = G.Converter.AngleDeltaCW(v1, v3);
bool d1 = Math.Abs(ang1 - Math.PI / 2) < _V_.M_B_BAR_TOLERANCE;
bool d2 = Math.Abs(ang2 - 3 * Math.PI / 2) < _V_.M_B_BAR_TOLERANCE;
if (d1 && d2)
{
R.D_Raud reinf = new R.D_Raud(main, side1, side2, _V_.X_REINFORCEMENT_NUMBER, _V_.X_REINFORCEMENT_MAIN_DIAMETER, _V_.X_REINFORCEMENT_MARK, parand);
if (denier(reinf.makeMainLine()))
{
return(false);
}
if (denier(reinf.makeSide1Line()))
{
return(false);
}
if (denier(reinf.makeSide2Line()))
{
return(false);
}
keep(reinf, e, c1, c2);
keep_double(reinf, other);
keep_double(reinf, other2);
}
else
{
R.E_Raud reinf = new R.E_Raud(main, side1, side2, _V_.X_REINFORCEMENT_NUMBER, _V_.X_REINFORCEMENT_MAIN_DIAMETER, _V_.X_REINFORCEMENT_MARK, parand);
if (denier(reinf.makeMainLine()))
{
return(false);
}
if (denier(reinf.makeSide1Line()))
{
return(false);
}
if (denier(reinf.makeSide2Line()))
{
return(false);
}
keep(reinf, e, c1, c2);
keep_double(reinf, other);
keep_double(reinf, other2);
}
return(true);
}
//B HANDLE
private bool B_vs_C_handler(G.Point mainPoint, G.Point mainEnd, G.Point sideStart, G.Edge e, G.Corner oc)
{
G.Line main = new G.Line(mainPoint, mainEnd);
G.Line side = new G.Line(sideStart, mainPoint);
G.Line temp1 = trimLine_basepoint(main, mainPoint);
if (temp1.Length() > main.Length() * _V_.M_TRIM_TOLERANCE)
{
main = temp1.Copy();
}
if (denier(main))
{
return(false);
}
G.Line temp2 = trimLine_basepoint(side, mainPoint);
if (temp2.Length() > side.Length() * _V_.M_TRIM_TOLERANCE)
{
side = temp2.Copy();
}
if (denier(side))
{
return(false);
}
if (main.Length() < _V_.Y_REINFORCEMENT_MAIN_RADIUS)
{
return(false);
}
if (side.Length() < _V_.Y_REINFORCEMENT_MAIN_RADIUS)
{
return(false);
}
G.Vector v1 = main.getDirectionVector();
G.Vector v2 = side.getDirectionVector();
double ang = G.Converter.AngleDeltaCW(v1, v2);
if (Math.Abs(ang - Math.PI / 2) < _V_.M_B_BAR_TOLERANCE)
{
R.B_Raud reinf = new R.B_Raud(main, side, _V_.X_REINFORCEMENT_NUMBER, _V_.X_REINFORCEMENT_MAIN_DIAMETER, _V_.X_REINFORCEMENT_MARK);
keep(reinf, e, oc, null);
}
else
{
R.C_Raud reinf = new R.C_Raud(main, side, _V_.X_REINFORCEMENT_NUMBER, _V_.X_REINFORCEMENT_MAIN_DIAMETER, _V_.X_REINFORCEMENT_MARK);
keep(reinf, e, oc, null);
}
return(true);
}
public bool define_D(G.Edge mainEdge, G.Edge side1Edge, G.Edge side2Edge)
{
bool mainSet = setEdges.Keys.Contains(mainEdge);
bool side1Set = setEdges.Keys.Contains(side1Edge);
bool side2Set = setEdges.Keys.Contains(side2Edge);
double cover1 = _V_.X_CONCRETE_COVER_2;
double coverMain = _V_.X_CONCRETE_COVER_1;
double cover2 = _V_.X_CONCRETE_COVER_2;
int parand = 2 * _V_.Y_CONCRETE_COVER_DELTA - 10; // parand magic
double side1Dist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
double mainDist = mainEdge.Line.Length();
double side2Dist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
if (mainSet == true)
{
coverMain = coverMain + _V_.Y_CONCRETE_COVER_DELTA;
}
G.Corner startCorner = null;
G.Point IP1 = getCornerPoint(side1Edge, mainEdge, cover1, coverMain, ref startCorner);
G.Corner endCorner = null;
G.Point IP2 = getCornerPoint(mainEdge, side2Edge, coverMain, cover2, ref endCorner);
G.Vector v1 = mainEdge.Line.getOffsetVector();
G.Vector v2 = side1Edge.Line.getCoolVector(v1);
G.Vector v3 = side2Edge.Line.getCoolVector(v2);
G.Point side1Start = IP1.move(side1Dist, v2);
G.Point side2End = IP2.move(side2Dist, v3);
if (startCorner != null)
{
if (setCorners.Keys.Contains(startCorner))
{
if (setEdges.Keys.Contains(mainEdge))
{
if (!ReferenceEquals(setCorners[startCorner], setEdges[mainEdge]))
{
coverMain = coverMain + _V_.Y_CONCRETE_COVER_DELTA;
}
}
if (setEdges.Keys.Contains(side1Edge))
{
if (!ReferenceEquals(setCorners[startCorner], setEdges[side1Edge]))
{
cover1 = cover1 + _V_.Y_CONCRETE_COVER_DELTA;
}
}
IP1 = getCornerPoint(side1Edge, mainEdge, cover1, coverMain, ref startCorner);
IP2 = getCornerPoint(mainEdge, side2Edge, coverMain, cover2, ref endCorner);
side1Start = IP1.move(side1Dist, v2);
side2End = IP2.move(side2Dist, v3);
startCorner = null;
}
}
if (endCorner != null)
{
if (setCorners.Keys.Contains(endCorner))
{
if (setEdges.Keys.Contains(mainEdge))
{
if (!ReferenceEquals(setCorners[endCorner], setEdges[mainEdge]))
{
coverMain = coverMain + _V_.Y_CONCRETE_COVER_DELTA;
}
}
if (setEdges.Keys.Contains(side2Edge))
{
if (!ReferenceEquals(setCorners[endCorner], setEdges[side2Edge]))
{
cover2 = cover2 + _V_.Y_CONCRETE_COVER_DELTA;
}
}
IP1 = getCornerPoint(side1Edge, mainEdge, cover1, coverMain, ref startCorner);
IP2 = getCornerPoint(mainEdge, side2Edge, coverMain, cover2, ref endCorner);
side1Start = IP1.move(side1Dist, v2);
side2End = IP2.move(side2Dist, v3);
endCorner = null;
}
}
//A_handler_debug(side1Start, IP1);
//A_handler_debug(IP1, IP2);
//A_handler_debug(IP2, side2End);
bool success = false;
if (mainSet == true)
{
success = D_vs_E_handler(IP1, IP2, side1Start, side2End, null, startCorner, endCorner, parand); // parand magic
}
else
{
success = D_vs_E_handler(IP1, IP2, side1Start, side2End, mainEdge, startCorner, endCorner, parand); // parand magic
}
return(success);
}
public bool define_B(G.Edge startEdge, G.Edge endEdge)
{
bool startSet = setEdges.Keys.Contains(startEdge);
bool endSet = setEdges.Keys.Contains(endEdge);
double cover1 = _V_.X_CONCRETE_COVER_1;
double cover2 = _V_.X_CONCRETE_COVER_1;
double mainDist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
double sideDist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
bool realCorner = G.Edge.haveSharedCorner(startEdge, endEdge);
if (realCorner)
{
G.Corner cor = G.Edge.getSharedCorner(startEdge, endEdge);
if (cor.Angle > Math.PI)
{
return(false);
}
}
if (startSet == true && endSet == true)
{
cover1 += _V_.Y_CONCRETE_COVER_DELTA;
cover2 += _V_.Y_CONCRETE_COVER_DELTA;
//mainDist == default
//sideDist == default
}
else if (startSet == false && endSet == false)
{
double startLineLength = startEdge.Line.Length();
double endLineLength = endEdge.Line.Length();
if (startLineLength > endLineLength)
{
startSet = true;
cover1 += _V_.Y_CONCRETE_COVER_DELTA;
//cover2 == default
//mainDist == default
sideDist = endEdge.edgeOffset(cover1, cover1, cover2).Length();
if (endEdge.StartCorner.Angle > Math.PI)
{
sideDist += _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
}
}
else
{
endSet = true;
//cover1 == default
cover2 += _V_.Y_CONCRETE_COVER_DELTA;
mainDist = startEdge.edgeOffset(cover1, cover1, cover2).Length();
//sideDist == default
if (startEdge.EndCorner.Angle > Math.PI)
{
mainDist += _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
}
}
if (startEdge.EndCorner.Angle > Math.PI)
{
startLineLength += _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
}
if (endEdge.StartCorner.Angle > Math.PI)
{
endLineLength += _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
}
}
else if (startSet == false && endSet == true)
{
//cover1 == default
cover2 += _V_.Y_CONCRETE_COVER_DELTA;
mainDist = startEdge.edgeOffset(cover1, cover1, cover2).Length();
//sideDist == default
if (startEdge.EndCorner.Angle > Math.PI)
{
mainDist += _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
}
}
else if (startSet == true && endSet == false)
{
cover1 += _V_.Y_CONCRETE_COVER_DELTA;
//cover2 == defualt
//mainDist == default
sideDist = endEdge.edgeOffset(cover1, cover1, cover2).Length();
if (endEdge.StartCorner.Angle > Math.PI)
{
sideDist += _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
}
}
mainDist = Math.Max(mainDist, _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH);
sideDist = Math.Max(sideDist, _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH);
G.Corner sharedCorner = null;
G.Point IP = getCornerPoint(startEdge, endEdge, cover1, cover2, ref sharedCorner);
if (!realCorner)
{
if (startSet == false && endSet == true)
{
G.Line otherLine = startEdge.edgeOffset(cover1, cover1, cover2);
G.Point other = IP.getClosePoint(otherLine.Start, otherLine.End);
double dist = other.distanceTo(IP);
mainDist += dist;
}
else if (startSet == true && endSet == false)
{
G.Line otherLine = endEdge.edgeOffset(cover1, cover1, cover2);
G.Point other = IP.getClosePoint(otherLine.Start, otherLine.End);
double dist = other.distanceTo(IP);
sideDist += dist;
}
}
G.Vector v1 = endEdge.Line.getOffsetVector();
G.Vector v2 = startEdge.Line.getCoolVector(v1);
G.Vector v3 = startEdge.Line.getOffsetVector();
G.Vector v4 = endEdge.Line.getCoolVector(v3);
G.Point mainEndPoint = IP.move(mainDist, v2);
G.Point sidePoint = IP.move(sideDist, v4);
//A_handler_debug(IP, mainEndPoint);
//A_handler_debug(sidePoint, IP);
bool success = false;
if (startSet == false)
{
success = B_vs_C_handler(IP, mainEndPoint, sidePoint, startEdge, sharedCorner);
}
else if (endSet == false)
{
success = B_vs_C_handler(IP, mainEndPoint, sidePoint, endEdge, sharedCorner);
}
else
{
success = B_vs_C_handler(IP, mainEndPoint, sidePoint, null, sharedCorner);
}
return(success);
}
public bool define_simple_D(G.Edge mainEdge, G.Edge side1Edge, G.Edge side2Edge)
{
bool mainSet = setEdges.Keys.Contains(mainEdge);
bool side1Set = setEdges.Keys.Contains(side1Edge);
bool side2Set = setEdges.Keys.Contains(side2Edge);
double cover1 = _V_.X_CONCRETE_COVER_1;
double coverMain = _V_.X_CONCRETE_COVER_1;
double cover2 = _V_.X_CONCRETE_COVER_1;
int parand = 0;
double side1Dist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
double mainDist = mainEdge.Line.Length();
double side2Dist = _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH;
G.Corner startCorner = null;
G.Point IP1 = getCornerPoint(side1Edge, mainEdge, cover1, coverMain, ref startCorner);
if (startCorner == null)
{
return(false);
}
G.Corner endCorner = null;
G.Point IP2 = getCornerPoint(mainEdge, side2Edge, coverMain, cover2, ref endCorner);
if (endCorner == null)
{
return(false);
}
if (mainSet == true)
{
coverMain = coverMain + _V_.Y_CONCRETE_COVER_DELTA;
}
if (side1Set == true)
{
cover1 = cover1 + _V_.Y_CONCRETE_COVER_DELTA;
}
else
{
if (side1Edge.getOtherCorner(startCorner).Angle > Math.PI)
{
side1Dist = side1Dist + side1Edge.Line.Length();
}
else
{
side1Dist = side1Edge.edgeOffset(_V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1).Length();
}
}
if (side2Set == true)
{
cover2 = cover2 + _V_.Y_CONCRETE_COVER_DELTA;
}
else
{
if (side2Edge.getOtherCorner(endCorner).Angle > Math.PI)
{
side2Dist = side2Dist + side2Edge.Line.Length();
}
else
{
side2Dist = side2Edge.edgeOffset(_V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1).Length();
}
}
if (side1Dist != side2Dist)
{
double max = Math.Max(side1Dist, side2Dist);
side1Dist = max;
side2Dist = max;
}
IP1 = getCornerPoint(side1Edge, mainEdge, cover1, coverMain, ref startCorner);
IP2 = getCornerPoint(mainEdge, side2Edge, coverMain, cover2, ref endCorner);
G.Vector v1 = mainEdge.Line.getOffsetVector();
G.Vector v2 = side1Edge.Line.getCoolVector(v1);
G.Vector v3 = side2Edge.Line.getCoolVector(v2);
G.Point side1Start = IP1.move(side1Dist, v2);
G.Point side2End = IP2.move(side2Dist, v3);
//A_handler_debug(side1Start, IP1);
//A_handler_debug(IP1, IP2);
//A_handler_debug(IP2, side2End);
bool success = false;
if (side1Set == false && side2Set == false)
{
success = D_vs_E_handler(IP1, IP2, side1Start, side2End, mainEdge, startCorner, endCorner, parand, side1Edge, side2Edge); // parand magic
}
else if (side1Set == false)
{
success = D_vs_E_handler(IP1, IP2, side1Start, side2End, mainEdge, startCorner, endCorner, parand, side1Edge); // parand magic
}
else if (side2Set == false)
{
success = D_vs_E_handler(IP1, IP2, side1Start, side2End, mainEdge, startCorner, endCorner, parand, side2Edge); // parand magic
}
else
{
success = D_vs_E_handler(IP1, IP2, side1Start, side2End, mainEdge, startCorner, endCorner, parand); // parand magic
}
return(success);
}
private void create_trimmed_long_A()
{
List <G.Edge> emptyEdges = allEdges.Where(x => !setEdges.Keys.Contains(x)).ToList();
emptyEdges = emptyEdges.OrderBy(b => b.Line.Length()).Reverse().ToList();
foreach (G.Edge e in emptyEdges)
{
if (setEdges.Keys.Contains(e))
{
continue;
}
if (narrow_denier(e))
{
continue;
}
G.Edge temp = null;
G.Line main = e.edgeOffset(_V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1);
main = trimLine_baseline(main, main.Copy(), _V_.X_CONCRETE_COVER_1, e, ref temp);
bool startTrimmed = false;
G.Edge startTrimmerEdge = null;
if (e.StartCorner.Angle > Math.PI)
{
G.Line extended = main.extendStart(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH);
G.Line trimmed = trimLine_basepoint(extended, main.End, _V_.X_CONCRETE_COVER_2, e, ref startTrimmerEdge);
if (trimmed.Length() < main.Length() + _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * _V_.M_TRIM_TOLERANCE)
{
startTrimmed = true;
}
main = trimmed;
}
bool endTrimmed = false;
G.Edge endTrimmerEdge = null;
if (e.EndCorner.Angle > Math.PI)
{
G.Line extended = main.extendEnd(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH);
G.Line trimmed = trimLine_basepoint(extended, main.Start, _V_.X_CONCRETE_COVER_2, e, ref endTrimmerEdge);
if (trimmed.Length() < main.Length() + _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * _V_.M_TRIM_TOLERANCE)
{
endTrimmed = true;
}
main = trimmed;
}
if (main.Length() > _V_.Y_REINFORCEMENT_MAIN_MIN_LENGTH)
{
A_handler(main.Start, main.End, e, null, _V_.X_REINFORCEMENT_MAIN_DIAMETER);
if (startTrimmed)
{
bool got_B = define_simple_B(e, startTrimmerEdge);
if (got_B == false)
{
G.Vector v1 = e.Line.getOffsetVector();
G.Vector v2 = startTrimmerEdge.Line.getCoolVector(v1);
G.Point AP = main.Start.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.5, v2);
G.Line b_line = new G.Line(main.Start, AP);
G.Edge sideTrimmerEdge = null;
G.Line newMain = trimLine_basepoint(b_line, main.Start, _V_.X_CONCRETE_COVER_2, e, ref sideTrimmerEdge);
if (sideTrimmerEdge != null)
{
define_D(startTrimmerEdge, sideTrimmerEdge, e);
}
}
}
if (endTrimmed)
{
bool got_B = define_simple_B(endTrimmerEdge, e);
if (got_B == false)
{
G.Vector v1 = e.Line.getOffsetVector();
G.Vector v2 = endTrimmerEdge.Line.getCoolVector(v1);
G.Point AP = main.End.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.5, v2);
G.Line b_line = new G.Line(main.End, AP);
G.Edge sideTrimmerEdge = null;
G.Line newMain = trimLine_basepoint(b_line, main.End, _V_.X_CONCRETE_COVER_2, e, ref sideTrimmerEdge);
if (sideTrimmerEdge != null)
{
define_D(endTrimmerEdge, e, sideTrimmerEdge);
}
}
}
}
}
}
public PseudoCorner(G.Edge ln1, G.Edge ln2)
{
edge1 = ln1;
edge2 = ln2;
}
private void create_trimmed_short_A()
{
List <G.Edge> emptyEdges = allEdges.Where(x => !setEdges.Keys.Contains(x)).ToList();
emptyEdges = emptyEdges.OrderBy(b => b.Line.Length()).ToList();
foreach (G.Edge e in emptyEdges)
{
if (setEdges.Keys.Contains(e))
{
continue;
}
if (narrow_denier(e))
{
continue;
}
G.Edge temp = null;
G.Line main = e.edgeOffset(_V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1, _V_.X_CONCRETE_COVER_1);
main = trimLine_baseline(main, main.Copy(), _V_.X_CONCRETE_COVER_2, e, ref temp);
bool startTrimmed = false;
G.Edge startTrimmerEdge = null;
if (e.StartCorner.Angle > Math.PI)
{
G.Line extended = main.extendStart(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH);
G.Line trimmed = trimLine_basepoint(extended, main.End, _V_.X_CONCRETE_COVER_2, e, ref startTrimmerEdge);
if (trimmed.Length() < main.Length() + _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * _V_.M_TRIM_TOLERANCE)
{
startTrimmed = true;
}
main = trimmed;
}
bool endTrimmed = false;
G.Edge endTrimmerEdge = null;
if (e.EndCorner.Angle > Math.PI)
{
G.Line extended = main.extendEnd(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH);
G.Line trimmed = trimLine_basepoint(extended, main.Start, _V_.X_CONCRETE_COVER_2, e, ref endTrimmerEdge);
if (trimmed.Length() < main.Length() + _V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * _V_.M_TRIM_TOLERANCE)
{
endTrimmed = true;
}
main = trimmed;
}
if (main.Length() <= _V_.Y_REINFORCEMENT_MAIN_MIN_LENGTH)
{
if (startTrimmed && endTrimmed)
{
bool got_D = define_D(e, startTrimmerEdge, endTrimmerEdge);
if (got_D == false)
{
G.Vector v1 = main.getOffsetVector();
G.Vector v2 = startTrimmerEdge.Line.getCoolVector(v1);
G.Vector v3 = endTrimmerEdge.Line.getCoolVector(v1);
G.Point side1Point = main.Start.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.05, v2);
G.Point side2Point = main.End.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.05, v3);
G.Line side1 = new G.Line(side1Point, main.Start);
G.Line side2 = new G.Line(main.End, side2Point);
if (denier(side1) && denier(side2))
{
G.Point AP = main.Start.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.5, v2);
G.Line b_line = new G.Line(main.Start, AP);
G.Edge side1TrimmerEdge = null;
G.Line side1Main = trimLine_basepoint(b_line, main.Start, _V_.X_CONCRETE_COVER_2, e, ref side1TrimmerEdge);
G.Point AP2 = main.End.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.5, v3);
G.Line b_line2 = new G.Line(main.End, AP2);
G.Edge side2TrimmerEdge = null;
G.Line side2Main = trimLine_basepoint(b_line2, main.End, _V_.X_CONCRETE_COVER_2, e, ref side2TrimmerEdge);
A_handler(main.Start, main.End, e, null, _V_.X_REINFORCEMENT_MAIN_DIAMETER);
define_D(startTrimmerEdge, side1TrimmerEdge, e);
define_D(endTrimmerEdge, e, side2TrimmerEdge);
}
else if (denier(side1))
{
G.Point AP = main.Start.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.5, v2);
G.Line b_line = new G.Line(main.Start, AP);
G.Edge sideTrimmerEdge = null;
G.Line newMain = trimLine_basepoint(b_line, main.Start, _V_.X_CONCRETE_COVER_2, e, ref sideTrimmerEdge);
B_vs_C_handler(main.End, side2Point, main.Start, e, null);
define_D(startTrimmerEdge, sideTrimmerEdge, e);
}
else if (denier(side2))
{
G.Point AP = main.End.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 1.5, v2);
G.Line b_line = new G.Line(main.End, AP);
G.Edge sideTrimmerEdge = null;
G.Line newMain = trimLine_basepoint(b_line, main.End, _V_.X_CONCRETE_COVER_2, e, ref sideTrimmerEdge);
define_D(endTrimmerEdge, e, sideTrimmerEdge);
B_vs_C_handler(main.Start, main.End, side1Point, e, null);
}
}
}
else if (startTrimmed)
{
bool got_B = define_B(e, startTrimmerEdge);
if (got_B == false)
{
G.Vector v1 = e.Line.getOffsetVector();
G.Vector v2 = startTrimmerEdge.Line.getCoolVector(v1);
G.Point AP = main.Start.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 2, v2);
G.Line b_line = new G.Line(main.Start, AP);
G.Edge sideTrimmerEdge = null;
G.Line newMain = trimLine_basepoint(b_line, main.Start, _V_.X_CONCRETE_COVER_2, e, ref sideTrimmerEdge);
if (sideTrimmerEdge != null)
{
bool got_D = define_D(startTrimmerEdge, sideTrimmerEdge, e);
if (got_D)
{
A_handler(main.Start, main.End, e, null, _V_.X_REINFORCEMENT_MAIN_DIAMETER);
}
}
else
{
G.Corner ec = e.EndCorner;
if (ec.Angle < Math.PI)
{
G.Edge otherEdge = ec.getOtherEdge(e);
define_D(e, startTrimmerEdge, otherEdge);
}
}
}
}
else if (endTrimmed)
{
bool got_B = define_B(endTrimmerEdge, e);
if (got_B == false)
{
G.Vector v1 = e.Line.getOffsetVector();
G.Vector v2 = endTrimmerEdge.Line.getCoolVector(v1);
G.Point AP = main.End.move(_V_.X_REINFORCEMENT_MAIN_ANCHOR_LENGTH * 2, v2);
G.Line b_line = new G.Line(main.End, AP);
G.Edge sideTrimmerEdge = null;
G.Line newMain = trimLine_basepoint(b_line, main.End, _V_.X_CONCRETE_COVER_2, e, ref sideTrimmerEdge);
if (sideTrimmerEdge != null)
{
bool got_D = define_D(endTrimmerEdge, e, sideTrimmerEdge);
if (got_D)
{
A_handler(main.Start, main.End, e, null, _V_.X_REINFORCEMENT_MAIN_DIAMETER);
}
}
else
{
G.Corner sc = e.StartCorner;
if (sc.Angle < Math.PI)
{
G.Edge otherEdge = sc.getOtherEdge(e);
define_D(e, otherEdge, endTrimmerEdge);
}
}
}
}
}
}
}
private G.Line trimLine_basepoint(G.Line extendedLine, G.Point fixedPoint, double offset, G.Edge e, ref G.Edge trimmer)
{
G.Line trimmedLine = extendedLine.Copy();
foreach (G.Edge eg in allEdges)
{
if (eg.Line.getOffsetVector() == e.Line.getOffsetVector())
{
continue;
}
if (e.StartCorner.getOtherEdge(e) == eg && e.StartCorner.Angle > Math.PI)
{
continue;
}
if (e.EndCorner.getOtherEdge(e) == eg && e.EndCorner.Angle > Math.PI)
{
continue;
}
if (trimmedLine.getDirectionVector() == eg.Line.getDirectionVector())
{
continue;
}
if (trimmedLine.getDirectionVector() == (-1) * eg.Line.getDirectionVector())
{
continue;
}
double o = offset - _V_.X_TRIM_MINIMUM_DELTA;
double so = _V_.X_CONCRETE_COVER_1 - _V_.X_TRIM_SIDE_MINIMUM_DELTA;
if (e.StartCorner.getOtherEdge(e) == eg)
{
o = so;
}
if (e.EndCorner.getOtherEdge(e) == eg)
{
o = so;
}
G.Line offsetLine = eg.edgeTrimmer(o, so, so);
if (G.Line.hasIntersection(trimmedLine, offsetLine))
{
G.Point ip = G.Line.getIntersectionPoint(trimmedLine, offsetLine);
if (ip == fixedPoint)
{
continue;
}
if (fixedPoint == extendedLine.End)
{
trimmedLine = new G.Line(ip, extendedLine.End);
}
else
{
trimmedLine = new G.Line(extendedLine.Start, ip);
}
trimmer = eg;
}
}
return(trimmedLine);
}
