Esempio n. 1
0
        public TubeProcessingData ProcessTubeStageOne(Tube3D tube)
        {
            TubeProcessingData tpd = new TubeProcessingData();

            Vector2[] Vert = new Vector2[3] {
                new Vector2(0, 0), new Vector2(1, 0), new Vector2(0, 1)
            };

            /* 1. Сохраним дно трубки */

            /*    for (int i = 0; i < 3; ++i)
             *      tpd.OldDno[i] = new Vector3(tube.Rays[i].Begin);
             *  tube.AntiRayize();*/

            /* 2. Найдем точки пересечения каждого из лучей с плоскостью треугольника */


            int Fails      = 0;
            int UnderFails = 0;

            for (int i = 0; i < 3; ++i)
            {
                tpd.IFact[i] = RayIntersect(tube.Rays[i], out tpd.UVs[i].x, out tpd.UVs[i].y);

                /* Плоские координаты u, v в 3D x, y, z */
                tpd.IPoints[i] = UVToXYZ(tpd.UVs[i].x, tpd.UVs[i].y);

                double t = tube.Rays[i].GetT(tpd.IPoints[i]);
                /* Если вдруг луч параллелен грани или вообще в другую сторону*/
                if (tpd.IFact[i] == -1 || tpd.IFact[i] == -2 /*|| t <= GeometryEpsilon*/ || t > 1 + Tracer3D.GeometryEpsilon)
                {
                    tpd.cs = TTCase.CaseNo;
                    //    Log("Stage1 : reject because tpd.IFact[" + i + "] = " + tpd.IFact[i] + " and t = " + t);
                    return(tpd);
                }
                else if (t <= Tracer3D.GeometryEpsilon)
                {
                    Fails++;
                    tpd.ExclusiveCaseUnderDno = true;
                    tpd.ExclusiveCaseIV[i]    = true;
                    //   Log("tpd.ExclusiveCaseUnderDno = true;");
                }
                // Log(" i = " + i + " ; t = " + t);

                /* трубка внутри треугольника */
                if (tpd.IFact[i] == 1)
                {
                    ++tpd.TinP;
                    tpd.TinPs.Add(i);
                    tpd.LastIndexTinP = i;
                }

                // Log("Stage 1: UnderPlane test: IPoints[i] = {" + tpd.IPoints[i].X + " , " + tpd.IPoints[i].Y + " , " + tpd.IPoints[i].Z + "}");
                //   Log("Stage 1: UnderPlane test: tube.Rays[0].Begin = {" + tube.Rays[0].Begin.X + " , " + tube.Rays[0].Begin.Y + " , " + tube.Rays[0].Begin.Z + "}");
                if (tpd.UnderPlane(UVToXYZ(tpd.Vert[i].x, tpd.Vert[i].y) - tube.Rays[0].Begin))
                {
                    UnderFails++;
                    tpd.DoNotAddPP[i] = true;
                    Log("Stage1 : underfail on i = " + i);

                    if (UnderFails == 3)
                    {
                        tpd.cs = TTCase.CaseNo;
                        Log("Stage1 : reject because UnderFails = 3");
                        return(tpd);
                    }
                }

                //if (cw != null) cw("IPoints[" + i + "] = " + IPoints[i].ToString() + " >>>>> u = " + UVs[i].x + " ; v = " + UVs[i].y);
            }

            if (Fails > 2)
            {
                tpd.cs = TTCase.CaseNo;
                return(tpd);
            }


            /* 3. ищем и пересчитываем все пересечения граней треугольника с гранями трубки */
            for (int i = 0; i < 3; ++i)
            {
                /* точки треугольника в трубке ? */

                double q1 = Utils2D.Classify(tpd.UVs[0].x, tpd.UVs[0].y, tpd.UVs[1].x, tpd.UVs[1].y, Vert[i].x, Vert[i].y);
                double q2 = Utils2D.Classify(tpd.UVs[1].x, tpd.UVs[1].y, tpd.UVs[2].x, tpd.UVs[2].y, Vert[i].x, Vert[i].y);
                double q3 = Utils2D.Classify(tpd.UVs[2].x, tpd.UVs[2].y, tpd.UVs[0].x, tpd.UVs[0].y, Vert[i].x, Vert[i].y);

                if ((q1 > 0 && q2 > 0 && q3 > 0) || (q1 < 0 && q2 < 0 && q3 < 0))
                {
                    ++tpd.PinT;
                    tpd.PinTs.Add(i);
                    tpd.LastIndexPinT = i;
                }

                int nexti = i == 2 ? 0 : i + 1;
                for (int j = 0; j < 3; ++j)
                {
                    int nextj = j == 2 ? 0 : j + 1;
                    Utils2D.CrossResultRec crr = Utils2D.Crossing(Vert[j], Vert[nextj], tpd.UVs[i], tpd.UVs[nexti]);
                    if (crr.type == Utils2D.EnumCrossType.ctOnLine)
                    {
                        //   double t1 = Utils2D.GetParameterLinesPoint(tpd.Vert[j], tpd.Vert[nextj], tpd.UVs[i]);
                        //   double t2 = Utils2D.GetParameterLinesPoint(tpd.Vert[j], tpd.Vert[nextj], tpd.UVs[nexti]);
                        tpd.Intersections.Add(new IntersectRecord(tpd.UVs[i], i, nexti, j, nextj));
                        tpd.Intersections.Add(new IntersectRecord(tpd.UVs[nexti], i, nexti, j, nextj));
                        //  tpd.DoNotAddPT[i] = true;
                        //  tpd.DoNotAddPT[nexti] = true;
                        tpd.HasNoIc[i] = false;
                    }
                    else if (crr.type == Utils2D.EnumCrossType.ctInBounds || crr.type == Utils2D.EnumCrossType.ctOnBounds)
                    {
                        tpd.Intersections.Add(new IntersectRecord(crr.pt, i, nexti, j, nextj));
                        tpd.HasNoIc[i] = false;
                    }

                    /* else if (crr.type == Utils2D.EnumCrossType.ctOutBounds)
                     * {
                     *   tpd.OutIntersections.Add(new IntersectRecord(crr.pt, i, nexti, j, nextj));
                     * }*/
                }
            }

            int Ic = tpd.Intersections.Count;

            if (tpd.PinT == 0 && tpd.TinP == 0 && Ic < 4)
            {
                tpd.cs = TTCase.CaseNo;
                return(tpd);
            }

            /* 4. теперь зная TinP, PinT, Intersections.Count можно рассмотреть все 8 случаев */
            tpd.cs = WhichCase(tpd.TinP, tpd.PinT, Ic); // определим случай

            /* 5. если пересечение есть, смотрим минимальную дистанцию до каждого луча */
            if (tpd.cs != TTCase.CaseNo)
            {
                tpd.Distance = Math.Min(Math.Min(
                                            (tube.Rays[0].Begin - tpd.IPoints[0]).SumComponentSqrs(),
                                            (tube.Rays[1].Begin - tpd.IPoints[1]).SumComponentSqrs()),
                                        (tube.Rays[2].Begin - tpd.IPoints[2]).SumComponentSqrs());
                tpd.WaveDirection = tube.CenterDirection();
                tpd.WaveDirection.Normalize();
            }

            /*  for (int i = 0; i < 3; ++i)
             *    tube.Rays[i].Begin = tpd.OldDno[i];*/

            return(tpd);
        }
Esempio n. 2
0
        public TubeProcessResult ProcessTubeStageTwo(TubeProcessingData t, Tube3D tube, List <Tube3D> ReflRefrTubes, List <Tube3D> SplitTubes, List <Tube3D> AddTubes)
        {
            TubeProcessResult Tpr = new TubeProcessResult();

            /* Попробуем иначе!!!
             *
             * */

            /*
             * ВОТ СЮДА ВСТАВЛЯЮ ТЕСТОВЫЙ КОД!!!
             */
            // Список вершин для триангуляции
            List <Vector2> VertsForDelauney1 = new List <Vector2>();

            // Важно, что сначала я добавляю PinTs
            for (int i = 0; i < t.PinTs.Count; ++i)
            {
                VertsForDelauney1.Add(t.Vert[t.PinTs[i]]);
            }

            // Затем пересечения
            int Ic = t.Intersections.Count;

            for (int i = 0; i < Ic; ++i)
            {
                VertsForDelauney1.Add(new Vector2(t.Intersections[i].u, t.Intersections[i].v));
            }


            // Случай такой: часть грани оказалась под нижней плоскостью трубки
            bool PlaneIntersectsBottomTubePlane = t.DoNotAddPP[0] || t.DoNotAddPP[1] || t.DoNotAddPP[2];

            Log("Stage 2: BEGIN - Addional actions need? " + PlaneIntersectsBottomTubePlane.ToString());
            if (PlaneIntersectsBottomTubePlane)
            {
                // удалим из массива для триангуляции все точки, лежажие ниже нижней плоскости трубки
                int Dt = VertsForDelauney1.Count;
                VertsForDelauney1.RemoveAll(xx =>
                                            (xx != t.UVs[0] && xx != t.UVs[1] && xx != t.UVs[2]) &&
                                            ((t.DoNotAddPP[0] && xx == t.Vert[0]) ||
                                             (t.DoNotAddPP[1] && xx == t.Vert[1]) ||
                                             (t.DoNotAddPP[2] && xx == t.Vert[2]) ||
                                             t.UnderPlane(UVToXYZ(xx.x, xx.y) - tube.Rays[0].Begin))
                                            );

                Log("Excl case Delta -> VertsForDelauney1.Count = " + (Dt - VertsForDelauney1.Count));

                // Созданим треугольник из нижней плоскости трубки
                Plane3D Bp = new Plane3D(tube.Rays[0].Begin, tube.Rays[1].Begin, tube.Rays[2].Begin, true);

                // Теперь выясним какие именно стороны грани пересекают эту плосокость

                // Индексы i<номер стороны>_<вершина>
                int i1_1, i1_2, i2_1, i2_2;

                // Число вершин под плосотью Bp
                int UnderVertNum = (t.DoNotAddPP[0] ? 1 : 0) + (t.DoNotAddPP[1] ? 1 : 0) + (t.DoNotAddPP[2] ? 1 : 0);
                int iUnderOrAbove;
                // одна снизу
                if (UnderVertNum == 1)
                {
                    // Определили какая снизу
                    iUnderOrAbove = (t.DoNotAddPP[0] ? 0 : (t.DoNotAddPP[1] ? 1 : 2));
                }
                // две снизу
                else
                {
                    // Какая сверху оказалась?
                    iUnderOrAbove = (!t.DoNotAddPP[0] ? 0 : (!t.DoNotAddPP[1] ? 1 : 2));
                }
                // Значит две стороны от нее исходят к остальным двум вершинам
                i1_1 = iUnderOrAbove;
                i2_1 = iUnderOrAbove;
                switch (iUnderOrAbove)
                {
                case 0: i1_2 = 1; i2_2 = 2; break;

                case 1: i1_2 = 0; i2_2 = 2; break;

                default: i1_2 = 0; i2_2 = 1; break;
                }
                //Log("Indices i1_1 = " + i1_1 + " i1_2 = " + i1_2 + " i2_1 = " + i2_1 + " i2_2 = " + i2_2);

                // сюда занесем точки пересечения сторон грани с плосокотью Bp
                Vector2 PIB1 = new Vector2();
                Vector2 PIB2 = new Vector2();

                // собственно поиск пересечений сторон грани с плосоктью Bp
                int res1 = Bp.RayIntersect(new Ray3D(Vertex[i1_1], Vertex[i1_2]), out PIB1.x, out PIB1.y);
                int res2 = Bp.RayIntersect(new Ray3D(Vertex[i2_1], Vertex[i2_2]), out PIB2.x, out PIB2.y);
                Log("res1 = " + res1 + " res2 = " + res2);

                // проверим пересечия уже в плосокти Bp
                Vector2[] Rps = new Vector2[3] {
                    new Vector2(0, 0), new Vector2(1, 0), new Vector2(0, 1)
                };
                if (res1 < 0 || res2 < 0)
                {
                    for (int i = 0; i < 3; ++i)
                    {
                        int nexti = i == 2 ? 0 : i + 1;
                        var cr    = Utils2D.Crossing(Rps[i], Rps[nexti], PIB1, PIB2);
                        if (cr.type == Utils2D.EnumCrossType.ctInBounds || cr.type == Utils2D.EnumCrossType.ctOnBounds)
                        {
                            double u, v, n;
                            GetUV(Bp.UVToXYZ(cr.pt.x, cr.pt.y), out u, out v, out n);
                            VertsForDelauney1.Add(new Vector2(u, v));
                        }
                    }
                }

                // добавим в массив для триангуляции точки отрезка, если они внутри треуголньика
                if (res1 > 0)
                {
                    double u, v, n;
                    GetUV(Bp.UVToXYZ(PIB1.x, PIB1.y), out u, out v, out n);
                    VertsForDelauney1.Add(new Vector2(u, v));
                }
                if (res2 > 0)
                {
                    double u, v, n;
                    GetUV(Bp.UVToXYZ(PIB2.x, PIB2.y), out u, out v, out n);
                    VertsForDelauney1.Add(new Vector2(u, v));
                }

                if (VertsForDelauney1.Count < 3)
                {
                    AddTubes.Add(tube);
                    Log("!!!1");

                    return(Tpr);
                }
            }


            List <Triangle> Triangles = new List <Triangle>();

            int cnt1 = VertsForDelauney1.Count;

            // удаляем всех дублеров
            VertsForDelauney1 = VertsForDelauney1.Distinct(new RealPointComparer()).ToList();
            // сколько убавилось?
            Log("Delta -> cnt : VertsForDelauney1 = " + (VertsForDelauney1.Count - cnt1));

            // Индекс с которого ядро в списке кончилось
            int CoreEndIndex = 0;

            if (t.cs == TTCase.CaseA)
            {
                for (int i = 0; i < 3; ++i)
                {
                    VertsForDelauney1.Add(t.UVs[i]);
                }
                Triangles.Add(new Triangle(0, 1, 2, true));
                CoreEndIndex = 1;
            }
            else
            {
                // ядро триангулируем
                Triangles    = Utils2D.RoundTrianglulationWOCenter(VertsForDelauney1);
                CoreEndIndex = Triangles.Count;

                int TubePStartIndex = VertsForDelauney1.Count;
                // Потом точки трубки добавим туда же после триангуляции ядра
                for (int i = 0; i < 3; ++i)
                {
                    VertsForDelauney1.Add(t.UVs[i]);
                }

                // Что теперь? Берем произвольное ребро выпулклого многоугольника ядра и рассекаем им пространоство
                for (int iE = 0; iE < TubePStartIndex; ++iE)
                {
                    int F1 = iE;
                    int F2 = iE == TubePStartIndex - 1 ? 0 : iE + 1;

                    // Сперва, нам нужно найти все точки трубки, лежащие левее от этого ребра
                    List <int> LeftToEdge = new List <int>();
                    for (int i = 0; i < VertsForDelauney1.Count; ++i)
                    {
                        if (
                            F1 == i || F2 == i ||
                            Utils2D.Classify(VertsForDelauney1[F1].x, VertsForDelauney1[F1].y, VertsForDelauney1[F2].x, VertsForDelauney1[F2].y, VertsForDelauney1[i].x, VertsForDelauney1[i].y) > Tracer3D.GeometryEpsilon)
                        {
                            LeftToEdge.Add(i);
                        }
                    }

                    // есть, о чем говорить
                    if (LeftToEdge.Count == 3)
                    {
                        Triangles.Add(new Triangle(LeftToEdge[0], LeftToEdge[1], LeftToEdge[2]));
                        Triangles[Triangles.Count - 1].Dump("Single T[" + (Triangles.Count - 1) + "] on core-edge F1 = " + F1 + " F2 = " + F2, VertsForDelauney1);
                    }
                    else if (LeftToEdge.Count > 3)
                    {
                        List <Vector2> Region = new List <Vector2>();
                        LeftToEdge.ForEach(delegate(int p)
                        {
                            VertsForDelauney1[p].Tag = p;
                            Region.Add(VertsForDelauney1[p]);
                        });

                        List <Triangle> RegionTriangles = Utils2D.RoundTrianglulationWOCenter(Region);

                        RegionTriangles.ForEach(delegate(Triangle tr)
                        {
                            Triangles.Add(new Triangle(
                                              Region[tr.p1].Tag,
                                              Region[tr.p2].Tag,
                                              Region[tr.p3].Tag
                                              ));
                            Triangles[Triangles.Count - 1].Dump("Multi  T[" + (Triangles.Count - 1) + "] on core-edge F1 = " + F1 + " F2 = " + F2, VertsForDelauney1);
                        });
                    }
                }

                // Все таки костыль!
                // Ищем ребро, на котором нет пересечений, оно подозрительно
                for (int i = 0; i < 3; ++i)
                {
                    // их нет!
                    if (t.HasNoIc[i])
                    {
                        int j = i == 2 ? 0 : i + 1;
                        j += TubePStartIndex;
                        int ii = i + TubePStartIndex;

                        // Есть ли треугольник, содержащий его?
                        int itr = Triangles.FindIndex(x =>
                                                      x.HasVertex(ii) && x.HasVertex(j)
                                                      );
                        Log("KOST! ");
                        if (itr == -1)
                        {
                            // АГА! Нет такого треугольника! Создадим его
                            // Для этого нам нужно найти точку ядра наиболее близкую к ребру i
                            int iWTF = 0;

                            Vector3 P2P1        = new Vector3(VertsForDelauney1[ii].x - VertsForDelauney1[j].x, VertsForDelauney1[ii].y - VertsForDelauney1[j].y, 0);
                            double  MinDistance = 10e5;
                            for (int k = 0; k < TubePStartIndex; ++k)
                            {
                                double distanceFromPtoP2P1 = P2P1.CrossProduct(new Vector3(VertsForDelauney1[j].x - VertsForDelauney1[k].x, VertsForDelauney1[j].y - VertsForDelauney1[k].y, 0)).Magnitude;
                                if (MinDistance > distanceFromPtoP2P1)
                                {
                                    MinDistance = distanceFromPtoP2P1;
                                    iWTF        = k;
                                }
                            }

                            Triangles.Add(new Triangle(ii, j, iWTF));
                            Triangles[Triangles.Count - 1].Dump("KOST!  T[" + (Triangles.Count - 1) + "]", VertsForDelauney1);
                        }
                    }
                }
            }

            /* DEBUG */

            /*  // Определим количество внутренних треугольников
             * int Num = Triangles.Count(x => x.IsInner(VertsForDelauney1));
             *
             * // если их нет, значит попали мимо, значит на зачем дробить исходный
             * if (Num == 0)
             * {
             *
             *    Log("Miss!");
             *    Tpr.Cs = TTCase.CaseNo;
             *    return Tpr;
             *
             * }*/
            /* DEBUG */



            Tube3D tube2 = new Tube3D(tube); // КОСТЫЛЬ №2

            // Отрубим хвосты лучей до плоскости грани!
            for (int i = 0; i < 3; ++i)
            {
                tube2.Rays[i].End = t.IPoints[i];
            }
            // площадь трубки
            double Area = tube2.AreaTop();

            int Cnt = -1;

            foreach (Triangle tr in Triangles)
            {
                ++Cnt;
                // разбиваем трубку, вычленяем нужную
                Tube3D TubeToTrace1 = tube2.UniversalSplit(new Vector3[3] {
                    UVToXYZ(VertsForDelauney1[tr.p1].x, VertsForDelauney1[tr.p1].y),
                    UVToXYZ(VertsForDelauney1[tr.p2].x, VertsForDelauney1[tr.p2].y),
                    UVToXYZ(VertsForDelauney1[tr.p3].x, VertsForDelauney1[tr.p3].y)
                });

                if (TubeToTrace1 == null)
                {
                    continue;
                }

                /*   if (TubeToTrace1.WrongTubeTest())
                 *     Log("Stop");*/

                // DEBUG

                /*     TubeToTrace1.Tags[0] = "(" + tr.p1 + ")";
                 *   TubeToTrace1.Tags[1] = "(" + tr.p2 + ")";
                 *   TubeToTrace1.Tags[2] = "(" + tr.p3 + ")";
                 */

                // вдруг смотрит вниз? исправить, должна смотреть вверх
                for (int i = 0; i < 3; ++i)
                {
                    TubeToTrace1.Rays[i].Begin += t.WaveDirection * Tracer3D.GeometryEpsilon; // КОСТЫЛЬ №3
                    TubeToTrace1.Rays[i].End   += t.WaveDirection * Tracer3D.GeometryEpsilon * 2;
                    if (t.UnderPlane(TubeToTrace1.Rays[i].End - TubeToTrace1.Rays[i].Begin))
                    {
                        TubeToTrace1.Rays[i].End = 2 * TubeToTrace1.Rays[i].Begin - TubeToTrace1.Rays[i].End;
                    }
                }
                // наши потомки не должны воспринимать эту грань, чтобы повтроно ее не трассировать на след. шаге
                TubeToTrace1.Prohibit = this;

                // площаь потомка
                double AddArea = TubeToTrace1.AreaTop(); // ЭТО НЕ ПРАВИЛЬНО, КОГДА ГРАНЬ ПОД УКЛОНОМ!!!!

                // отгрызем кусок мощности
                TubeToTrace1.Power = tube.Power * AddArea / Area;
                //TubeToTrace1.

                // "внутренняя" трубка - та, что попала на грань, должна претерпеть отражение и преломление
                tr.Dump("", VertsForDelauney1);
                if (tr.IsInner(VertsForDelauney1))//Cnt < CoreEndIndex)//)//tr.Inner) // ?????????????????????????
                {
                    Log(" $$$ This triange is being traced! $$$");

                    // [0] - отраженная, [1] - преломленная
                    Tube3D[] RRT = ReflectAndRefractTube(TubeToTrace1);
                    if (RRT[0] != null)
                    {
                        // DEBUG
                        RRT[0].Comment = tube.Comment + " ; refl ";

                        // добавим ее в отраженные
                        RRT[0].Prohibit = this;
                        ReflRefrTubes.Add(RRT[0]);
                    }

                    if (RRT[1] != null)
                    {
                        // DEBUG
                        RRT[1].Comment = tube.Comment + " ; refr ";

                        // добавим ее в преломленные
                        RRT[1].Prohibit = this;
                        ReflRefrTubes.Add(RRT[1]);
                    }

                    // DEBUG
                    TubeToTrace1.Comment = tube.Comment + " ; me split ";

                    // а исходную - в дополнительные
                    SplitTubes.Add(TubeToTrace1);
                }
                else
                {
                    // DEBUG
                    TubeToTrace1.Comment = tube.Comment + " ; me add ";

                    // мимо грани - сразу в дополнительные
                    AddTubes.Add(TubeToTrace1);
                }
            }

            /* for (int i = 0; i < 3; ++i)
             *   if (t.UnderPlane(tube.Rays[i].End - tube.Rays[i].Begin))
             *   {
             *       Log("WWTF?");
             *       tube.Rays[i].End = 2 * tube.Rays[i].Begin - tube.Rays[i].End;
             *   }*/

            Tpr.Cs             = t.cs;
            Tpr.NumOfTriangles = Triangles.Count;
            Tpr.TotalNewTubes  = SplitTubes.Count + AddTubes.Count + ReflRefrTubes.Count;
            return(Tpr);
        }
Esempio n. 3
0
        public List <Tube3D> RecursiveTracing(Scene3D MyScene, List <Tube3D> Rays, uint Call = 0, uint AddCnt = 0)
        {
            // Список лучей
            List <Tube3D> Result = new List <Tube3D>();

            if (MyScene.ShouldTerminate)
            {
                MyScene.Ready = true;
                return(Result);
            }

            // Если достигли максимального шага вернем пустой список
            if (Call >= MaxTraceSteps || AddCnt >= 5)
            {
                if (AddCnt >= 5)
                {
                    Log("Stack overflow???");
                }
                Rays.ForEach(R => R.SetLenght(InfinityMVisible));
                return(Rays);
            }

            // Для каждого луча из предложенных на данный шаг
            foreach (Tube3D Ray in Rays)
            {
                // Заморочки многопоточности
                if (MyScene.ShouldTerminate)
                {
                    MyScene.Ready = true;
                    return(Result);
                }
                if (Call == 0 && AddCnt == 0)
                {
                    MyScene.RayCnt++;

                    MyScene.ProgressPercent = 100 * MyScene.RayCnt / MyScene.InitialRays.Count;

                    if (MyScene.ProgressPercent != MyScene.ProgressPercentOld)
                    {
                        UpdateProgress(MyScene.Tag, false);
                        MyScene.ProgressPercentOld = MyScene.ProgressPercent;
                    }
                }

                Log("Call = " + Call + " comment = {{" + Ray.Comment + "}}" + " Area = " + Ray.AreaTop().ToString());

                if (Call == 1)
                {
                    Log("stop call 1");
                }

                // Если мощность трубки исчезающе мала, проигнорируем ее, чтобы не плодить лишних
                // или если площадь нулевая
                if (Ray.Power < MinimumPower || Ray.AreaTopC < MinAreaTop)
                {
                    continue;
                }

                // Устремим концы лучей в бесконечность
                Ray.Rayize();

                // Данные о ближайшем пересечении
                TubeProcessingData MinTpd      = null;
                double             MinDistance = 1e10;
                Plane3D            MinPlane    = null;

                // Для всех граней в сцене
                int fc = -1;
                foreach (Figure3D Fig in MyScene.Figs)
                {
                    foreach (Plane3D Plane in Fig.TransformedFaces)
                    {
                        fc++;
                        // Нам запрещено взаимодействовать с этим треугольником, пропускаем его
                        if (Ray.Prohibit == Plane)
                        {
                            continue;
                        }

                        // Данные о столковении
                        TubeProcessingData Tpd = Plane.ProcessTubeStageOne(Ray);

                        // Если оно имело место и оказалось ближе предыдущего, сохраним эти данные
                        if (Tpd.cs != TTCase.CaseNo && MinDistance > Tpd.Distance)
                        {
                            MinDistance = Tpd.Distance;
                            MinTpd      = Tpd;
                            MinPlane    = Plane;
                        }
                    }
                }

                // Список трубок, которые отправят на следующий этап алгоритма
                List <Tube3D> ToNextCall = new List <Tube3D>();
                // Список трубок, которые получены из падающей трубки путем ее разбиения
                List <Tube3D> SplitTubes = new List <Tube3D>();
                // Список трубок, отсчеченных
                List <Tube3D> ToThisCall = new List <Tube3D>();

                // Если нет никаких пересечений пересечение
                if (MinPlane == null)
                {
                    // Просто сохраним эту трубку с результатах
                    Ray.SetLenght(InfinityMVisible);
                    Result.Add(Ray);
                }
                else
                {
                    Log("Stage 2: " + MinTpd.cs);
                    if (MinTpd.cs == TTCase.CaseUnknown)
                    {
                        Log("Stage 2: Unknown case details: ");
                        Log("   Ic = " + MinTpd.Intersections.Count);
                        Log("   PinT = " + MinTpd.PinT);
                        Log("   TinP = " + MinTpd.TinP);
                    }

                    // Второй этап обработки трубки и треугольника дает нам уже все производные трубки
                    TubeProcessResult Tpr = MinPlane.ProcessTubeStageTwo(MinTpd, Ray, ToNextCall, SplitTubes, ToThisCall);

                    // Добавим трубки составляющее все, что осталось от исходной при отсечке
                    Result.AddRange(SplitTubes);

                    // Добавим результат рекурсивного вызова трассировки для следующего шага (это прел./отр. трубки)
                    Result.AddRange(RecursiveTracing(MyScene, ToNextCall, Call + 2));

                    // Добавим результат рекурсивного вызова трассировки для текущего шага (отсечка)
                    Result.AddRange(RecursiveTracing(MyScene, ToThisCall, Call, AddCnt + 1));
                }
            }

            return(Result);
        }