Example #1
0
        /// <summary>
        /// Метод выполняет операцию вырезать выдавливанием для
        /// последнего созданного эскиза
        /// </summary>
        /// <param name="depth">Глубина выдавливания</param>
        public bool CutExtrusion(double depth)
        {
            try
            {
                ksEntityCollection coll = (ksEntityCollection)_app.Part.EntityCollection((short)Obj3dType.o3d_sketch);
                int      i             = coll.GetCount();
                ksEntity sketch        = coll.GetByIndex(i - 1);
                ksEntity entityCutExtr = (ksEntity)_app.Part.NewEntity((short)Obj3dType.o3d_cutExtrusion);
                if (entityCutExtr != null)
                {
                    ksCutExtrusionDefinition extrusionDef = (ksCutExtrusionDefinition)entityCutExtr.GetDefinition();
                    if (extrusionDef != null)
                    {
                        extrusionDef.directionType = (short)Direction_Type.dtMiddlePlane;
                    }
                    extrusionDef.SetSideParam(true, (short)End_Type.etBlind, depth, 0, false);

                    extrusionDef.SetSketch(sketch);
                    entityCutExtr.Create();
                    entityCutExtr.Update();
                }
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Example #2
0
        /// <summary>
        /// Создать паз
        /// </summary>
        /// <param name="shim">Параметры шайбы</param>
        /// <param name="part">Компонент сборки</param>
        private void CreateGroove(ShimSettings shim, ksPart part)
        {
            // Создаем эскиз для паза

            ksEntity           sketchGroove;
            ksSketchDefinition sketchGrooveDefinition;

            CreateSketch(part, out sketchGroove, out sketchGrooveDefinition,
                         (short)Obj3dType.o3d_planeXOZ);


            // Рисуем паз на эскизе

            ksDocument2D GrooveEdit = sketchGrooveDefinition.BeginEdit();

            GrooveEdit.ksCircle(shim.InnerRadius, 0, shim.GrooveRadius, 1);
            sketchGrooveDefinition.EndEdit();

            // Вырезаем паз

            ksEntity cutGrooveExtrude =
                part.NewEntity((short)Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition cutGrooveExtrudeDefinition =
                cutGrooveExtrude.GetDefinition();

            cutGrooveExtrudeDefinition.directionType =
                (short)Direction_Type.dtBoth;
            cutGrooveExtrudeDefinition.SetSketch(sketchGroove);
            ksExtrusionParam cutGrooveExtrudeParam =
                cutGrooveExtrudeDefinition.ExtrusionParam();

            cutGrooveExtrudeParam.depthNormal  = shim.Height;
            cutGrooveExtrudeParam.depthReverse = shim.Height;
            cutGrooveExtrude.Create();
        }
Example #3
0
 ///<summary>
 /// Создание отверстия в кадле
 ///</summary>
 private void CreateHoleInKadlo(double kadloHeight, bool circle, bool square, bool triangle, double radiusHole, double squareSide, double triangleSide)
 {
     if (_part != null)
     {
         // интерфейс свойств эскиза
         ksEntity holeInKadlo = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
         if (holeInKadlo != null)
         {
             // Получение интерфейса свойств эскиза
             ksSketchDefinition holeSketch = (ksSketchDefinition)holeInKadlo.GetDefinition();
             if (holeSketch != null)
             {
                 ksEntity basePlane;
                 // Получение интерфейса базовой плоскости XOZ
                 basePlane = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOZ);
                 // установим плоскость базовой для эскиза
                 holeSketch.SetPlane(basePlane);
                 // создадим эскиз
                 holeInKadlo.Create();
                 // интерфейс редактора эскиза
                 ksDocument2D sketchEdit = (ksDocument2D)holeSketch.BeginEdit();
                 //КРУГ
                 if (circle == true)
                 {
                     sketchEdit.ksCircle(1, -kadloHeight / 2, radiusHole, 1);
                 }
                 if (square == true)
                 {
                     sketchEdit.ksLineSeg(1 - squareSide / 2, -kadloHeight / 2 - squareSide / 2, 1 - squareSide / 2, -kadloHeight / 2 + squareSide / 2, 1);
                     sketchEdit.ksLineSeg(1 - squareSide / 2, -kadloHeight / 2 + squareSide / 2, 1 + squareSide / 2, -kadloHeight / 2 + squareSide / 2, 1);
                     sketchEdit.ksLineSeg(1 + squareSide / 2, -kadloHeight / 2 + squareSide / 2, 1 + squareSide / 2, -kadloHeight / 2 - squareSide / 2, 1);
                     sketchEdit.ksLineSeg(1 + squareSide / 2, -kadloHeight / 2 - squareSide / 2, 1 - squareSide / 2, -kadloHeight / 2 - squareSide / 2, 1);
                 }
                 //ТРЕУГОЛЬНИК
                 if (triangle == true)
                 {
                     var triangleHeight = Math.Sqrt(3) / 2 * triangleSide;
                     sketchEdit.ksLineSeg(1, -kadloHeight / 2, 1 - triangleSide / 2, -kadloHeight / 2 + triangleHeight, 1);
                     sketchEdit.ksLineSeg(1 - triangleSide / 2, -kadloHeight / 2 + triangleHeight, 1 + triangleSide / 2, -kadloHeight / 2 + triangleHeight, 1);
                     sketchEdit.ksLineSeg(1 + triangleSide / 2, -kadloHeight / 2 + triangleHeight, 1, -kadloHeight / 2, 1);
                 }
                 // завершение редактирования эскиза
                 holeSketch.EndEdit();
                 ksEntity entityHoleCutExtr = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_cutExtrusion);
                 if (entityHoleCutExtr != null)
                 {
                     ksCutExtrusionDefinition cutExtrDef = (ksCutExtrusionDefinition)entityHoleCutExtr.GetDefinition();
                     if (cutExtrDef != null)
                     {
                         cutExtrDef.cut           = true;
                         cutExtrDef.directionType = (short)Direction_Type.dtNormal;
                         cutExtrDef.SetSideParam(true, (short)End_Type.etThroughAll);
                         cutExtrDef.SetSketch(holeSketch);
                         entityHoleCutExtr.Create();
                     }
                 }
             }
         }
     }
 }
        /// <summary>
        /// Метод, выполняющий вырезание выдавливанием по эскизу
        /// </summary>
        /// <param name="part">Интерфейс компонента</param>
        /// <param name="sketch">Эскиз</param>
        /// <param name="topHeight">Высота вырезания вверх</param>
        /// <param name="bottomHeight">Высота вырезания вниз</param>
        /// <param name="type">Тип выдавливания</param>
        private void CutExtrusion(ksPart part, ksEntity sketch,
                                  double topHeight, double bottomHeight, bool type)
        {
            ksEntity entityCutExtrusion = (ksEntity)part.NewEntity((short)
                                                                   Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition cutExtrusionDefinition =
                (ksCutExtrusionDefinition)entityCutExtrusion.GetDefinition();

            if (type == false)
            {
                cutExtrusionDefinition.directionType = (short)Direction_Type.
                                                       dtNormal;
                cutExtrusionDefinition.SetSideParam(true, (short)End_Type.
                                                    etBlind, topHeight);
            }
            if (type == true)
            {
                cutExtrusionDefinition.directionType = (short)Direction_Type.
                                                       dtBoth;
                cutExtrusionDefinition.SetSideParam(true, (short)End_Type.
                                                    etBlind, topHeight);
                cutExtrusionDefinition.SetSideParam(false, (short)End_Type.
                                                    etBlind, bottomHeight);
            }
            cutExtrusionDefinition.SetSketch(sketch);
            entityCutExtrusion.Create();
        }
        /// <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();
        }
Example #6
0
 ///<summary>
 /// Создание отверситий в нижнем ободе
 ///</summary>
 private void CreateHolesInRim(double kadloHeight, double rimCenter, int numberMounting)
 {
     if (_part != null)
     {
         // интерфейс свойств эскиза
         ksEntity rimHoles = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
         if (rimHoles != null)
         {
             // Получение интерфейса свойств эскиза
             ksSketchDefinition rimSketch = (ksSketchDefinition)rimHoles.GetDefinition();
             if (rimSketch != null)
             {
                 ksEntity basePlane;
                 // Получение интерфейса базовой плоскости XOY
                 basePlane = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                 // установим плоскость базовой для эскиза
                 rimSketch.SetPlane(basePlane);
                 // создадим эскиз
                 rimHoles.Create();
                 // интерфейс редактора эскиза
                 ksDocument2D sketchEdit = (ksDocument2D)rimSketch.BeginEdit();
                 int          i          = 1;
                 for (double phi = 0; phi < 2 * Math.PI; phi += 2 * Math.PI / numberMounting)
                 {
                     double x = rimCenter * Math.Cos(phi);
                     double y = rimCenter * Math.Sin(phi);
                     //круглое отверстие
                     sketchEdit.ksCircle(x, y, 2.5, 1);
                     if (i < numberMounting)
                     {
                         i++;
                     }
                     else
                     {
                         break;
                     }
                 }
                 // завершение редактирования эскиза
                 rimSketch.EndEdit();
                 // вырежим выдавливанием
                 ksEntity entityCutExtr = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_cutExtrusion);
                 if (entityCutExtr != null)
                 {
                     ksCutExtrusionDefinition cutExtrDef = (ksCutExtrusionDefinition)entityCutExtr.GetDefinition();
                     if (cutExtrDef != null)
                     {
                         cutExtrDef.cut           = true;
                         cutExtrDef.directionType = (short)Direction_Type.dtNormal;
                         cutExtrDef.SetSideParam(true, (short)End_Type.etThroughAll);
                         cutExtrDef.SetSketch(rimSketch);
                         entityCutExtr.Create();
                     }
                 }
             }
         }
     }
 }
Example #7
0
        /// <summary>
        /// Выдавливание вырезанием
        /// </summary>
        /// <param name=""="name"></param>
        /// <param name="ksEntityExtrusion"></param>
        /// <param name="ksEntityDrawTwo"></param>
        private void ExstrusionCut(string name, ksEntity ksEntityExtrusion, ksEntity ksEntityDrawTwo)
        {
            ksCutExtrusionDefinition _ksCutExtrusionDefinition = (ksCutExtrusionDefinition)ksEntityExtrusion.GetDefinition();

            _ksCutExtrusionDefinition.SetSideParam(true, (short)End_Type.etBlind, 10, 0, true);
            _ksCutExtrusionDefinition.SetSketch(ksEntityDrawTwo);
            ksEntityExtrusion.name     = name;
            ksEntityExtrusion.useColor = 0;
            ksEntityExtrusion.SetAdvancedColor(0, 0.9, 0.8, 0.7, 0.6, 1, 0.4);
            ksEntityExtrusion.Create();
        }
        /// <summary>
        /// Создане выреза крепления
        /// </summary>
        /// <param name="diameterBracing">Диаметр крепления</param>
        /// <param name="lengthBracing">Длина крепления</param>
        /// <param name="lengthLeg">Длина ножки</param>
        /// <param name="lengthHead">Длина головки</param>
        private void BuildBracingCut(double diameterBracing, double lengthBracing, double lengthLeg, double lengthHead)
        {
            #region Константы для выреза крепления
            const int part           = -1;
            const int sketch         = 5;
            const int planeXOY       = 1;
            const int planeOffset    = 14;
            const int rectangleParam = 91;
            const int shaded         = 3;
            const int etBlind        = 0;
            const int cutExtrusion   = 26;
            #endregion

            _part = _doc3D.GetPart(part);
            ksEntity EntityPlane = _part.GetDefaultEntity(planeXOY);

            //Смещение плоскости
            ksEntity PlaneOffSet = _part.NewEntity(planeOffset);
            ksPlaneOffsetDefinition planeOffDefinition = PlaneOffSet.GetDefinition();
            planeOffDefinition.direction = true;
            planeOffDefinition.offset    = lengthLeg + lengthHead + lengthBracing;
            planeOffDefinition.SetPlane(EntityPlane);
            PlaneOffSet.Create();

            //Эскиз
            ksEntity           EntityRectangle           = _part.NewEntity(sketch);
            ksSketchDefinition sketchDefinitionRectangle = EntityRectangle.GetDefinition();
            sketchDefinitionRectangle.SetPlane(PlaneOffSet);
            EntityRectangle.Create();
            ksDocument2D     Document2 = sketchDefinitionRectangle.BeginEdit();
            ksRectangleParam _par;
            _par        = _kompas.GetParamStruct(rectangleParam);
            _par.height = diameterBracing / 2;
            _par.width  = diameterBracing;
            _par.x      = -(diameterBracing / 2);
            _par.y      = -(diameterBracing / 4);
            _par.ang    = 0;
            _par.style  = 1;
            Document2.ksRectangle(_par, 0);
            sketchDefinitionRectangle.EndEdit();

            //Вырезание
            ksEntity EntityCutExtrusion = _part.NewEntity(cutExtrusion);
            ksCutExtrusionDefinition CutExtrusionDefinition = EntityCutExtrusion.GetDefinition();
            CutExtrusionDefinition.cut           = true;
            CutExtrusionDefinition.directionType = 0;
            CutExtrusionDefinition.SetSideParam(true, etBlind, lengthBracing / 2, 0, false);
            CutExtrusionDefinition.SetSketch(EntityRectangle);
            EntityCutExtrusion.Create();
            _doc3D.drawMode        = shaded;
            _doc3D.shadedWireframe = true;
        }
Example #9
0
        /// <summary>
        /// Вырезание
        /// </summary>
        /// <param name="part"></param>
        /// <param name="sketch"></param>
        /// <param name="heigth"></param>
        private static void Cut(ksPart part,
                                ksEntity sketch, double heigth)
        {
            ksEntity cutExtrude = part.NewEntity((short)
                                                 Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition cutextrDef = cutExtrude.GetDefinition();

            cutextrDef.directionType = (short)Direction_Type.dtNormal;
            cutextrDef.SetSketch(sketch);
            ksExtrusionParam cutExtrParam = cutextrDef.ExtrusionParam();

            cutExtrParam.depthNormal = heigth;
            cutExtrude.Create();
        }
Example #10
0
        /// <summary>
        /// Обычный вырез
        /// </summary>
        /// <param name="part">Компонент сборки</param>
        /// <param name="sketch">Вырезаемый эскиз</param>
        /// <param name="depth">Глубина выреза</param>
        protected void CutExtrude(ksPart part, ksEntity sketch,
                                  double depth)
        {
            ksEntity cutExtrude =
                part.NewEntity((short)Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition cutextrDefinition =
                cutExtrude.GetDefinition();

            cutextrDefinition.directionType =
                (short)Direction_Type.dtNormal;
            cutextrDefinition.SetSketch(sketch);
            ksExtrusionParam cutExtrudeParam =
                cutextrDefinition.ExtrusionParam();

            cutExtrudeParam.depthNormal = depth;
            cutExtrude.Create();
        }
        /// <summary>
        /// Создание отверстия крепления
        /// </summary>
        /// <param name="diameterBracing">Диаметр крепления</param>
        /// <param name="lengthBracing">Длина крепления</param>
        /// <param name="lengthLeg">Длина ножки</param>
        /// <param name="lengthHead">Длина головки</param>
        private void BuildBracingHole(double diameterBracing, double lengthBracing, double lengthLeg, double lengthHead)
        {
            #region Константы отверстия крепления
            const int part         = -1;
            const int sketch       = 5;
            const int planeXOY     = 1;
            const int planeOffset  = 14;
            const int shaded       = 3;
            const int etBlind      = 0;
            const int planeXOZ     = 2;
            const int cutExtrusion = 26;
            #endregion

            ksEntity EntityPlane = _part.GetDefaultEntity(planeXOY);
            _part = _doc3D.GetPart(part);
            ksEntity EntityPlane3 = _part.GetDefaultEntity(planeXOZ);

            //Смещение плоскости
            ksEntity PlaneOffHole = _part.NewEntity(planeOffset);
            ksPlaneOffsetDefinition planeOffsetDefinitionHole = PlaneOffHole.GetDefinition();
            planeOffsetDefinitionHole.direction = true;
            planeOffsetDefinitionHole.offset    = diameterBracing / 2;
            planeOffsetDefinitionHole.SetPlane(EntityPlane3);
            PlaneOffHole.Create();

            //Эскиз отверстия крепения
            ksEntity           EntityHole           = _part.NewEntity(sketch);
            ksSketchDefinition sketchDefinitionHole = EntityHole.GetDefinition();
            sketchDefinitionHole.SetPlane(PlaneOffHole);
            EntityHole.Create();
            ksDocument2D DocumentHole = sketchDefinitionHole.BeginEdit();
            DocumentHole.ksCircle(0, -(0.75 * lengthBracing + lengthLeg + lengthHead), diameterBracing / 6, 1);
            sketchDefinitionHole.EndEdit();

            //Выдавливание отверстия крепления
            ksEntity EntityCutExtrusionHole = _part.NewEntity(cutExtrusion);
            ksCutExtrusionDefinition CutExtrusionDefinitionHole = EntityCutExtrusionHole.GetDefinition();
            CutExtrusionDefinitionHole.cut           = true;
            CutExtrusionDefinitionHole.directionType = 0;
            CutExtrusionDefinitionHole.SetSideParam(true, etBlind, diameterBracing, 0, false);
            CutExtrusionDefinitionHole.SetSketch(EntityHole);
            EntityCutExtrusionHole.Create();
            _doc3D.drawMode        = shaded;
            _doc3D.shadedWireframe = true;
        }
Example #12
0
        /// <summary>
        /// Выдавливание вырезанием
        /// </summary>
        /// <param name="ksEntity"></param>
        /// <param name="name">Имя</param>
        private void CreatExtrusionOffsetCutMethod
            (ksEntity ksEntity, string name)
        {
            ksEntity ksEntityBossExtrusionn;

            ksEntityBossExtrusionn =
                _ksPart.NewEntity((short)Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition ksBossExtrusionDefinition =
                (ksCutExtrusionDefinition)ksEntityBossExtrusionn.
                GetDefinition();

            ksBossExtrusionDefinition.SetSideParam(false,
                                                   (short)End_Type.etBlind, mouseSetting.
                                                   HeightOfTheSecondMouseProperty, 2, false);
            ksBossExtrusionDefinition.SetSketch(ksEntity);
            ksEntityBossExtrusionn.name = name;
            ksEntityBossExtrusionn.Create();
        }
Example #13
0
        /// <summary>
        /// Выдавливание вырезанием
        /// </summary>
        /// <param name="name">Название операции</param>
        /// <param name="ksEntityExtrusion">выдавливание</param>
        /// <param name="ksEntityDrawTwo">эскиз</param>
        /// <param name="size">Длина</param>
        private void ExstrusionCut(string name, ksEntity ksEntityExtrusion,
                                   ksEntity ksEntityDrawTwo, double size)
        {
            double angle = CuttingСorners(_bucket.DiameterOfTheBottom,
                                          _bucket.TheDiameterOfTheThroat, _bucket.TheHeightOfTheBucket);
            int grayColor = 2368548;
            ksCutExtrusionDefinition ksCutExtrusionDefinition =
                (ksCutExtrusionDefinition)ksEntityExtrusion.GetDefinition();

            ksCutExtrusionDefinition.SetSideParam(false,
                                                  (short)End_Type.etBlind,
                                                  size, angle, true);
            ksCutExtrusionDefinition.SetSketch(ksEntityDrawTwo);
            ksEntityExtrusion.name     = name;
            ksEntityExtrusion.useColor = 0;
            ksEntityExtrusion.SetAdvancedColor(grayColor, 0.9, 0.8,
                                               0.7, 0.6, 1, 0.4);
            ksEntityExtrusion.Create();
        }
Example #14
0
        /// <summary>
        /// Выдавливание эскиза
        /// </summary>
        /// <param name="name"></param>
        /// <param name="length"></param>
        /// <param name="ksEntity"></param>
        private void ExtrusionCutSkecth(string name, double length,
                                        ksEntity ksEntity)
        {
            const int grayColor         = 460551;
            ksEntity  ksEntityExtrusion =
                (ksEntity)_ksPart.NewEntity(
                    (short)Obj3dType.o3d_cutExtrusion);
            ksCutExtrusionDefinition ksCutExtrusionDefinition =
                (ksCutExtrusionDefinition)
                ksEntityExtrusion.GetDefinition();

            ksCutExtrusionDefinition.cut           = true;
            ksCutExtrusionDefinition.directionType = 0;
            ksCutExtrusionDefinition.SetSideParam(true,
                                                  (short)End_Type.etBlind,
                                                  length, 0, false);
            ksCutExtrusionDefinition.SetSketch(ksEntity);
            ksEntityExtrusion.name     = name;
            ksEntityExtrusion.useColor = 0;
            ksEntityExtrusion.SetAdvancedColor(grayColor, 0.9, 0.8,
                                               0.7, 0.6, 1, 0.4);
            ksEntityExtrusion.Create();
        }
Example #15
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();
                    }
                }
            }
        }
Example #16
0
        /// <summary>
        /// Выдавливание окружности с вырезом
        /// </summary>
        /// <param name="x1">координата Х центра окружности</param>
        /// <param name="y1">координата У центра окружности</param>
        /// <param name="rad">радиус окружности</param>
        /// <param name="depth">Глубина окружности</param>
        /// <param name="plane">На какой плоскости</param>
        /// <param name="defType"></param>
        /// <param name="chamfer"> </param>
        public void CreateCircleHole(double x1, double y1, double rad, double depth, string plane, string defType)
        {
            var doc  = (ksDocument3D)kompas.ActiveDocument3D();
            var part = (ksPart)doc.GetPart((short)Part_Type.pTop_Part);

            if (part != null)
            {
                // Создаем новый эскиз
                ksEntity entitySketch = (ksEntity)part.NewEntity((short)Obj3dType.o3d_sketch);
                if (entitySketch != null)
                {
                    // интерфейс свойств эскиза
                    ksSketchDefinition sketchDef = (ksSketchDefinition)entitySketch.GetDefinition( );
                    if (sketchDef != null)
                    {
                        // получим интерфейс базовой плоскости
                        ksEntity basePlane;
                        if (plane == "XOY")
                        {
                            basePlane = (ksEntity)part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        }
                        else
                        {
                            basePlane = (ksEntity)part.GetDefaultEntity((short)Obj3dType.o3d_planeXOZ);
                        }
                        sketchDef.SetPlane(basePlane);          // установим плоскость базовой для эскиза
                        entitySketch.Create( );                 // создадим эскиз1

                        // интерфейс редактора эскиза
                        ksDocument2D sketchEdit = (ksDocument2D)sketchDef.BeginEdit( );

                        //круглое отверстие
                        sketchEdit.ksCircle(x1, y1, rad, 1);
                        sketchDef.EndEdit( );   // завершение редактирования эскиза
                        // вырежим выдавливанием

                        ksEntity entityCutExtr = (ksEntity)part.NewEntity((short)Obj3dType.o3d_cutExtrusion);

                        if (entityCutExtr != null)
                        {
                            ksCutExtrusionDefinition cutExtrDef = (ksCutExtrusionDefinition)entityCutExtr.GetDefinition( );

                            if (cutExtrDef != null)
                            {
                                cutExtrDef.cut           = true;
                                cutExtrDef.directionType = (short)Direction_Type.dtReverse;

                                if (defType == "ThroughAll")
                                {
                                    cutExtrDef.SetSideParam(false, (short)End_Type.etThroughAll, depth);
                                }
                                else if (defType == "Blind")
                                {
                                    cutExtrDef.SetSideParam(false, (short)End_Type.etBlind, depth);
                                }

                                cutExtrDef.SetSketch(entitySketch);
                                entityCutExtr.Create( ); // создадим операцию вырезание выдавливанием
                                // CreateChamfer ( "XOZ" );
                                sketchDef.EndEdit( );    // завершение редактирования эскиза
                            }
                        }
                    }
                }
            }
        }
Example #17
0
        /// <summary>
        /// вырез в нижней части цилиндра
        /// </summary>
        /// <param name="param"></param>
        public void FlatPart(Parameters param)
        {
            double Radios1 = param.Radios1;
            double Cut1    = param.Cut1;
            double Cut2    = param.Cut2;
            var    doc     = (ksDocument3D)_kompas.ActiveDocument3D();
            ksPart part3   = (ksPart)doc.GetPart((short)Part_Type.pTop_Part); // новый компонент

            if (part3 != null)
            {
                ksEntity entitySketch3 = (ksEntity)part3.NewEntity((short)Obj3dType.o3d_sketch);
                if (entitySketch3 != null)
                {
                    ksSketchDefinition sketchDef3 = (ksSketchDefinition)entitySketch3.GetDefinition();
                    if (sketchDef3 != null)
                    {
                        ksEntity basePlane = (ksEntity)part3.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        sketchDef3.SetPlane(basePlane); // установим плоскость
                        sketchDef3.angle = 0;
                        entitySketch3.Create();         // создадим эскиз

                        ksDocument2D sketchEdit3 = (ksDocument2D)sketchDef3.BeginEdit();
                        sketchEdit3.ksLineSeg(Radios1, Radios1, -Radios1, Radios1, 1);
                        sketchEdit3.ksLineSeg(Radios1, Cut1, -Radios1, Cut1, 1);
                        sketchEdit3.ksLineSeg(Radios1, Cut1, Radios1, Radios1, 1);
                        sketchEdit3.ksLineSeg(-Radios1, Cut1, -Radios1, Radios1, 1);
                        sketchDef3.EndEdit();   // завершение редактирования эскиза

                        ksEntity entityCutExtr = (ksEntity)part3.NewEntity((short)Obj3dType.o3d_cutExtrusion);
                        if (entityCutExtr != null)
                        {
                            ksCutExtrusionDefinition cutExtrDef = (ksCutExtrusionDefinition)entityCutExtr.GetDefinition();
                            if (cutExtrDef != null)
                            {
                                cutExtrDef.SetSketch(entitySketch3);                        // установим эскиз операции
                                cutExtrDef.directionType = (short)Direction_Type.dtReverse; //прямое направление
                                cutExtrDef.SetSideParam(false, (short)End_Type.etBlind, Cut2, 0, true);
                                cutExtrDef.SetThinParam(false, 0, 0, 0);
                            }
                            entityCutExtr.Create(); // создадим операцию вырезание выдавливанием
                        }
                    }
                }
            }
            ksPart part4 = (ksPart)doc.GetPart((short)Part_Type.pTop_Part);  // новый компонент

            if (part4 != null)
            {
                ksEntity entitySketch4 = (ksEntity)part4.NewEntity((short)Obj3dType.o3d_sketch);
                if (entitySketch4 != null)
                {
                    ksSketchDefinition sketchDef4 = (ksSketchDefinition)entitySketch4.GetDefinition();
                    if (sketchDef4 != null)
                    {
                        ksEntity basePlane = (ksEntity)part4.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        sketchDef4.SetPlane(basePlane); // установим плоскость
                        sketchDef4.angle = 0;
                        entitySketch4.Create();         // создадим эскиз

                        ksDocument2D sketchEdit4 = (ksDocument2D)sketchDef4.BeginEdit();
                        // введем новый эскиз - квадрат
                        sketchEdit4.ksLineSeg(-Radios1, -Radios1, Radios1, -Radios1, 1);
                        sketchEdit4.ksLineSeg(-Radios1, -Cut1, Radios1, -Cut1, 1);
                        sketchEdit4.ksLineSeg(-Radios1, -Cut1, -Radios1, -Radios1, 1);
                        sketchEdit4.ksLineSeg(Radios1, -Cut1, Radios1, -Radios1, 1);
                        sketchDef4.EndEdit();   // завершение редактирования эскиза

                        ksEntity entityCutExtr2 = (ksEntity)part4.NewEntity((short)Obj3dType.o3d_cutExtrusion);
                        if (entityCutExtr2 != null)
                        {
                            ksCutExtrusionDefinition cutExtrDef2 = (ksCutExtrusionDefinition)entityCutExtr2.GetDefinition();
                            if (cutExtrDef2 != null)
                            {
                                cutExtrDef2.SetSketch(entitySketch4);                        // установим эскиз операции
                                cutExtrDef2.directionType = (short)Direction_Type.dtReverse; //прямое направление
                                cutExtrDef2.SetSideParam(false, (short)End_Type.etBlind, Cut2, 0, true);
                                cutExtrDef2.SetThinParam(false, 0, 0, 0);
                            }

                            entityCutExtr2.Create(); // создадим операцию вырезание выдавливанием
                        }
                    }
                }
            }
        }