Exemple #1
0
        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);
        }
Exemple #2
0
        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 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);
        }
Exemple #4
0
        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);
                }
            }
        }
Exemple #5
0
 /// <summary>
 /// Угол, отсчитанный от первого вектора ко второму против часовой стрелки
 /// </summary>
 /// <param name="v1">первый вектор</param>
 /// <param name="v2">второй вектор</param>
 /// <returns>угол в радианах из интервала (-pi, +pi]</returns>
 public static double AngleBetween(Vector v1, Vector v2)
 {
     Vector vn1 = v1.Normalise();
     Vector n1 = Vector.LeftNormal(vn1);
     Vector vn2 = v2.Normalise();
     double sc = vn1 * vn2;
     double ht = n1 * vn2;
     return (ht >= 0) ? Math.Acos(sc) : -Math.Acos(sc);
 }
Exemple #6
0
        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();
            }
        }
Exemple #7
0
        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);
        }
        //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);
        }
        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();
            }
        }
        //definer
        private bool D_side_handler(G.Point start, G.Point end, int parand)
        {
            G.Line side = new G.Line(start, end);

            if (denier(side))
            {
                return(false);
            }

            //reinf_geometry_debug.Add(side);

            G.Vector o1   = side.getDirectionVector();
            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);

            R.D_Raud cur;
            if (p.angle < Math.PI / 4)
            {
                if (_V_.X_REINFORCEMENT_SIDE_D_CREATE == 1)
                {
                    cur = new R.D_Raud(side, _V_.Y_ELEMENT_WIDTH_COVER + parand, 1, _V_.X_REINFORCEMENT_SIDE_D_DIAMETER, _V_.X_REINFORCEMENT_MARK);
                }
                else
                {
                    return(false);
                }
            }
            else
            {
                if (_V_.X_REINFORCEMENT_TOP_D_CREATE == 1)
                {
                    cur = new R.D_Raud(side, _V_.Y_ELEMENT_WIDTH_COVER + parand, 1, _V_.X_REINFORCEMENT_TOP_D_DIAMETER, _V_.X_REINFORCEMENT_MARK);
                }
                else
                {
                    return(false);
                }
            }

            int currentIndex = knownArrayReinforcement.Count - 1;

            knownArrayReinforcement[currentIndex].add_one(cur);
            keep_array(cur, null);

            return(true);
        }
Exemple #11
0
        public D_Raud(G.Line main, G.Line side1, G.Line side2, int nr, int d, string teras, int parand = 0) : base(main, nr, d, teras)
        {
            _A  = shorter(side1.Length());
            _B  = shorter(main.Length());
            _B2 = shorter(main.Length() + parand); // parand magic
            _C  = shorter(side2.Length());

            _IP     = main.getCenterPoint();
            _Length = _A + _B2 + _C; // parand magic

            G.Vector v1 = -1 * side1.getDirectionVector();
            _Side1Point = _StartPoint.move(_A, v1);

            G.Vector v2 = side2.getDirectionVector();
            _Side2Point = _EndPoint.move(_C, v2);
        }
Exemple #12
0
        private void draw_region(G.Region r, List <G.Line> reinf, PaintEventArgs e)
        {
            foreach (G.Line re in reinf)
            {
                Pen ppp = new Pen(Color.Cyan, 2);
                draw_line(re, ppp, e);
            }

            // EDGES
            foreach (G.Edge ee in r.edges)
            {
                Pen ppp = new Pen(Color.DarkRed, 2);
                draw_line(ee.Line, ppp, e);
            }

            //CENTER POINT OFFSET
            foreach (G.Edge ee in r.edges)
            {
                G.Point  cp = ee.Line.getCenterPoint();
                G.Vector ov = ee.Line.getOffsetVector();
                G.Point  op = cp.move(20, ov);

                Pen ppp = new Pen(Color.Red, 2);
                draw_point(op, ppp, e);
            }

            //CORNERS
            foreach (G.Corner cr in r.corners)
            {
                if (Math.Abs(Math.Abs(cr.Angle) - Math.PI / 2) < 0.01)
                {
                    Pen ppp = new Pen(Color.Green, 2);
                    draw_circle(cr.CP, ppp, e);
                }
                else if (Math.Abs(cr.Angle) > Math.PI)
                {
                    Pen ppp = new Pen(Color.Red, 2);
                    draw_circle(cr.CP, ppp, e);
                }
                else
                {
                    Pen ppp = new Pen(Color.Blue, 2);
                    draw_circle(cr.CP, ppp, e);
                }
            }
        }
Exemple #13
0
        public E_Raud(G.Line main, G.Line side1, G.Line side2, int nr, int d, string teras, int parand = 0) : base(main, nr, d, teras)
        {
            G.Vector mainDir = main.getDirectionVector();
            G.Polar  mainPol = G.Converter.xy_to_la(mainDir);

            G.Vector sideDir1 = side1.getDirectionVector();
            G.Polar  sidePol1 = G.Converter.xy_to_la(sideDir1);

            G.Vector sideDir2 = side2.getDirectionVector();
            G.Polar  sidePol2 = G.Converter.xy_to_la(sideDir2);

            _A  = shorter(side1.Length());
            _B  = shorter(main.Length());
            _B2 = shorter(main.Length() + parand); // parand magic
            _C  = shorter(side2.Length());

            G.Vector perpendVector = mainDir.rotate(-Math.PI / 2);
            double   maxDist       = Math.Max(_A, _C) * 2;

            G.Line mainExtended = main.extendDouble(maxDist);

            G.Point movePoint1   = side1.Start.move(maxDist, perpendVector);
            G.Line  perpendLine1 = new G.Line(side1.Start, movePoint1);
            G.Point interPoint1  = G.Line.getIntersectionPoint(mainExtended, perpendLine1);
            G.Line  XLine        = new G.Line(side1.Start, interPoint1);

            G.Point movePoint2   = side2.End.move(maxDist, perpendVector);
            G.Line  perpendLine2 = new G.Line(side2.End, movePoint2);
            G.Point interPoint2  = G.Line.getIntersectionPoint(mainExtended, perpendLine2);
            G.Line  YLine        = new G.Line(side2.End, interPoint2);

            _U = G.Converter.AngleDelta(mainPol.angle, sidePol1.angle);
            _V = G.Converter.AngleDelta(mainPol.angle, sidePol2.angle);
            _X = XLine.Length();
            _Y = YLine.Length();

            _IP     = main.getCenterPoint();
            _Length = _A + _B2 + _C; // parand magic

            G.Vector v1 = -1 * side1.getDirectionVector();
            _Side1Point = _StartPoint.move(_A, v1);

            G.Vector v2 = side2.getDirectionVector();
            _Side2Point = _EndPoint.move(_C, v2);
        }
Exemple #14
0
        public Raud(G.Line main, int nr, int d, string teras)
        {
            G.Vector dir = main.getDirectionVector();
            G.Polar  pol = G.Converter.xy_to_la(dir);

            _Rotation = G.Converter.Wrap(pol.angle, Math.PI * 2, 0.0);

            _Number   = nr;
            _Diameter = d;
            _Materjal = teras;

            double shorterLength  = shorter(main.Length());
            double originalLength = main.Length();
            double delta          = (originalLength - shorterLength) / 2;

            _StartPoint = main.Start.move(delta, dir);
            _EndPoint   = _StartPoint.move(shorterLength, dir);
        }
Exemple #15
0
        private bool isLineRight(G.Line ln)
        {
            G.Vector v = ln.getDirectionVector();

            double absX = Math.Abs(v.X);
            double absY = Math.Abs(v.Y);

            G.Vector absV = new G.Vector(absX, absY);
            G.Polar  p    = G.Converter.xy_to_la(absV);

            double remain = p.angle % (Math.PI / 4);

            if (remain < 0.1)
            {
                return(true);
            }

            return(false);
        }
Exemple #16
0
        public B_Raud(G.Line main, G.Line side, int nr, int d, string teras) : base(main, nr, d, teras)
        {
            _A = shorter(side.Length());
            _B = shorter(main.Length());

            _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);
        }
Exemple #17
0
        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);
        }
Exemple #18
0
        private void draw_region(G.Region r, PaintEventArgs e)
        {
            foreach (G.Edge ee in r.edges)
            {
                Pen ppp = new Pen(Color.DarkRed, 2);
                draw_line(ee.Line, ppp, e);
            }

            foreach (G.Corner cr in r.corners)
            {
                if (Math.Abs(Math.Abs(cr.Angle) - Math.PI / 2) < 0.01)
                {
                    Pen ppp = new Pen(Color.Green, 2);
                    draw_circle(cr.CP, ppp, e);
                }
                else if (Math.Abs(cr.Angle) > Math.PI)
                {
                    Pen ppp = new Pen(Color.Red, 2);
                    draw_circle(cr.CP, ppp, e);
                }
                else
                {
                    Pen ppp = new Pen(Color.Blue, 2);
                    draw_circle(cr.CP, ppp, e);
                }
            }

            foreach (G.Edge ee in r.edges)
            {
                G.Point  cp = ee.Line.getCenterPoint();
                G.Vector ov = ee.Line.getOffsetVector();
                G.Point  op = cp.move(100, ov);

                Pen ppp = new Pen(Color.Red, 2);
                draw_point(op, ppp, e);
            }
        }
Exemple #19
0
        private void diagonalRotater(G.Point centerPoint, G.Vector v3, double n, double m, ref G.Line tester)
        {
            if (n > 6)
            {
                return;
            }

            double deg5 = 0.0872665;
            double rot  = deg5 * n * m;

            v3     = v3.rotate(rot);
            tester = new G.Line(centerPoint, _V_.X_REINFORCEMENT_DIAGONAL_ANCHOR_LENGTH, v3);

            if (denier(tester))
            {
                n = n + 1;
                m = m * -1;
                diagonalRotater(centerPoint, v3, n, m, ref tester);
            }
            else
            {
                return;
            }
        }
Exemple #20
0
        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);
                                }
                            }
                        }
                    }
                }
            }
        }
        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);
        }
Exemple #22
0
 public Vector(Vector source)
 {
     x = new double[source.x.Length];
     for (int i = 0; i < source.x.Length; ++i)
     {
         x[i] = source.x[i];
     }
 }
        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_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);
        }
Exemple #25
0
 //?
 public static double get_angle(Vector vector1, Vector vector2)
 {
     var firstChisl = vector1 * vector2;
     var firstZnam = Math.Sqrt(vector1 * vector1) * Math.Sqrt(vector2 * vector2);
     var fir = firstChisl / firstZnam;
     return Math.Acos(fir);
 }
Exemple #26
0
 /// <summary>
 /// Левая нормаль к вектору
 /// </summary>
 /// <param name="v">вектор</param>
 /// <returns>новый вектор</returns>
 public static Vector LeftNormal(Vector v)
 {
     return new Vector(-v.Y, v.X);
 }
Exemple #27
0
 /// <summary>
 /// Конструктор копирования
 /// </summary>
 /// <param name="v">копируемый вектор</param>
 public Vector(Vector v)
 {
     this.X = v.X; this.Y = v.Y;
 }
Exemple #28
0
 /// <summary>
 /// Угол, отсчитанный от орта оси X к данному вектору против часовой стрелки
 /// </summary>
 /// <param name="v"> вектор</param>
 /// <returns>угол в радианах из интервала (-pi, +pi]</returns>
 public static double AngleFromXOrto(Vector v)
 {
     Vector vn = v.Normalise();
     return (vn.Y >= 0) ? Math.Acos(vn.X) : -Math.Acos(vn.X);
 }
Exemple #29
0
        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);
                            }
                        }
                    }
                }
            }
        }
        //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);
        }