Exemple #1
0
        /// <summary>
        /// создание фаски
        /// </summary>
        /// <param name="param"></param>
        public void CreateChamfer(Parameters param)
        {
            double Lenght1 = param.Lenght1;
            double Lenght2 = param.Lenght2;
            double Angle1  = param.Angle1;
            var    doc     = (ksDocument3D)_kompas.ActiveDocument3D();
            ksPart part2   = (ksPart)doc.GetPart((short)Part_Type.pTop_Part); // новый компонент

            if (part2 != null)
            {
                ksEntityCollection collect2 = (ksEntityCollection)part2.EntityCollection((short)Obj3dType.o3d_face);
                if (collect2 != null && collect2.SelectByPoint(0, 0, Lenght1 + 5 + Lenght2) && collect2.GetCount() != 0)
                {
                    ksEntity entityChamfer = (ksEntity)part2.NewEntity((short)Obj3dType.o3d_chamfer);
                    if (entityChamfer != null)
                    {
                        ksChamferDefinition ChamferDef = (ksChamferDefinition)entityChamfer.GetDefinition();
                        if (ChamferDef != null)
                        {
                            ChamferDef.tangent = false;
                            ChamferDef.SetChamferParam(true, Angle1, Angle1);
                            ksEntityCollection arr = (ksEntityCollection)ChamferDef.array();    // динамический массив объектов
                            if (arr != null)
                            {
                                for (int i = 0, count = collect2.GetCount(); i < count; i++)
                                {
                                    arr.Add(collect2.GetByIndex(i));
                                }
                                entityChamfer.Create();
                            }
                        }
                    }
                }
            }
        }
Exemple #2
0
        /// <summary>
        /// Метод выполняет операцию выдавливания
        /// для последнего созданного эскиза
        /// </summary>
        /// <param name="depth">Глубина выдавливания</param>
        public bool DoOperationExtrusion(double depth)
        {
            try
            {
                ksEntityCollection coll = (ksEntityCollection)_app.Part.EntityCollection((short)Obj3dType.o3d_sketch);
                int      i          = coll.GetCount();
                ksEntity sketch     = coll.GetByIndex(i - 1);
                ksEntity entityExtr = (ksEntity)_app.Part.NewEntity((short)Obj3dType.o3d_baseExtrusion);
                if (entityExtr != null)
                {
                    ksBaseExtrusionDefinition extrusionDef = (ksBaseExtrusionDefinition)entityExtr.GetDefinition();
                    if (extrusionDef != null)
                    {
                        extrusionDef.directionType = (short)Direction_Type.dtMiddlePlane;
                    }
                    extrusionDef.SetSideParam(true, (short)End_Type.etBlind, depth);

                    extrusionDef.SetSketch(sketch);
                    entityExtr.Create();
                    entityExtr.Update();
                }
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Exemple #3
0
        /// <summary>
        /// Метод создает фаску в 45'
        /// </summary>
        public bool Create(double dist, Point3d coor)
        {
            try
            {
                ksEntityCollection edge = (ksEntityCollection)_app.Part.EntityCollection((short)Obj3dType.o3d_edge);
                if ((edge != null) && (edge.SelectByPoint(coor.X, coor.Y, coor.Z)) && (edge.GetCount() != 0))
                {
                    ksEntity            chamfer = (ksEntity)_app.Part.NewEntity((short)Obj3dType.o3d_chamfer);
                    ksChamferDefinition chDef   = (ksChamferDefinition)chamfer.GetDefinition();

                    if (chDef != null)
                    {
                        chDef.tangent = true;
                        chDef.SetChamferParam(false, dist, dist);
                        ksEntityCollection chamferCollection = (ksEntityCollection)chDef.array();
                        chamferCollection.Clear();
                        chamferCollection.Add(edge.GetByIndex(0));
                        chamfer.Create();
                    }
                }
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Exemple #4
0
        /// <summary>
        /// Окрашивание места для хвата в чёрный
        /// </summary>
        /// <param name="iPart">Интерфейс детали</param>
        /// <param name="side">Направление</param>
        private void CreateBlackColor(ksPart iPart, bool side)
        {
            //Получение радиуса ручки
            var X = _modelelParameters.Parameter(ParametersName.HandleRadius).Value;
            //Получение длины гладкой части
            var Y = _modelelParameters.Parameter(ParametersName.ConnectionLength).Value + 5;
            var Z = 0;
            //Получаем массив граней объекта
            ksEntityCollection entityCollectionPart =
                (ksEntityCollection)iPart.EntityCollection((short)Obj3dType.o3d_face);

            //Сортируем грани по заданным координатам
            if (side == true)
            {
                entityCollectionPart.SelectByPoint(X, Y, Z);
            }
            else
            {
                entityCollectionPart.SelectByPoint(X, -Y, Z);
            }
            //Получаем первый элмент массива
            ksEntity element = entityCollectionPart.First();
            //Получаем интерфейс управления цветом детали
            ksColorParam colorParam = element.ColorParam();

            //Назначаем цвет
            colorParam.color = 333333;
            //Применяем изменения
            element.Update();
        }
Exemple #5
0
        public void Fillet(ksPart iPart, int index, double radius, TeaPotParams teaPotParams)
        {
            // Получение интерфейса объекта скругление
            ksEntity entityFillet = (ksEntity)iPart.NewEntity((int)Obj3dType.o3d_fillet);
            // Получаем интерфейс параметров объекта скругление
            ksFilletDefinition filletDefinition = (ksFilletDefinition)entityFillet.GetDefinition();

            // Радиус скругления
            filletDefinition.radius = radius;
            // Не продолжать по касательным ребрам
            filletDefinition.tangent = true;
            // Получаем массив граней объекта
            ksEntityCollection entityCollectionPart = (ksEntityCollection)iPart.EntityCollection((int)Obj3dType.o3d_face);
            // Получаем массив скругляемых граней
            ksEntityCollection entityCollectionFillet = (ksEntityCollection)filletDefinition.array();

            entityCollectionFillet.Clear();

            //ksEntity ENT = entityCollectionFillet.GetByIndex(0);

            // Заполняем массив скругляемых объектов
            entityCollectionFillet.Add(entityCollectionPart.GetByIndex(index));

            // Создаем скругление
            int X = Convert.ToInt32(teaPotParams.TeaPotHandleColor);

            entityFillet.SetAdvancedColor(X, 2, 2, 2, 2, 1, 2);
            entityFillet.Create();
        }
Exemple #6
0
        /// <summary>
        /// Метод копирует последнюю операцию
        /// по концентрической окружности относительно оси OY
        /// </summary>
        /// <param name="count">Количество копий</param>
        public bool CreateOperationCircPartArray(int count)
        {
            try
            {
                ksEntityCollection elemCol = (ksEntityCollection)_app.Part.EntityCollection((short)Obj3dType.o3d_cutExtrusion);
                if ((elemCol != null) && (elemCol.GetCount() != 0))
                {
                    ksEntity axis     = (ksEntity)_app.Part.NewEntity((short)Obj3dType.o3d_axisOY);
                    ksEntity circCopy = (ksEntity)_app.Part.NewEntity((short)Obj3dType.o3d_circularCopy);
                    ksCircularCopyDefinition CopyDef = (ksCircularCopyDefinition)circCopy.GetDefinition();

                    if (CopyDef != null)
                    {
                        CopyDef.count1  = 1;
                        CopyDef.count2  = count;
                        CopyDef.step2   = 360;
                        CopyDef.factor2 = true;
                        CopyDef.SetAxis(axis);
                        ksEntityCollection copiedElemCol = (ksEntityCollection)CopyDef.GetOperationArray();
                        copiedElemCol.Clear();
                        int i = elemCol.GetCount();
                        copiedElemCol.Add(elemCol.GetByIndex(i - 1));
                        circCopy.Create();
                    }
                }
                return(true);
            }
            catch
            {
                return(false);
            }
        }
        /// <summary>
        /// Создание отверстий по концентрической сетке
        /// </summary>
        /// <param name="coordinate">Координата расположения</param>
        /// <param name="radius">Радиус отверстия</param>
        /// <param name="height">Высота вырезания</param>
        /// <param name="count">Количество отверстий</param>
        private void CreateArray(double coordinate, double radius,
                                 double height, int count)
        {
            var       document           = (ksDocument3D)_kompas.ActiveDocument3D();
            var       part               = (ksPart)document.GetPart((short)Part_Type.pTop_Part);
            const int coordinateX        = 0;
            const int coordinateY        = 0;
            const int styleLineBase      = 1;
            const int styleLineAuxiliary = 6;
            const int stepCopy           = 360;

            ksEntity entitySketch = (ksEntity)part.NewEntity((short)
                                                             Obj3dType.o3d_sketch);
            ksSketchDefinition sketchDefinition = (ksSketchDefinition)
                                                  entitySketch.GetDefinition();
            ksEntity basePlane = (ksEntity)part.GetDefaultEntity((short)
                                                                 Obj3dType.o3d_planeXOY);

            sketchDefinition.SetPlane(basePlane);
            entitySketch.Create();
            ksDocument2D sketchEdit = (ksDocument2D)sketchDefinition.
                                      BeginEdit();

            sketchEdit.ksCircle(coordinateX, coordinateY, coordinate,
                                styleLineAuxiliary);
            sketchEdit.ksCircle(coordinate, coordinateY, radius,
                                styleLineBase);
            sketchDefinition.EndEdit();

            ksEntity entityCutExtrusion = (ksEntity)part.NewEntity((short)
                                                                   Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition cutExtrusionDefinition =
                (ksCutExtrusionDefinition)entityCutExtrusion.GetDefinition();

            cutExtrusionDefinition.directionType =
                (short)Direction_Type.dtNormal;
            cutExtrusionDefinition.SetSideParam(true,
                                                (short)End_Type.etBlind, height);
            cutExtrusionDefinition.SetSketch(entitySketch);
            entityCutExtrusion.Create();

            ksEntity circularCopyEntity = (ksEntity)part.NewEntity((short)
                                                                   Obj3dType.o3d_circularCopy);
            ksCircularCopyDefinition circularCopyDefinition =
                (ksCircularCopyDefinition)circularCopyEntity.GetDefinition();

            circularCopyDefinition.SetCopyParamAlongDir(count, stepCopy,
                                                        true, false);
            ksEntity baseAxisOZ = (ksEntity)part.GetDefaultEntity((short)
                                                                  Obj3dType.o3d_axisOZ);

            circularCopyDefinition.SetAxis(baseAxisOZ);
            ksEntityCollection entityCollection = (ksEntityCollection)
                                                  circularCopyDefinition.GetOperationArray();

            entityCollection.Add(cutExtrusionDefinition);
            circularCopyEntity.Create();
        }
        /// <summary>
        /// Kompas extrusion parameters for extrusion by sketches collection
        /// </summary>
        /// <param name="document3DPart">Part with detail in 3d document</param>
        /// <param name="extrusionType">Type of extrusion</param>
        /// <param name="extrudableEntity">Extrudable (выдавливаЕМЫЙ) entity</param>
        /// <param name="sketchesCollection">Collection of extrudable sketches for types
        /// such as loft, evolution etc.</param>
        public KompasExtrusionParameters(ksPart document3DPart, Obj3dType extrusionType, ksEntity extrudableEntity, ksEntityCollection sketchesCollection)
        {
            Document3DPart     = document3DPart;
            ExtrusionType      = extrusionType;
            ExtrudableEntity   = extrudableEntity;
            SketchesCollection = sketchesCollection;

            Direction = Direction_Type.dtBoth;
            Depth     = default(double);
        }
        /// <summary>
        /// Kompas extrusion parameters for extrusion by entity
        /// </summary>
        /// <param name="document3DPart">Part with detail in 3d document</param>
        /// <param name="extrusionType">Type of extrusion</param>
        /// <param name="extrudableEntity">Extrudable (выдавливаЕМЫЙ) entity</param>
        /// <param name="direction">Type of direction of extrusion</param>
        /// <param name="depth">Depth of extrusion</param>
        public KompasExtrusionParameters(ksPart document3DPart, Obj3dType extrusionType, ksEntity extrudableEntity, Direction_Type direction, double depth)
        {
            Document3DPart   = document3DPart;
            ExtrusionType    = extrusionType;
            ExtrudableEntity = extrudableEntity;
            Direction        = direction;
            Depth            = depth;

            SketchesCollection = null;
        }
Exemple #10
0
        /// <summary>
        /// Построение держателя для блинов
        /// </summary>
        /// <param name="iPart">Интерфейс детали</param>
        /// <param name="side">Направление</param>
        private void CreateHolder(ksPart iPart, bool side)
        {
            //Получаем массив граней объекта
            ksEntityCollection entityCollectionPart =
                (ksEntityCollection)iPart.EntityCollection((short)Obj3dType.o3d_face);
            //Получаем длину гладкой части
            var Y = _modelelParameters.Parameter(ParametersName.ConnectionLength).Value / 2;
            //Получаем длину места хвата
            var Y1 = _modelelParameters.Parameter(ParametersName.GripLength).Value / 2;
            var Y2 = 15;

            //Сортируем грани по координатам
            if (side == false)
            {
                entityCollectionPart.SelectByPoint(0, -(Y + Y1 + Y2), 0);
            }
            if (side == true)
            {
                entityCollectionPart.SelectByPoint(0, (Y + Y1 + Y2), 0);
            }
            //Получаем первый элемент массива
            var planeDetal = entityCollectionPart.First();
            //Создаем новый эскиз
            ksEntity iSketch =
                (ksEntity)iPart.NewEntity((short)Obj3dType.o3d_sketch);
            //Получаем интерфейс свойств эскиза
            ksSketchDefinition iDefinitionSketch = (ksSketchDefinition)iSketch.GetDefinition();

            //Устанавливаем плоскость эскиза
            iDefinitionSketch.SetPlane(planeDetal);
            //Создание эскиза
            iSketch.Create();
            //Создание нового 2Д документа
            ksDocument2D iDocument2D = (ksDocument2D)iDefinitionSketch.BeginEdit();
            //Получение радиуса рукоятки
            var rad = _modelelParameters.Parameter(ParametersName.HolderRadius).Value;

            //Создание кругов
            iDocument2D.ksCircle(0, 0, 3, 1);
            iDocument2D.ksCircle(0, 0, rad, 1);
            //Создание эскиза
            iDefinitionSketch.EndEdit();
            //Получение глубины выдавливания
            var depth = _modelelParameters.Parameter(ParametersName.HolderLength).Value;

            //Выполнение выдавливания
            ExctrusionSketch(iPart, iSketch, depth, true);
        }
Exemple #11
0
            public override ksEntity Execute()
            {
                ksEntity cut = Part.NewEntity((short)Obj3dType.o3d_cutEvolution);
                ksCutEvolutionDefinition definition = cut.GetDefinition();

                definition.cut             = true;
                definition.sketchShiftType = 1;
                definition.SetSketch(_drawSectionCmd.Execute());

                ksEntityCollection entityCollection = definition.PathPartArray();

                entityCollection.Clear();
                entityCollection.Add(_drawTrajectoryCmd.Execute());
                cut.Create();
                return(cut);
            }
Exemple #12
0
        /// <summary>
        /// Выдавливание по траектории
        /// </summary>
        /// <param name="entityEvolution">вырез кинматики</param>
        /// <param name="skechOne">Эскиз сечения</param>
        /// <param name="skechTwo">Эскиз траектории</param>
        /// <param name="ksEntityCollection"></param>
        private void KinematicExstrusion(ksEntity skechOne,
                                         ksEntity skechTwo)
        {
            ksEntity entityEvolution =
                (ksEntity)_ksPart.NewEntity((short)Obj3dType.o3d_baseEvolution);
            ksBaseEvolutionDefinition baseEvolutionDefinition =
                (ksBaseEvolutionDefinition)entityEvolution.GetDefinition();

            baseEvolutionDefinition.sketchShiftType = 1;
            baseEvolutionDefinition.SetSketch(skechOne);
            ksEntityCollection ksEntityCollection =
                (ksEntityCollection)baseEvolutionDefinition.PathPartArray();

            ksEntityCollection.Clear();
            ksEntityCollection.Add(skechTwo);
            entityEvolution.Create();
        }
Exemple #13
0
            public override ksEntity Execute()
            {
                _extrudeHandleCmd.Execute();
                ksEntity           fillet           = Part.NewEntity((short)Obj3dType.o3d_fillet);
                ksFilletDefinition filletDefinition = fillet.GetDefinition();

                filletDefinition.radius  = 1;
                filletDefinition.tangent = false;
                ksEntityCollection facesToFillet = filletDefinition.array();

                facesToFillet.Clear();
                ksEntityCollection partFaces = Part.EntityCollection((short)Obj3dType.o3d_face);

                for (int i = 0; i < partFaces.GetCount(); i++)
                {
                    facesToFillet.Add(partFaces.GetByIndex(i));
                }

                fillet.Create();
                return(fillet);
            }
Exemple #14
0
        /// <summary>
        /// Скругление
        /// </summary>
        private void Filled(ksEntity ksEntity)
        {
            const int grayColor      = 16777215;
            ksEntity  ksEntityFilled = (ksEntity)_ksPart.NewEntity(
                (short)Obj3dType.o3d_fillet);
            ksFilletDefinition ksFilletDefinition =
                (ksFilletDefinition)ksEntityFilled.GetDefinition();

            ksFilletDefinition.radius  = 2;
            ksFilletDefinition.tangent = false;
            ksEntityCollection ksEntityCollectionPart =
                (ksEntityCollection)_ksPart.EntityCollection(
                    (short)Obj3dType.o3d_edge);
            ksEntityCollection ksEntityCollectionFillet =
                (ksEntityCollection)ksFilletDefinition.array();

            ksEntityCollectionFillet.Clear();
            ksEntityCollectionFillet.Add(ksEntityCollectionPart.GetByIndex(1));
            ksEntityCollectionFillet.Add(ksEntityCollectionPart.GetByIndex(0));
            ksEntityFilled.useColor = 0;
            ksEntityFilled.SetAdvancedColor(grayColor, 0.9, 0.8,
                                            0.7, 0.6, 1, 0.4);
            ksEntityFilled.Create();
        }
Exemple #15
0
        /// <summary>
        /// Построение места для хвата
        /// </summary>
        private void CreateGrip(ksPart iPart, bool side)
        {
            //Объявление объекта плоскости
            ksEntity planeDetal = null;
            var      direction  = true;

            //Если длина гладкого места равна 0
            if (_modelelParameters.Parameter(ParametersName.ConnectionLength).Value == 0)
            {
                //Получаем интерфейс базовой плоскости ХОY
                planeDetal =
                    (ksEntity)iPart.GetDefaultEntity((short)Obj3dType.o3d_planeXOZ);
                if (side == true)
                {
                    direction = false;
                }
            }
            else
            {
                //Получаем массив граней объекта
                ksEntityCollection entityCollectionPart =
                    (ksEntityCollection)iPart.EntityCollection((short)Obj3dType.o3d_face);
                //Получаем длину гладкой части
                var Y = _modelelParameters.Parameter(ParametersName.ConnectionLength).Value / 2;
                //Сортируем грани по принадлежности к координатам
                if (side == false)
                {
                    entityCollectionPart.SelectByPoint(0, -Y, 0);
                }
                if (side == true)
                {
                    entityCollectionPart.SelectByPoint(0, Y, 0);
                }
                //Получение первой грани массива
                planeDetal = entityCollectionPart.First();
            }
            //Создаем новый эскиз
            ksEntity iSketch =
                (ksEntity)iPart.NewEntity((short)Obj3dType.o3d_sketch);
            //Получаем интерфейс свойств эскиза
            ksSketchDefinition iDefinitionSketch = (ksSketchDefinition)iSketch.GetDefinition();

            //Устанавливаем плоскость эскиза
            iDefinitionSketch.SetPlane(planeDetal);
            //Создание эскиза
            iSketch.Create();
            //Создание нового 2Д документа
            ksDocument2D iDocument2D = (ksDocument2D)iDefinitionSketch.BeginEdit();
            //Получение радиуса ручки
            var rad = _modelelParameters.Parameter(ParametersName.HandleRadius).Value;

            //Создание круга
            iDocument2D.ksCircle(0, 0, rad, 1);
            //Создание эскиза
            iDefinitionSketch.EndEdit();
            //Получение глубины выдавливания
            var depth = _modelelParameters.Parameter(ParametersName.GripLength).Value / 2;

            //Выполнение выдавливания
            ExctrusionSketch(iPart, iSketch, depth, direction);
        }
Exemple #16
0
        /// <summary>
        /// Создание модели шестерни
        /// </summary>
        /// <param name="properties">Передаваемые с формы параметры</param>
        public void CreateModel(Gear properties)
        {
            int teethCount    = properties.TeethCount;
            var angle         = properties.Angle;
            var thickness     = properties.Thickness;
            var shaftDiam     = properties.ShaftDiam;
            var diameterOut   = properties.DiameterOut;
            var diameterIn    = properties.DiameterIn;
            var diameterPitch = (diameterOut + diameterIn) / 2; // делительный диаметр колеса
            var alfa1         = 0.0;
            var alfa2         = 0.0;
            // интерфейсы ортогональных плоскостей
            ksPart iPart = _doc3.GetPart((int)Part_Type.pNew_Part) as ksPart;  //новый компонет

            if (iPart != null)
            {
                // интерфейсы ортогональных плоскостей
                ksEntity planeXoy = iPart.GetDefaultEntity((short)Obj3dType.o3d_planeXOY) as ksEntity;
                ksEntity planeXoz = iPart.GetDefaultEntity((short)Obj3dType.o3d_planeXOZ) as ksEntity;
                ksEntity planeYoz = iPart.GetDefaultEntity((short)Obj3dType.o3d_planeYOZ) as ksEntity;
                // интерфейс эскиза (половина контура сечения колеса)
                ksEntity iSketchEntity = iPart.NewEntity((short)Obj3dType.o3d_sketch) as ksEntity;
                if (iSketchEntity != null)
                {
                    // интерфейс параметров эскиза
                    ksSketchDefinition iSketchDef = iSketchEntity.GetDefinition() as ksSketchDefinition;
                    if (iSketchDef != null)
                    {
                        if (planeXoy != null)
                        {
                            // устанавливаем плоскость,
                            // на которой создается эскиз
                            iSketchDef.SetPlane(planeXoy);

                            iSketchEntity.Create();

                            // запускаем процесс редактирования эскиза
                            // doc – указатель на интерфейс ksDocument2D
                            _doc = iSketchDef.BeginEdit() as ksDocument2D;
                            if (_doc != null)
                            {
                                _doc.ksLineSeg(-thickness / 2, 00, thickness / 2, 0, 3); //3 - осевая линия
                                _doc.ksLineSeg(thickness / 2, shaftDiam / 2, -thickness / 2, shaftDiam / 2, 1);
                                _doc.ksLineSeg(thickness / 2, shaftDiam / 2, thickness / 2, diameterOut / 2, 1);
                                _doc.ksLineSeg(-thickness / 2, diameterOut / 2, -thickness / 2, shaftDiam / 2, 1);
                                _doc.ksLineSeg(-thickness / 2, diameterOut / 2, thickness / 2, diameterOut / 2, 1);
                            }
                            iSketchDef.EndEdit();
                        }
                    }
                }
                // интерфейс базовой операции вращения
                ksEntity iBaseRotatedEntity = iPart.NewEntity((short)Obj3dType.o3d_baseRotated) as ksEntity;
                if (iBaseRotatedEntity != null)
                {
                    // интерфейс параметров вращения
                    ksBaseRotatedDefinition iBaseRotatedDef =
                        iBaseRotatedEntity.GetDefinition() as ksBaseRotatedDefinition;
                    if (iBaseRotatedDef != null)
                    {
                        // настройка параметров вращения
                        iBaseRotatedDef.SetThinParam(false, (short)Direction_Type.dtNormal, 1, 1);
                        iBaseRotatedDef.SetSideParam(true, 360.0);
                        iBaseRotatedDef.toroidShapeType = false;
                        iBaseRotatedDef.SetSketch(iSketchEntity);
                        // создаем операцию вращения
                        // результат – заготовка зубчатого колеса
                        iBaseRotatedEntity.Create();
                    }
                }
                ksEntity iSketch1Entity = iPart.NewEntity((short)Obj3dType.o3d_sketch) as ksEntity;
                if (iSketch1Entity != null)
                {
                    ksSketchDefinition iSketch1Def = iSketch1Entity.GetDefinition() as ksSketchDefinition;
                    if (iSketch1Def != null)
                    {
                        if (planeYoz != null)
                        {
                            // размещаем эскиз на плоскости XOY
                            iSketch1Def.SetPlane(planeXoy);
                            iSketch1Entity.Create();
                            _doc = iSketch1Def.BeginEdit() as ksDocument2D;
                            if (_doc != null)
                            {
                                var width = properties.KeywayWidth;
                                _doc.ksLineSeg(thickness / 2, -width / 2, -thickness / 2, -width / 2, 1);
                                _doc.ksLineSeg(-thickness / 2, width / 2, -thickness / 2, -width / 2, 1);
                                _doc.ksLineSeg(-thickness / 2, width / 2, thickness / 2, width / 2, 1);
                                _doc.ksLineSeg(thickness / 2, width / 2, thickness / 2, -width / 2, 1);
                            }
                            iSketch1Def.EndEdit();
                        }
                    }
                }
                // интерфейс операции Вырезать выдавливанием
                ksEntity iCutExtrusion = iPart.NewEntity((short)Obj3dType.o3d_cutExtrusion) as ksEntity;
                if (iCutExtrusion != null)
                {
                    // интерфейс параметров вырезания
                    ksCutExtrusionDefinition iCutExtrusionDef =
                        iCutExtrusion.GetDefinition() as ksCutExtrusionDefinition;
                    if (iCutExtrusionDef != null)
                    {
                        // настройка параметров
                        iCutExtrusionDef.SetSketch(iSketch1Entity);
                        // направление
                        iCutExtrusionDef.directionType = (short)Direction_Type.dtNormal;
                        // величина вырезания по каждому из направлений
                        iCutExtrusionDef.SetSideParam(true, (short)ksEndTypeEnum.etBlind,
                                                      properties.KeywayDepth + shaftDiam / 2, 0, false);
                        iCutExtrusionDef.SetThinParam(false, 0, 0, 0);
                        iCutExtrusion.Create();
                    }
                }
                // интерфейс смещенной плоскости
                ksEntity iOffsetPlaneEntity = iPart.NewEntity((short)Obj3dType.o3d_planeOffset) as ksEntity;
                if (iOffsetPlaneEntity != null)
                {
                    // интерфейс параметров смещенной плоскости
                    ksPlaneOffsetDefinition iOffsetPlaneDef =
                        iOffsetPlaneEntity.GetDefinition() as ksPlaneOffsetDefinition;
                    if (iOffsetPlaneDef != null)
                    {
                        // величина, базовая плоскость и другие параметры смещения
                        iOffsetPlaneDef.offset = thickness / 2;
                        iOffsetPlaneDef.SetPlane(planeYoz);
                        iOffsetPlaneDef.direction = false;
                        // делаем плоскость скрытой
                        iOffsetPlaneEntity.hidden = true;
                        // создаем вспомогательную плоскость
                        iOffsetPlaneEntity.Create();
                    }
                }
                // эскиз первого выреза между зубьями
                ksEntity iSketch2Entity = iPart.NewEntity((short)Obj3dType.o3d_sketch) as ksEntity;
                if (iSketch2Entity != null)
                {
                    ksSketchDefinition iSketch2Def = iSketch2Entity.GetDefinition() as ksSketchDefinition;
                    if (iSketch2Def != null)
                    {
                        // базовая плоскость – вспомогательная iOffsetPlaneEntity
                        iSketch2Def.SetPlane(iOffsetPlaneEntity);
                        iSketch2Entity.Create();
                        _doc  = iSketch2Def.BeginEdit() as ksDocument2D;
                        alfa1 = 360.0 / teethCount;
                        _doc.ksMtr(0, 0, 90, 1, 1);
                        // вычерчивание изображения эскиза
                        // вместо эвольвент для простоты
                        // берем обычные дуги по трем точкам
                        _doc.ksArcBy3Points(-(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0)),
                                            -diameterPitch / 2 * Math.Sin(DegToRad(alfa1 / 8)),
                                            -diameterPitch / 2 * Math.Cos(DegToRad(alfa1 / 8)),
                                            -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 4)),
                                            -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 4)), 1);
                        _doc.ksArcByPoint(0, 0, diameterIn / 2, -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 4)),
                                          -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 4)),
                                          -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 2)),
                                          -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 2)), -1, 1);
                        _doc.ksArcBy3Points(-diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 2)),
                                            -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 2)),
                                            -diameterPitch / 2 * Math.Sin(DegToRad(0.625 * alfa1)),
                                            -diameterPitch / 2 * Math.Cos(DegToRad(0.625 * alfa1)),
                                            -(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0.75 * alfa1)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0.75 * alfa1)), 1);
                        _doc.ksArcBy3Points(-(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0.75 * alfa1)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0.75 * alfa1)),
                                            -(diameterOut / 2 + 2) * Math.Sin(DegToRad(0.375 * alfa1)),
                                            -(diameterOut / 2 + 2) * Math.Cos(DegToRad(0.375 * alfa1)),
                                            -(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0)), 1);
                        _doc.ksDeleteMtr();
                        iSketch2Def.EndEdit();
                    }
                }
                // интерфейс второго эскиза выреза между зубьями
                ksEntity iSketch3Entity = iPart.NewEntity((short)Obj3dType.o3d_sketch) as ksEntity;
                if (iSketch3Entity != null)
                {
                    ksSketchDefinition iSketch3Def = iSketch3Entity.GetDefinition() as ksSketchDefinition;
                    if (iSketch3Def != null)
                    {
                        // строим на плоскости YOZ
                        iSketch3Def.SetPlane(planeYoz);
                        iSketch3Entity.Create();
                        _doc  = iSketch3Def.BeginEdit() as ksDocument2D;
                        alfa2 = -(180 / Math.PI * (thickness * Math.Tan(Math.PI * (angle) / 180) / diameterPitch));
                        _doc.ksMtr(0, 0, 90, 1, 1);
                        // вычерчивание изображения эскиза
                        // вместо эвольвент для простоты
                        // берем обычные дуги по трем точкам
                        _doc.ksArcBy3Points(-(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(alfa2)),
                                            -diameterPitch / 2 * Math.Sin(DegToRad(alfa1 / 8 + alfa2)),
                                            -diameterPitch / 2 * Math.Cos(DegToRad(alfa1 / 8 + alfa2)),
                                            -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 4 + alfa2)),
                                            -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 4 + alfa2)), 1);
                        _doc.ksArcByPoint(0, 0, diameterIn / 2, -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 4 + alfa2)),
                                          -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 4 + alfa2)),
                                          -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 2 + alfa2)),
                                          -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 2 + alfa2)), -1, 1);
                        _doc.ksArcBy3Points(-diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 2 + alfa2)),
                                            -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 2 + alfa2)),
                                            -diameterPitch / 2 * Math.Sin(DegToRad(0.625 * alfa1 + alfa2)),
                                            -diameterPitch / 2 * Math.Cos(DegToRad(0.625 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0.75 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0.75 * alfa1 + alfa2)), 1);
                        _doc.ksArcBy3Points(-(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0.75 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0.75 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 2) * Math.Sin(DegToRad(0.375 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 2) * Math.Cos(DegToRad(0.375 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(alfa2)),
                                            1);
                        _doc.ksDeleteMtr();
                        iSketch3Def.EndEdit();
                    }
                }
                // вторая смещенная плоскость
                ksEntity iOffsetPlane1Entity = iPart.NewEntity((short)Obj3dType.o3d_planeOffset) as ksEntity;
                if (iOffsetPlane1Entity != null)
                {
                    ksPlaneOffsetDefinition iOffsetPlane1Def =
                        iOffsetPlane1Entity.GetDefinition() as ksPlaneOffsetDefinition;
                    if (iOffsetPlane1Def != null)
                    {
                        // величина смещения та же
                        iOffsetPlane1Def.offset = thickness / 2;
                        // направление противоположное
                        iOffsetPlane1Def.direction = true;
                        iOffsetPlane1Def.SetPlane(planeYoz);
                        // делаем плоскость скрытой
                        iOffsetPlane1Entity.hidden = true;
                        // создаем смещенную плоскость
                        iOffsetPlane1Entity.Create();
                    }
                }
                // третий (последний) эскиз выреза между зубьями
                ksEntity iSketch4Entity = iPart.NewEntity((short)Obj3dType.o3d_sketch) as ksEntity;
                if (iSketch4Entity != null)
                {
                    ksSketchDefinition iSketch4Def = iSketch4Entity.GetDefinition() as ksSketchDefinition;
                    if (iSketch4Def != null)
                    {
                        // базовая плоскость – только что созданная смещенная
                        iSketch4Def.SetPlane(iOffsetPlane1Entity);
                        iSketch4Entity.Create();
                        _doc  = iSketch4Def.BeginEdit() as ksDocument2D;
                        alfa2 = -(180 / Math.PI * (2 * thickness * Math.Tan(Math.PI * (angle) / 180) / diameterPitch));
                        _doc.ksMtr(0, 0, 90, 1, 1);
                        // вычерчивание изображения эскиза
                        // вместо эвольвент для простоты
                        // берем обычные дуги по трем точкам
                        _doc.ksArcBy3Points(-(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(alfa2)),
                                            -diameterPitch / 2 * Math.Sin(DegToRad(alfa1 / 8 + alfa2)),
                                            -diameterPitch / 2 * Math.Cos(DegToRad(alfa1 / 8 + alfa2)),
                                            -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 4 + alfa2)),
                                            -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 4 + alfa2)), 1);
                        _doc.ksArcByPoint(0, 0, diameterIn / 2, -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 4 + alfa2)),
                                          -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 4 + alfa2)),
                                          -diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 2 + alfa2)),
                                          -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 2 + alfa2)), -1, 1);
                        _doc.ksArcBy3Points(-diameterIn / 2 * Math.Sin(DegToRad(alfa1 / 2 + alfa2)),
                                            -diameterIn / 2 * Math.Cos(DegToRad(alfa1 / 2 + alfa2)),
                                            -diameterPitch / 2 * Math.Sin(DegToRad(0.625 * alfa1 + alfa2)),
                                            -diameterPitch / 2 * Math.Cos(DegToRad(0.625 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0.75 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0.75 * alfa1 + alfa2)), 1);
                        _doc.ksArcBy3Points(-(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(0.75 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(0.75 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 2) * Math.Sin(DegToRad(0.375 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 2) * Math.Cos(DegToRad(0.375 * alfa1 + alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Sin(DegToRad(alfa2)),
                                            -(diameterOut / 2 + 0.1) * Math.Cos(DegToRad(alfa2)),
                                            1);
                        _doc.ksDeleteMtr();
                        iSketch4Def.EndEdit();
                    }
                }
                // интерфейс операции Вырезать по сечениям
                ksEntity iCutLoftEntity = iPart.NewEntity((short)Obj3dType.o3d_cutLoft) as ksEntity;
                if (iCutLoftEntity != null)
                {
                    // интерфейс параметров операции по сечениям
                    ksCutLoftDefinition iCutLoftDef = iCutLoftEntity.GetDefinition() as ksCutLoftDefinition;
                    if (iCutLoftDef != null)
                    {
                        // интерфейс массива ksEntityCollection
                        // коллекции эскизов для вырезания по сечениям
                        ksEntityCollection collect = iCutLoftDef.Sketchs() as ksEntityCollection;
                        // добавляем эскизы в колекцию
                        collect.Add(iSketch2Entity);
                        collect.Add(iSketch3Entity);
                        collect.Add(iSketch4Entity);
                        // создаем операцию по сечениям
                        // результат – первый вырез между зубьями в венце колеса
                        iCutLoftEntity.Create();
                    }
                }
                // интерфейс вспомогательной оси на пересечении двух плоскостей
                ksEntity iAxis = iPart.NewEntity((short)Obj3dType.o3d_axis2Planes) as ksEntity;
                if (iAxis != null)
                {
                    // интерфейс параметров вспомогательной оси
                    // на пересечении плоскостей
                    ksAxis2PlanesDefinition iAxis2PlDef = iAxis.GetDefinition() as ksAxis2PlanesDefinition;
                    if (iAxis2PlDef != null)
                    {
                        // задаем плоскости
                        iAxis2PlDef.SetPlane(1, planeXoz);
                        iAxis2PlDef.SetPlane(2, planeXoy);
                        // делаем ось невидимой
                        iAxis.hidden = true;
                        // создаем вспомогательную ось
                        iAxis.Create();
                    }
                }
                // интерфейс операции Массив по концентрической сетке
                ksEntity iCircularCopy = iPart.NewEntity((short)Obj3dType.o3d_circularCopy) as ksEntity;
                if (iCircularCopy != null)
                {
                    // интерфейс параметров операции копирования по массиву
                    ksCircularCopyDefinition iCirCopyDef = iCircularCopy.GetDefinition() as ksCircularCopyDefinition;
                    if (iCirCopyDef != null)
                    {
                        // коллекция операций для копирования
                        ksEntityCollection collect1 = iCirCopyDef.GetOperationArray() as ksEntityCollection;
                        // операция всего лишь одна – вырезание зуба
                        collect1.Add(iCutLoftEntity);
                        // количество копий, равно количеству зубьев
                        iCirCopyDef.count2  = teethCount;
                        iCirCopyDef.factor2 = true;
                        // ось копирования
                        iCirCopyDef.SetAxis(iAxis);
                        // создаем концентрический массив – колесо готово!
                        iCircularCopy.Create();
                    }
                }
            }
        }
        /// <summary>
        /// CСоздание резьбы на ножке
        /// </summary>
        /// <param name="diameterLeg">Диаметр ножки</param>
        /// <param name="lengthLeg">Длина ножки</param>
        /// <param name="diameterBracing">Диаметр крепления</param>
        /// <param name="lengthHead">Длина головки</param>
        private void BuildThreadLeg(double diameterLeg, double lengthLeg, double diameterBracing, double lengthHead)
        {
            #region Константы для резьбы
            const int part            = -1;
            const int planeOffset     = 14;
            const int sketch          = 5;
            const int planeXOY        = 1;
            const int cylindricspiral = 56;
            const int cutEvolution    = 47;
            const int planeXOZ        = 2;
            #endregion

            //Смещенеие плоскости
            _part = _doc3D.GetPart(part);
            ksEntity entityOffset = _part.NewEntity(planeOffset);
            ksPlaneOffsetDefinition planeDefinition = entityOffset.GetDefinition();
            planeDefinition.offset    = lengthHead;
            planeDefinition.direction = true;
            ksEntity EntityPlaneOffset = _part.GetDefaultEntity(planeXOY);
            planeDefinition.SetPlane(EntityPlaneOffset);
            entityOffset.Create();

            //Построение спирали
            ksEntity entityCylinderic = _part.NewEntity(cylindricspiral);
            ksCylindricSpiralDefinition cylindricSpiral = entityCylinderic.GetDefinition();
            cylindricSpiral.SetPlane(entityOffset);
            cylindricSpiral.buildDir   = true;
            cylindricSpiral.buildMode  = 1;
            cylindricSpiral.height     = lengthLeg;
            cylindricSpiral.diam       = diameterLeg;
            cylindricSpiral.firstAngle = 0;
            cylindricSpiral.turnDir    = true;
            cylindricSpiral.step       = 0.5;
            entityCylinderic.Create();

            //Эскиз треуголника
            ksEntity           Entity2          = _part.NewEntity(sketch);
            ksSketchDefinition sketchDefinition = Entity2.GetDefinition();
            ksEntity           Entity           = _part.GetDefaultEntity(planeXOZ);
            sketchDefinition.SetPlane(Entity);
            Entity2.Create();

            Document2D document2D = sketchDefinition.BeginEdit();
            var        StartX     = diameterLeg / 2 - (diameterLeg / 100); //
            var        StartY     = -0.5 / 2 + 0.01;
            document2D.ksLineSeg(StartX, -lengthHead, diameterLeg - StartX, -lengthHead + StartY, 1);
            document2D.ksLineSeg(StartX, -lengthHead, diameterLeg - StartX, -lengthHead - StartY, 1);
            document2D.ksLineSeg(diameterLeg - StartX, -lengthHead + StartY, diameterLeg - StartX, -lengthHead - StartY, 1);
            sketchDefinition.EndEdit();

            //Кинематическое вырезание
            ksEntity entityCutEvolution = _part.NewEntity(cutEvolution);
            ksCutEvolutionDefinition cutEvolutionDefinition = entityCutEvolution.GetDefinition();
            cutEvolutionDefinition.cut             = true;
            cutEvolutionDefinition.sketchShiftType = 1;
            cutEvolutionDefinition.SetSketch(sketchDefinition);
            ksEntityCollection EntityCollection = (cutEvolutionDefinition.PathPartArray());
            EntityCollection.Clear();
            EntityCollection.Add(entityCylinderic);
            entityCutEvolution.Create();
        }