public static List <ParamsPolygon> GetPolygonsOfCriticalArea(int n, double coeff, double deltaSmInitialStep = 1, double deltaCoeffStep = 1)
        {
            if (deltaSmInitialStep <= 0 || deltaCoeffStep <= 0)
            {
                throw new Exception("Недопустимые аргументы, должны быть > 0!");
            }
            Log("Построение основы... Подсчет точек... 0%");
            List <ParamsPolygon> polygons   = new List <ParamsPolygon>();
            List <Point3D>       areaUp     = new List <Point3D>();
            List <Point3D>       areaBottom = new List <Point3D>();
            List <Point3D>       areaResult = new List <Point3D>();
            DACEmulator          emulator   = new DACEmulator(n, coeff, 0, 0, 0);//Нижняя и верхняя половины области
            int edgesCount = 0;

            areaUp = GetPointsOfCriticalArea(emulator, DACEmulator.Delta.Coeff, DACEmulator.Delta.SM, deltaSmInitialStep, deltaCoeffStep);
            emulator.DeltaCoeff = 0;
            emulator.DeltaIndex = 0;
            emulator.DeltaSM    = 0;
            areaBottom          = GetPointsOfCriticalArea(emulator, DACEmulator.Delta.Coeff, DACEmulator.Delta.SM, deltaSmInitialStep, -deltaCoeffStep);
            edgesCount          = areaUp.Count;
            areaResult.AddRange(areaUp);

            List <Point3D> edgePrevious = new List <Point3D>();

            for (int i = 0; i < deltaSmInitialStep * 2; i++)
            {
                edgePrevious.Add(areaUp[0]);
            }
            for (int i = 0; i < edgesCount; i++)
            {
                emulator.DeltaCoeff = areaUp[i].X;
                emulator.DeltaIndex = 0;
                List <Point3D> edgeUp = GetPointsOfCriticalArea(emulator, areaBottom[i].Y, areaUp[i].Y, DACEmulator.Delta.SM, DACEmulator.Delta.Index, deltaSmInitialStep, deltaCoeffStep);
                emulator.DeltaCoeff = areaUp[i].X;
                emulator.DeltaIndex = 0;
                List <Point3D> edgeBottom = GetPointsOfCriticalArea(emulator, areaBottom[i].Y, areaUp[i].Y, DACEmulator.Delta.SM, DACEmulator.Delta.Index, deltaSmInitialStep, -deltaCoeffStep);
                edgeBottom.Reverse();
                edgeUp.AddRange(edgeBottom);
                areaResult.AddRange(edgeUp);

                if (i == edgesCount - 1)
                {
                    edgeUp.Clear();
                    for (int k = 0; k < deltaSmInitialStep * 2; k++)
                    {
                        edgeUp.Add(new Point3D(areaUp[areaUp.Count - 1].X, areaUp[areaUp.Count - 1].Y, areaBottom[areaUp.Count - 1].Z));
                    }
                }
                if (i > 0)
                {
                    ParamsPolygon polygon = null;
                    for (int j = 0; j < edgeUp.Count - 1; j++)
                    {
                        polygon = new ParamsPolygon();
                        polygon.Vertexs.Add(edgePrevious[j]);
                        polygon.Vertexs.Add(edgePrevious[j + 1]);
                        polygon.Vertexs.Add(edgeUp[j + 1]);
                        polygon.Vertexs.Add(edgeUp[j]);
                        polygons.Add(polygon);
                    }
                    polygon = new ParamsPolygon();
                    polygon.Vertexs.Add(edgePrevious[edgePrevious.Count - 1]);
                    polygon.Vertexs.Add(edgePrevious[0]);
                    polygon.Vertexs.Add(edgeUp[0]);
                    polygon.Vertexs.Add(edgeUp[edgeUp.Count - 1]);
                    polygons.Add(polygon);

                    Point3D[] pointsPrevious = new Point3D[edgeUp.Count];
                    edgeUp.CopyTo(pointsPrevious);
                    edgePrevious = pointsPrevious.ToList();
                }
                Log("Создание полигонов области допустимых значений... " + (i / edgesCount) + "%");
            }
            areaBottom.Reverse();
            //areaResult.AddRange(areaBottom);
            areaResult.RemoveRange(0, edgesCount);
            Log("Готово! 100%");
            return(polygons);
        }
            private void _read()
            {
                _size     = m_io.ReadU4le();
                _function = ((Wmf.Func)m_io.ReadU2le());
                switch (Function)
                {
                case Wmf.Func.Setbkmode: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsSetbkmode(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Setbkcolor: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ColorRef(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Setrop2: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsSetrop2(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Polyline: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsPolyline(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Setwindoworg: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsSetwindoworg(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Polygon: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsPolygon(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Setwindowext: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsSetwindowext(io___raw_params, this, m_root);
                    break;
                }

                case Wmf.Func.Setpolyfillmode: {
                    __raw_params = m_io.ReadBytes(((Size - 3) * 2));
                    var io___raw_params = new KaitaiStream(__raw_params);
                    _params = new ParamsSetpolyfillmode(io___raw_params, this, m_root);
                    break;
                }

                default: {
                    _params = m_io.ReadBytes(((Size - 3) * 2));
                    break;
                }
                }
            }