private G.Line trimLine_basepoint(G.Line extendedLine, G.Point fixedPoint) // this function is used by B vs C handler and does not know what edge it belongs to. Hence the 0.01 tambov
{
G.Line trimmedLine = extendedLine.Copy();
foreach (G.Edge eg in allEdges)
{
double o = _V_.X_CONCRETE_COVER_1 - _V_.X_TRIM_MINIMUM_DELTA;
G.Line offsetLine = eg.edgeOffset(o, o, o);
if (G.Line.hasIntersection(trimmedLine, offsetLine))
{
G.Point ip = G.Line.getIntersectionPoint(trimmedLine, offsetLine);
if (fixedPoint == extendedLine.End)
{
trimmedLine = new G.Line(ip, extendedLine.End);
}
else
{
trimmedLine = new G.Line(extendedLine.Start, ip);
}
}
}
return(trimmedLine);
}
public static E_Raud mergeTwoRebar_long(C_Raud one, C_Raud two)
{
G.Point a = one._SidePoint;
G.Point b = one.StartPoint;
G.Point c = two.StartPoint;
G.Point d = two._EndPoint;
G.Line temp1 = new G.Line(a, b);
G.Line main = new G.Line(b, c);
G.Line temp2 = new G.Line(c, d);
double s1 = temp1.Length();
double s2 = temp2.Length();
double max = Math.Max(s1, s2);
G.Vector v1 = (-1) * temp1.getDirectionVector();
G.Vector v2 = temp2.getDirectionVector();
G.Point new_a = b.move(max, v1);
G.Point new_d = c.move(max, v2);
G.Line side1 = new G.Line(new_a, b);
G.Line side2 = new G.Line(c, new_d);
E_Raud raud = new E_Raud(main, side1, side2, one.Number, one.Diameter, one.Materjal);
return(raud);
}
public G.Line makeLine()
{
G.Point a = new G.Point(_StartPoint.X, _StartPoint.Y);
G.Point b = new G.Point(_EndPoint.X, _EndPoint.Y);
G.Line rebarLine = new G.Line(a, b);
return(rebarLine);
}
public void add_one(Raud one)
{
_array.Add(one);
int index = (int)_array.Count / 2;
_IP = _array[index].IP;
}
public C_Raud(G.Line main, G.Line side, int nr, int d, string teras) : base(main, nr, d, teras)
{
G.Vector mainDir = main.getDirectionVector();
G.Polar mainPol = G.Converter.xy_to_la(mainDir);
G.Vector sideDir = side.getDirectionVector();
G.Polar sidePol = G.Converter.xy_to_la(sideDir);
_A = shorter(side.Length());
_B = shorter(main.Length());
_U = G.Converter.AngleDelta(mainPol.angle, sidePol.angle);
_IP = main.Start;
_Length = _A + _B;
//OVERRIDE
G.Vector dir = main.getDirectionVector();
double shorterLength = shorter(main.Length());
_StartPoint = main.Start;
_EndPoint = _StartPoint.move(shorterLength, dir);
//OVERRIDE
G.Vector v1 = -1 * side.getDirectionVector();
_SidePoint = _StartPoint.move(_A, v1);
}
public void E_Raud_Init_test1()
{
G.Point start = new G.Point(0.0, 0.0);
G.Point mainp = start.move(5, new G.Vector(1, 0));
G.Point side1p = start.move(10, new G.Vector(-1, 1));
G.Point side2p = mainp.move(15, new G.Vector(1, 1));
G.Line main = new G.Line(start, mainp);
G.Line side1 = new G.Line(side1p, start);
G.Line side2 = new G.Line(mainp, side2p);
R.E_Raud reinf = new R.E_Raud(main, side1, side2, 2, 8, "B500B");
Assert.AreEqual(reinf.StartPoint.X, 0.0, 0.001);
Assert.AreEqual(reinf.StartPoint.Y, 0.0, 0.001);
Assert.AreEqual(reinf.Rotation, 0.0, 0.001);
Assert.AreEqual(reinf.A, 10, 0.001);
Assert.AreEqual(reinf.B, 5, 0.001);
Assert.AreEqual(reinf.C, 15, 0.001);
Assert.AreEqual(reinf.U, Math.PI / 4, 0.001);
Assert.AreEqual(reinf.V, Math.PI / 4, 0.001);
Assert.AreEqual(reinf.X, 7.071, 0.001);
Assert.AreEqual(reinf.Y, 10.606, 0.001);
Assert.AreEqual(reinf.Length, 30, 0.001);
Assert.AreEqual(reinf.Diameter, 8, 0.001);
Assert.AreEqual(reinf.Materjal, "B500B");
}
public void D_Raud_Init_test3()
{
G.Point start = new G.Point(6.0, 2.0);
G.Point mainp = start.move(5, new G.Vector(1, -1));
G.Point side1p = start.move(10, new G.Vector(1, 1));
G.Point side2p = mainp.move(15, new G.Vector(1, 1));
G.Line main = new G.Line(start, mainp);
G.Line side1 = new G.Line(side1p, start);
G.Line side2 = new G.Line(mainp, side2p);
R.D_Raud reinf = new R.D_Raud(main, side1, side2, 2, 8, "B500B");
Assert.AreEqual(reinf.StartPoint.X, 6.0, 0.001);
Assert.AreEqual(reinf.StartPoint.Y, 2.0, 0.001);
Assert.AreEqual(reinf.Rotation, Math.PI + 3 * Math.PI / 4, 0.001);
Assert.AreEqual(reinf.A, 10, 0.001);
Assert.AreEqual(reinf.B, 5, 0.001);
Assert.AreEqual(reinf.C, 15, 0.001);
Assert.AreEqual(reinf.Length, 30, 0.001);
Assert.AreEqual(reinf.Diameter, 8, 0.001);
Assert.AreEqual(reinf.Materjal, "B500B");
}
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);
}
private List <T.BendingShape> getBendingData(List <_Db.BlockReference> blocks)
{
List <T.BendingShape> parse = new List <T.BendingShape>();
foreach (_Db.BlockReference block in blocks)
{
G.Point insp = new G.Point(block.Position.X, block.Position.Y);
T.BendingShape current = new T.BendingShape(insp, block.Name);
foreach (_Db.ObjectId arId in block.AttributeCollection)
{
_Db.DBObject obj = _c.trans.GetObject(arId, _Db.OpenMode.ForWrite);
_Db.AttributeReference ar = obj as _Db.AttributeReference;
setBendingParameters(ar, current);
}
current.validator();
if (current.Valid)
{
parse.Add(current);
}
else
{
write(current.Reason);
}
}
return(parse);
}
public void D_Raud_Init_test_parand2()
{
G.Point start = new G.Point(0.0, 0.0);
G.Point mainp = start.move(25, new G.Vector(1, 0));
G.Point side1p = start.move(10, new G.Vector(0, 1));
G.Point side2p = mainp.move(15, new G.Vector(0, 1));
G.Line main = new G.Line(start, mainp);
G.Line side1 = new G.Line(side1p, start);
G.Line side2 = new G.Line(mainp, side2p);
R.D_Raud reinf = new R.D_Raud(main, side1, side2, 2, 8, "B500B", -20);
Assert.AreEqual(reinf.StartPoint.X, 0.0, 0.001);
Assert.AreEqual(reinf.StartPoint.Y, 0.0, 0.001);
Assert.AreEqual(reinf.Rotation, 0.0, 0.001);
Assert.AreEqual(reinf.A, 10, 0.001);
Assert.AreEqual(reinf.B, 25, 0.001);
Assert.AreEqual(reinf.B2, 5, 0.001);
Assert.AreEqual(reinf.C, 15, 0.001);
Assert.AreEqual(reinf.Length, 30, 0.001);
Assert.AreEqual(reinf.Diameter, 8, 0.001);
Assert.AreEqual(reinf.Materjal, "B500B");
}
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);
}
}
}
/// <summary>
/// Перемещение кривой при нажатии на неё мышкой
/// </summary>
private void panel1_MouseMove(object sender, MouseEventArgs e)
{
if (moving)
{
IPoint new_p = new Geometry.Point(e.X + p_offset.X, e.Y + p_offset.Y);
movingCurve.Curve = new MoveTo(movingCurve.Curve, new_p);
panel1.Refresh();
DrawMove(movingList, movingCurve);
}
else
{
foreach (VisualCurve c in curves)
{
if (hoverCurve = c.Path.IsOutlineVisible(e.Location, new Pen(Color.Black, 15)))
{
VisualCurve cu = VisualCurve.CreateVisualCurve(c.Clone());
c.Draw(new DrawGraphics(g, 3));
hover = true;
break;
}
}
if (!hoverCurve && hover)
{
panel1.Refresh();
Draw(curves);
hover = false;
}
}
}
private void insertReinforcmentMark(string mark, G.Point IP)
{
string layerName = "K023TL";
string styleName = "dmt_M" + (int)Math.Round(L._V_.Z_DRAWING_SCALE);
textStyleHandler();
blockHandler();
leaderStyleHandler(styleName, (int)Math.Round(L._V_.Z_DRAWING_SCALE));
_Db.DBDictionary mleaderStyleTable = _c.trans.GetObject(_c.db.MLeaderStyleDictionaryId, _Db.OpenMode.ForWrite) as _Db.DBDictionary;
_Ge.Point3d insertPointLeader = new _Ge.Point3d(IP.X, IP.Y, 0);
_Ge.Point3d insertPointText = new _Ge.Point3d(IP.X + 7.5 * L._V_.Z_DRAWING_SCALE, IP.Y + 7.5 * L._V_.Z_DRAWING_SCALE, 0);
_Db.MText mText = new _Db.MText();
mText.SetDatabaseDefaults();
mText.Contents = mark;
_Db.MLeader leader = new _Db.MLeader();
leader.SetDatabaseDefaults();
leader.ContentType = _Db.ContentType.MTextContent;
leader.MText = mText;
leader.AddLeaderLine(insertPointLeader);
leader.TextLocation = insertPointText;
leader.MLeaderStyle = mleaderStyleTable.GetAt(styleName);
leader.Layer = layerName;
_c.modelSpace.AppendEntity(leader);
_c.trans.AddNewlyCreatedDBObject(leader, true);
}
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);
}
void drawMesh(Graphics e)
{
if (meshs != null)
{
foreach (var mesh in meshs)
{
ArithmMeanGrade crit = new ArithmMeanGrade();
Gradient st = new Gradient();
for (int i = 0; i < mesh.Y - 1; i++)
{
for (int j = 0; j < mesh.X - 1; j++)
{
// st.GetCellColor(crit.Calculate(mesh));
System.Drawing.Point[] littlemesh = new System.Drawing.Point[4];
littlemesh[0] = new System.Drawing.Point((int)(mesh[i, j].X), (int)(mesh[i, j].Y));
littlemesh[1] = new System.Drawing.Point((int)(mesh[i + 1, j].X), (int)(mesh[i + 1, j].Y));
littlemesh[2] = new System.Drawing.Point((int)(mesh[i + 1, j + 1].X), (int)(mesh[i + 1, j + 1].Y));
littlemesh[3] = new System.Drawing.Point((int)(mesh[i, j + 1].X), (int)(mesh[i, j + 1].Y));
Geometry.Point[,] littlemesh2 = new Geometry.Point[2, 2];
littlemesh2[0, 0] = new Geometry.Point((int)(mesh[i, j].X), (int)(mesh[i, j].Y));
littlemesh2[0, 1] = new Geometry.Point((int)(mesh[i + 1, j].X), (int)(mesh[i + 1, j].Y));
littlemesh2[1, 0] = new Geometry.Point((int)(mesh[i, j + 1].X), (int)(mesh[i, j + 1].Y));
littlemesh2[1, 1] = new Geometry.Point((int)(mesh[i + 1, j + 1].X), (int)(mesh[i + 1, j + 1].Y));
int cols = 2;
int rows = 2;
RegMesh2D mesh2 = new RegMesh2D(littlemesh2, cols, rows);
Brush br = new SolidBrush(st.GetCellColor(crit.Calculate(mesh2)));
e.FillPolygon(br, littlemesh);
}
}
for (int i = 0; i < mesh.Y; i++)
{
for (int j = 0; j < mesh.X; j++)
{
if (j != mesh.X - 1)
{
e.DrawLine(new Pen(Color.Black),
(int)mesh[i, j].X, (int)mesh[i, j].Y,
(int)mesh[i, j + 1].X, (int)mesh[i, j + 1].Y);
}
if (i != mesh.Y - 1)
{
e.DrawLine(new Pen(Color.Black),
(int)mesh[i, j].X, (int)mesh[i, j].Y,
(int)mesh[i + 1, j].X, (int)mesh[i + 1, j].Y);
}
}
}
}
meshs = null;
}
}
public LineSegment(G.Point start, G.Edge parent, G.Edge other = null)
{
_start = start;
_end = start;
_parent = parent;
_other = other;
}
private void draw_circle(G.Point p, Pen ppp, PaintEventArgs e, int pointSize = 10)
{
int x = (Convert.ToInt32(p.X) / scale) - nullX - pointSize / 2;
int y = (-Convert.ToInt32(p.Y) / scale) + nullY - pointSize / 2;
Point dp = new Point(x, y);
e.Graphics.DrawEllipse(ppp, x, y, pointSize, pointSize);
}
public Teleport(Point center)
: base(Physics.Material.Adamantium, new Point(0, 0), false, null)
{
teleported = null;
Activated = false;
Enabled = true;
Shape = ConvexPolygon.Rectangle(center, Width, Height);
}
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);
}
private void define_side_D(LineSegment seg)
{
G.Line ln = seg.getLine();
G.Line offsetLine = ln.Offset(_V_.X_CONCRETE_COVER_1);
G.Vector d1 = ln.getDirectionVector();
G.Vector o1 = ln.getOffsetVector();
double absX = Math.Abs(o1.X);
double absY = Math.Abs(o1.Y);
G.Vector absV = new G.Vector(absX, absY);
G.Polar p = G.Converter.xy_to_la(absV);
int spacing;
int distance;
int parand; // parand magic
if (p.angle < Math.PI / 4)
{
spacing = _V_.X_REINFORCEMENT_SIDE_D_SPACING;
distance = _V_.X_REINFORCEMENT_SIDE_D_ANCHOR_LENGTH;
parand = _V_.X_REINFORCEMENT_SIDE_D_FIX;
}
else
{
spacing = _V_.X_REINFORCEMENT_TOP_D_SPACING;
distance = _V_.X_REINFORCEMENT_TOP_D_ANCHOR_LENGTH;
parand = _V_.X_REINFORCEMENT_TOP_D_FIX;
}
double nearEdge = _V_.X_CONCRETE_COVER_1 * 2.5;
double equalSpacer = ((ln.Length() - 2 * nearEdge) % spacing) / 2;
double j = nearEdge + equalSpacer;
double len = ln.Length();
if ((len - nearEdge * 2) > spacing)
{
R.Raud_Array rauad = new R.Raud_Array(spacing);
knownArrayReinforcement.Add(rauad);
while (j < len)
{
G.Point start = offsetLine.Start.move(j, d1);
G.Point end = start.move(distance, o1);
D_side_handler(start, end, parand); // parand magic
j = j + spacing;
}
D_side_garbage_collector();
}
}
public void A_Raud_class_test()
{
G.Point start = new G.Point(0.0, 0.0);
G.Point end = new G.Point(10.0, 0.0);
G.Line line = new G.Line(start, end);
R.A_Raud reinf = new R.A_Raud(line, 2, 8, "B500B");
Assert.IsTrue(reinf is R.Raud);
Assert.IsTrue(reinf is R.A_Raud);
}
public void SetVelocityToPlayer(Point adding)
{
if (adding.IsCollinear(new Point(1, 0))) //Horizontal vector
{
player.Velocity = new Point(adding.x, player.Velocity.y);
}
else if (world.IsBodyOnGround(player, PhysicalWorld.acceleration))
{
player.Velocity = new Point(player.Velocity.x, adding.y);
}
}
//DEBUG
private bool A_handler_debug(G.Point mainPoint, G.Point mainEnd)
{
G.Line main = new G.Line(mainPoint, mainEnd);
reinf_geometry_debug.Add(main);
R.A_Raud reinf = new R.A_Raud(main, _V_.X_REINFORCEMENT_NUMBER, _V_.X_REINFORCEMENT_MAIN_DIAMETER, _V_.X_REINFORCEMENT_MARK);
keep(reinf, null, null, null);
return(true);
}
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 panel1_MouseUp(object sender, MouseEventArgs e)
{
if (moving)
{
IPoint new_p = new Geometry.Point(e.X + p_offset.X, e.Y + p_offset.Y);
new Items_Move(movingList.IndexOf(movingCurve), new_p, this).Execute();
movingCurve = null;
moving = false;
panel1.Refresh();
Draw(curves);
}
}
//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 Box(Point center)
: base(Physics.Material.Wood, new Point(0, 0), false, null)
{
type = random.Next(0, 3);
Point v = new Point(Size / 2, Size / 2);
var points = new[]
{
center + v, center + v.RotateAroundOrigin(Math.PI / 2),
center - v, center - v.RotateAroundOrigin(Math.PI / 2)
};
Shape = new ConvexPolygon(points);
}
private List <T.ReinforcementMark> getMarkData(List <_Db.MText> txts)
{
List <T.ReinforcementMark> parse = new List <T.ReinforcementMark>();
foreach (_Db.MText txt in txts)
{
G.Point insp = new G.Point(txt.Location.X, txt.Location.Y);
T.ReinforcementMark current = new T.ReinforcementMark(insp, txt.Contents);
parse.Add(current);
}
return(parse);
}
private List <T.TableMaterialRow> getSummaryData(List <_Db.BlockReference> blocks)
{
List <T.TableMaterialRow> parse = new List <T.TableMaterialRow>();
foreach (_Db.BlockReference block in blocks)
{
G.Point insp = new G.Point(block.Position.X, block.Position.Y);
T.TableMaterialRow temp = new T.TableMaterialRow(insp);
parse.Add(temp);
}
return(parse);
}
private void define_side_U(LineSegment seg)
{
G.Line mainLine = seg.getLine();
G.Line otherLine = seg.getOtherLine();
if (setLineSegment.Contains(seg))
{
return;
}
if (isLineRight(mainLine) == false && isLineRight(otherLine) == true)
{
return;
}
G.Vector d1 = mainLine.getDirectionVector();
G.Vector o1 = mainLine.getOffsetVector();
int spacing = _V_.X_REINFORCEMENT_STIRRUP_SPACING;
double nearEdge = _V_.X_CONCRETE_COVER_1 * 1.2;
double equalSpacer = ((mainLine.Length() - 2 * nearEdge) % spacing) / 2;
double j = nearEdge + equalSpacer;
double len = mainLine.Length();
if ((len - nearEdge * 2) > spacing)
{
R.Raud_Array rauad = new R.Raud_Array(spacing);
knownArrayReinforcement.Add(rauad);
while (j < len)
{
G.Point start = mainLine.Start.move(j, d1);
G.Point extended = start.move(_V_.Y_STIRRUP_MAX_LENGTH * 1.1, o1);
G.Line temp = new G.Line(start, extended);
G.Point end = G.Line.getIntersectionPoint(temp, otherLine);
temp = new G.Line(start, end);
if (Math.Round(temp.Length(), 0) > _V_.X_CONCRETE_COVER_1 * 2)
{
temp = temp.extendDouble(-1 * _V_.X_CONCRETE_COVER_1);
U_side_handler(temp.Start, temp.End, seg);
}
j = j + spacing;
}
U_side_garbage_collector();
}
}