/// <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();
        }
Esempio n. 2
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);
        }
Esempio n. 3
0
 /// <summary>
 /// Рисует окружность.
 /// </summary>
 /// <param name="sketchEdit">Эскиз для рисования.</param>
 public void DrawCircle(ksDocument2D sketchEdit)
 {
     foreach (PointF center in PointsList)
     {
         sketchEdit.ksCircle(center.X, center.Y, Radius, 1);
     }
 }
Esempio n. 4
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();
        }
        /// <summary>
        /// Создание головки
        /// </summary>
        /// <param name="diameterHead">Диаметр головки </param>
        /// <param name="lengthHead">Длина головки </param>
        private void BuildHead(double diameterHead, double lengthHead)
        {
            #region Константы для головки
            const int part          = -1;
            const int sketch        = 5;
            const int planeXOY      = 1;
            const int baseExtrusion = 24;
            const int shaded        = 3;
            const int etBlind       = 0;
            #endregion

            //Эскиз головки
            _part   = _doc3D.GetPart(part);
            _entity = _part.NewEntity(sketch);
            ksSketchDefinition SketchDefinition = _entity.GetDefinition();
            ksEntity           EntityPlane      = _part.GetDefaultEntity(planeXOY);
            SketchDefinition.SetPlane(EntityPlane);
            _entity.Create();
            ksDocument2D Document2D = SketchDefinition.BeginEdit();
            Document2D.ksCircle(0, 0, diameterHead / 2, 1);
            SketchDefinition.EndEdit();

            //Выдавливание головки
            ksEntity EntityExtrusion = _part.NewEntity(baseExtrusion);
            ksBaseExtrusionDefinition BaseExtrusionDefinition = EntityExtrusion.GetDefinition();
            BaseExtrusionDefinition.SetSideParam(true, etBlind, lengthHead, 0, true);
            BaseExtrusionDefinition.SetSketch(_entity);
            EntityExtrusion.Create();
            _doc3D.drawMode        = shaded;
            _doc3D.shadedWireframe = true;
        }
Esempio n. 6
0
 /// <summary>
 /// Построение гладкой части
 /// </summary>
 private void CreateConnector(ksPart iPatr)
 {
     if (_modelelParameters.Parameter(ParametersName.ConnectionLength).Value != 0)
     {
         //Получаем интерфейс базовой плоскости ХОY
         ksEntity planeZOY =
             (ksEntity)iPatr.GetDefaultEntity((short)Obj3dType.o3d_planeXOZ);
         //Создаем новый эскиз
         ksEntity iSketch =
             (ksEntity)iPatr.NewEntity((short)Obj3dType.o3d_sketch);
         //Получаем интерфейс свойств эскиза
         ksSketchDefinition iDefinitionSketch = (ksSketchDefinition)iSketch.GetDefinition();
         //Устанавливаем плоскость эскиза
         iDefinitionSketch.SetPlane(planeZOY);
         //Создание эскиза
         iSketch.Create();
         //Создание нового 2Д документа
         ksDocument2D iDocument2D = (ksDocument2D)iDefinitionSketch.BeginEdit();
         //Получение радиуса рукояти
         var rad = _modelelParameters.Parameter(ParametersName.HandleRadius).Value;
         //Построение круга
         iDocument2D.ksCircle(0, 0, rad + 0.1, 1);
         //Создание эскиза
         iDefinitionSketch.EndEdit();
         //Получение глубины выдавливания
         var depth = _modelelParameters.Parameter(ParametersName.ConnectionLength).Value / 2;
         //Выдавливание в обе стороны
         ExctrusionSketch(iPatr, iSketch, depth, false);
         ExctrusionSketch(iPatr, iSketch, depth, true);
     }
 }
Esempio n. 7
0
        /// <summary>
        /// Добавление элементов на полотно двери
        /// </summary>
        /// <param name="doorParameters"></param>
        /// <param name="doorPart"></param>
        /// <param name="planeXoY"></param>
        private void DoorModification(DoorParameters doorParameters,
                                      ksPart doorPart, ksEntity planeXoY)
        {
            ksEntity eyePlaneOffset = doorPart.NewEntity((short)
                                                         Obj3dType.o3d_planeOffset);
            ksPlaneOffsetDefinition eyeDefinition =
                eyePlaneOffset.GetDefinition();

            eyeDefinition.SetPlane(planeXoY);
            eyeDefinition.offset = doorParameters.WeigthDoor;
            eyePlaneOffset.Create();
            ksEntity eyeSketch = doorPart.NewEntity((short)
                                                    Obj3dType.o3d_sketch);
            ksSketchDefinition eyeSketchDefinition =
                eyeSketch.GetDefinition();

            eyeSketchDefinition.SetPlane(eyePlaneOffset);
            eyeSketch.Create();
            ksDocument2D eye = eyeSketchDefinition.BeginEdit();

            eye.ksCircle(doorParameters.YEye / 2.0, 0, 15, 1);
            eyeSketchDefinition.EndEdit();
            Cut(doorPart, eyeSketch, doorParameters.WeigthDoor);
            AnimalDoor(doorParameters, doorPart, eyePlaneOffset);
            DoorKnob(doorParameters, doorPart, eyePlaneOffset);
        }
Esempio n. 8
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();
                     }
                 }
             }
         }
     }
 }
Esempio n. 9
0
        /// <summary>
        /// Метод, создающий эскиз вырезов на передней части ручки
        /// </summary>
        private void CreateNotchSketch()
        {
            CreateEntitySketch((short)Obj3dType.o3d_planeXOY);

            _sketchEdit = (ksDocument2D)_sketchDefinition.BeginEdit();
            _sketchEdit.ksCircle(0, 40, 19, 1);
            _sketchDefinition.EndEdit();
        }
Esempio n. 10
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();
                     }
                 }
             }
         }
     }
 }
Esempio n. 11
0
        /// <summary>
        /// построение среднего цилиндра детали
        /// </summary>
        /// <param name="param"></param>
        public void MiddleCircle(Parameters param)
        {
            double Radios1 = param.Radios1;
            double Lenght1 = param.Lenght1;
            double Angle2  = param.Angle2;
            var    doc     = (ksDocument3D)_kompas.ActiveDocument3D();
            ksPart part1   = (ksPart)doc.GetPart((short)Part_Type.pTop_Part); // новый компонент

            if (part1 != null)
            {
                ksEntity entityOffsetPlane1 = (ksEntity)part1.NewEntity((short)Obj3dType.o3d_planeOffset);
                ksEntity entitySketch1      = (ksEntity)part1.NewEntity((short)Obj3dType.o3d_sketch);
                if (entityOffsetPlane1 != null)
                {
                    // интерфейс свойств смещенной плоскости
                    ksPlaneOffsetDefinition offsetDef1 = (ksPlaneOffsetDefinition)entityOffsetPlane1.GetDefinition();
                    if (offsetDef1 != null)
                    {
                        offsetDef1.offset = Lenght1;                       // расстояние от базовой плоскости
                        ksEntity basePlane1 = (ksEntity)part1.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        basePlane1.name = "Смещенная плоскость";           // название для плоскости

                        offsetDef1.SetPlane(basePlane1);                   // базовая плоскость
                        entityOffsetPlane1.name   = "Смещенная плоскость"; // имя для смещенной плоскости
                        entityOffsetPlane1.hidden = true;
                        entityOffsetPlane1.Create();                       // создать смещенную плоскость

                        if (entitySketch1 != null)
                        {
                            ksSketchDefinition sketchDef1 = (ksSketchDefinition)entitySketch1.GetDefinition();
                            if (sketchDef1 != null)
                            {
                                sketchDef1.SetPlane(entityOffsetPlane1); // установим плоскость XOY базовой для эскиза
                                entitySketch1.Create();                  // создадим эскиз

                                // интерфейс редактора эскиза
                                ksDocument2D sketchEdit1 = (ksDocument2D)sketchDef1.BeginEdit();
                                sketchEdit1.ksCircle(0, 0, Radios1, 1);
                                sketchDef1.EndEdit();                    // завершение редактирования эскиза
                                ksEntity entityExtr1 = (ksEntity)part1.NewEntity((short)Obj3dType.o3d_baseExtrusion);
                                if (entityExtr1 != null)
                                {
                                    ksBaseExtrusionDefinition extrusionDef1 = (ksBaseExtrusionDefinition)entityExtr1.GetDefinition();
                                    if (extrusionDef1 != null)
                                    {
                                        extrusionDef1.directionType = (short)Direction_Type.dtNormal;
                                        extrusionDef1.SetSideParam(true, (short)End_Type.etBlind, 5, Angle2, true);
                                        extrusionDef1.SetSketch(entitySketch1);  // эскиз операции выдавливания
                                        entityExtr1.Create();                    // создать операцию
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 12
0
        /// <summary>
        /// построение верхней части цилиндра
        /// </summary>
        /// <param name="param"></param>
        public void UpCircle(Parameters param)
        {
            double Radios2 = param.Radios2;
            double Lenght1 = param.Lenght1;
            double Lenght2 = param.Lenght2;
            var    doc     = (ksDocument3D)_kompas.ActiveDocument3D();
            ksPart part2   = (ksPart)doc.GetPart((short)Part_Type.pTop_Part); // новый компонент

            if (part2 != null)
            {
                ksEntity entityOffsetPlane2 = (ksEntity)part2.NewEntity((short)Obj3dType.o3d_planeOffset);
                ksEntity entitySketch2      = (ksEntity)part2.NewEntity((short)Obj3dType.o3d_sketch);
                if (entityOffsetPlane2 != null)
                {
                    ksPlaneOffsetDefinition offsetDef2 = (ksPlaneOffsetDefinition)entityOffsetPlane2.GetDefinition();
                    if (offsetDef2 != null)
                    {
                        offsetDef2.offset = Lenght1 + 5;                   // расстояние от базовой плоскости
                        ksEntity basePlane2 = (ksEntity)part2.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        basePlane2.name = "Смещенная плоскость";           // название для плоскости

                        offsetDef2.SetPlane(basePlane2);                   // базовая плоскость
                        entityOffsetPlane2.name   = "Смещенная плоскость"; // имя для смещенной плоскости
                        entityOffsetPlane2.hidden = true;
                        entityOffsetPlane2.Create();                       // создать смещенную плоскость

                        if (entitySketch2 != null)
                        {
                            ksSketchDefinition sketchDef2 = (ksSketchDefinition)entitySketch2.GetDefinition();
                            if (sketchDef2 != null)
                            {
                                sketchDef2.SetPlane(entityOffsetPlane2); // установим плоскость XOY базовой для эскиза
                                entitySketch2.Create();                  // создадим эскиз

                                ksDocument2D sketchEdit2 = (ksDocument2D)sketchDef2.BeginEdit();
                                sketchEdit2.ksCircle(0, 0, Radios2, 1);
                                sketchDef2.EndEdit();                    // завершение редактирования эскиза
                                ksEntity entityExtr2 = (ksEntity)part2.NewEntity((short)Obj3dType.o3d_baseExtrusion);
                                if (entityExtr2 != null)
                                {
                                    ksBaseExtrusionDefinition extrusionDef2 = (ksBaseExtrusionDefinition)entityExtr2.GetDefinition();
                                    if (extrusionDef2 != null)
                                    {
                                        extrusionDef2.directionType = (short)Direction_Type.dtNormal;
                                        extrusionDef2.SetSideParam(true, (short)End_Type.etBlind, Lenght2, 0, false);
                                        extrusionDef2.SetSketch(entitySketch2);  // эскиз операции выдавливания
                                        entityExtr2.Create();                    // создать операцию
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 13
0
 /// <summary>
 /// Нарисовать четырехугольник с непрямыми углами с круглым отверстием
 /// </summary>
 internal void DrawQuadrangleWithRoundHole()
 {
     if (kompas != null)
     {
         kompas.Visible = true;
         ksDocument3D iDocument3D = (ksDocument3D)kompas.Document3D();
         if (iDocument3D.Create(false /*видимый*/, true /*деталь*/))
         {
             iDocument3D.fileName = "With Round Hole";
             ksPart iPart = (ksPart)iDocument3D.GetPart((short)Part_Type.pTop_Part);     // новый компонент (.pNew_Part - был)
             if (iPart != null)
             {
                 //// получим интерфейс базовой плоскости XOY
                 ksEntity planeXOY = (ksEntity)iPart.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);    // 1-интерфейс на плоскость XOY
                 ksEntity iSketch  = (ksEntity)iPart.NewEntity((short)Obj3dType.o3d_sketch);
                 if (iSketch != null)
                 {
                     // интерфейс свойств эскиза
                     ksSketchDefinition iDefinitionSketch = (ksSketchDefinition)iSketch.GetDefinition();
                     if (iDefinitionSketch != null)
                     {
                         iDefinitionSketch.SetPlane(planeXOY);
                         iSketch.Create();
                         ksDocument2D iDocument2D = (ksDocument2D)iDefinitionSketch.BeginEdit();
                         iDocument2D.ksLineSeg(-30.0, -30.0, 30.0, -30.0, 1);
                         iDocument2D.ksLineSeg(30.0, -30.0, 0, 30.0, 1);
                         iDocument2D.ksLineSeg(0, 30.0, -60.0, 30.0, 1);
                         iDocument2D.ksLineSeg(-60.0, 30.0, -30.0, -30.0, 1);
                         iDocument2D.ksCircle(-15, 0, 4, 1);
                         iDefinitionSketch.EndEdit();
                         ksEntity entityExtr = (ksEntity)iPart.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                         if (entityExtr != null)
                         {
                             // интерфейс свойств базовой операции выдавливания
                             ksBossExtrusionDefinition extrusionDef = (ksBossExtrusionDefinition)entityExtr.GetDefinition(); // интерфейс базовой операции выдавливания
                             if (extrusionDef != null)
                             {
                                 ksExtrusionParam extrProp = (ksExtrusionParam)extrusionDef.ExtrusionParam(); // интерфейс структуры параметров выдавливания
                                 if (extrProp != null)
                                 {
                                     extrusionDef.SetSketch(iSketch);                       // эскиз операции выдавливания
                                     extrProp.direction   = (short)Direction_Type.dtNormal; // направление выдавливания (прямое)
                                     extrProp.typeNormal  = (short)End_Type.etBlind;        // тип выдавливания (строго на глубину)
                                     extrProp.depthNormal = 10;                             // глубина выдавливания
                                     entityExtr.Create();                                   // создадим операцию
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 }
Esempio n. 14
0
        // Работа с именованной группой
        private void WorkNameGroup()
        {
            //рабочая группа сущестует  до конца работы функции
            reference gr = doc.ksNewGroup(0);
            reference p  = doc.ksLineSeg(20, 20, 40, 20, 1);

            doc.ksLineSeg(40, 20, 40, 40, 1);
            doc.ksLineSeg(40, 40, 20, 40, 1);
            doc.ksLineSeg(20, 40, 20, 20, 1);
            doc.ksEndGroup();

            //рабочую группу сохраняем в именной
            //именная группа хранится в документе и
            if (doc.ksSaveGroup(gr, "group1") != 1)
            {
                return;
            }
            reference gr1 = doc.ksGetGroup("group1");

            if (gr1 == 0)
            {
                return;
            }

            reference c = doc.ksCircle(30, 30, 10, 1);

            doc.ksAddObjGroup(gr1, c);

            doc.ksLightObj(gr1, 1);
            kompas.ksMessage("добавили объект в именную группу");
            doc.ksLightObj(gr1, 0);

            doc.ksExcludeObjGroup(gr1, p);

            doc.ksLightObj(gr1, 1);
            kompas.ksMessage("исключили объект из именной группы");
            doc.ksLightObj(gr1, 0);
        }
Esempio n. 15
0
 /// <summary>
 /// Метод создает эскиз окружности
 /// </summary>
 /// <param name="coor">Координаты центра окружности</param>
 /// <param name="radius">Радиус окружности</param>
 /// <param name="lineType">Тип линии</param>
 /// <returns></returns>
 public bool DrawCircle(Point coor, double radius, int lineType)
 {
     try
     {
         SketchCreator      sketchCreator = new SketchCreator(_app);
         ksSketchDefinition def           = sketchCreator.MakeSketch();
         ksDocument2D       doc           = (ksDocument2D)def.BeginEdit();
         doc.ksCircle(coor.X, coor.Y, radius, lineType);
         def.EndEdit();
         return(true);
     }
     catch
     {
         return(false);
     }
 }
        /// <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;
        }
Esempio n. 17
0
        /// <summary>
        /// построение нижнего целиндра детали
        /// </summary>
        /// <param name="param"></param>
        public void DownCircle(Parameters param)
        {
            double Radios1  = param.Radios1;
            double Lenght1  = param.Lenght1;
            var    document = (ksDocument3D)_kompas.Document3D();

            document.Create();
            var    doc  = (ksDocument3D)_kompas.ActiveDocument3D();
            ksPart 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 = (ksEntity)part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        sketchDef.SetPlane(basePlane);
                        entitySketch.Create();

                        ksDocument2D sketchEdit = (ksDocument2D)sketchDef.BeginEdit();
                        sketchEdit.ksCircle(0, 0, Radios1, 1);
                        sketchDef.EndEdit();

                        ksEntity entityExtr = (ksEntity)part.NewEntity((short)Obj3dType.o3d_baseExtrusion);
                        if (entityExtr != null)
                        {
                            ksBaseExtrusionDefinition extrusionDef = (ksBaseExtrusionDefinition)entityExtr.GetDefinition();
                            if (extrusionDef != null)
                            {
                                extrusionDef.directionType = (short)Direction_Type.dtNormal;
                                extrusionDef.SetSideParam(true, (short)End_Type.etBlind, Lenght1, 0, false);
                                extrusionDef.SetSketch(entitySketch);       // эскиз операции выдавливания
                                entityExtr.Create();                        // создать операцию
                            }
                        }
                    }
                }
            }
        }
Esempio n. 18
0
            protected override void DrawSketch(ksDocument2D sketchEdit)
            {
                var m  = Model;
                var p1 = Point.Pnt(-m.BladeLength * .8, m.BladeHeight / 2);
                var p2 = Point.Pnt(0, m.BladeHeight / 2);
                var p3 = Point.Pnt(0, m.BladeHeight * .34);
                var p4 = Point.Pnt(m.HandleLength, m.BladeHeight * .1);
                var p5 = Point.Pnt(m.HandleLength, -m.BladeHeight * .1);
                var p6 = Point.Pnt(0, -m.BladeHeight * .34);
                var p7 = Point.Pnt(0, -m.BladeHeight / 2);
                var p8 = Point.Pnt(-m.BladeLength * .8, -m.BladeHeight / 2);
                var p9 = Point.Pnt(-m.BladeLength, m.BladeHeight * .2);

                DrawLine(sketchEdit, p1, p2, p3, p4, p5, p6, p7, p8);
                sketchEdit.ksArcBy3Points(p8.Coordinate1, p8.Coordinate2, p8.Coordinate1 - 1, p8.Coordinate2,
                                          p9.Coordinate1, p9.Coordinate2, 1);
                sketchEdit.ksArcBy3Points(p9.Coordinate1, p9.Coordinate2, p9.Coordinate1 + 1, p9.Coordinate2,
                                          p1.Coordinate1, p1.Coordinate2, 1);
                sketchEdit.ksCircle(m.HandleLength / 2, 0, m.HandleBoreDiameter / 2, 1);
            }
        /// <summary>
        /// Создание крепления
        /// </summary>
        /// <param name="diameterBracing">Диаметр крепления</param>
        /// <param name="lengthBracing">Длина крепления</param>
        /// <param name="lengthLeg">Длина ножки</param>
        /// <param name="lengthHead">Длина головки</param>
        private void BuildBracing(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 baseExtrusion = 24;
            const int shaded        = 3;
            const int etBlind       = 0;
            #endregion

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

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

            //Эскиз крепления
            ksEntity           Entity           = _part.NewEntity(sketch);
            ksSketchDefinition sketchDefinition = Entity.GetDefinition();
            sketchDefinition.SetPlane(PlaneOff);
            Entity.Create();
            ksDocument2D Document2D = sketchDefinition.BeginEdit();
            Document2D.ksCircle(0, 0, diameterBracing / 2, 1);
            sketchDefinition.EndEdit();

            //Выдавливание крепления
            ksEntity EntityExtrusion = _part.NewEntity(baseExtrusion);
            ksBaseExtrusionDefinition BaseExtrusionDefinition = EntityExtrusion.GetDefinition();
            BaseExtrusionDefinition.SetSideParam(true, etBlind, lengthBracing, 0, true);
            BaseExtrusionDefinition.SetSketch(Entity);
            EntityExtrusion.Create();
            _doc3D.drawMode        = shaded;
            _doc3D.shadedWireframe = true;
        }
Esempio n. 20
0
        public void CreateBody(ksPart iPart, KompasObject _kompas, TeaPotParams teaPotParams)
        {
            double   radius = teaPotParams.TeaPotDiameter / 2;
            double   height = teaPotParams.TeaPotHeight;
            ksEntity iSketch;

            ksSketchDefinition iDefinitionSketch;

            CreateSketch(out iSketch, out iDefinitionSketch);

            // Интерфейс для рисования = на скетче;
            ksDocument2D iDocument2D = (ksDocument2D)iDefinitionSketch.BeginEdit();

            iDocument2D.ksCircle(0, 0, radius, 1);

            // Закончить редактировать эскиз
            iDefinitionSketch.EndEdit();
            int X = Convert.ToInt32(teaPotParams.TeaPotBodyColor);

            ExctrusionSketch(iPart, iSketch, height, true, X);
        }
        /// <summary>
        /// Метод, создающий и возвращающий эскиз окружности c заданным
        /// радиусом
        /// </summary>
        /// <param name="part">Интерфейс компонента</param>
        /// <param name="radius">Радиус окружности</param>
        /// <returns></returns>
        private ksEntity DrawCircle(ksPart part, double radius)
        {
            const int coordinateX = 0;
            const int coordinateY = 0;
            const int styleLine   = 1;

            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, radius, styleLine);
            sketchDefinition.EndEdit();

            return(entitySketch);
        }
Esempio n. 22
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);
        }
Esempio n. 23
0
        ///<summary>
        /// Создание ободов
        ///</summary>
        private void CreateRim(double kadloHeight, double thicknessTopDrumhead, double thicknessBottomDrumhead, double rimRadius, double rimWidth, double rimHeight)
        {
            #region Создание смещенной плоскости для верхнего обода

            ksSketchDefinition rimSketch = null;
            // Проверка на существование компонента сборки
            if (_part != null)
            {
                // создадим новый эскиз
                var RimSketch = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                if (RimSketch != null)
                {
                    // Получение интерфейса свойств эскиза
                    rimSketch = (ksSketchDefinition)RimSketch.GetDefinition();
                    if (rimSketch != null)
                    {
                        // Получение интерфейса базовой плоскости XOY
                        var      basePlane1                = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        ksEntity entityOffsetPlane1        = _part.NewEntity((short)Obj3dType.o3d_planeOffset);
                        ksPlaneOffsetDefinition offsetDef1 = (ksPlaneOffsetDefinition)entityOffsetPlane1.GetDefinition();
                        // Высота кадла + толщина пластика+0.1
                        offsetDef1.offset = kadloHeight + thicknessTopDrumhead + 0.1;
                        // Направление смещения
                        offsetDef1.direction = true;
                        offsetDef1.SetPlane(basePlane1);
                        // Создаем смещенную плоскость
                        entityOffsetPlane1.Create();

                        ksEntity _rimSketch = _part.NewEntity((short)Obj3dType.o3d_sketch);

                        var sketchDef3 = (ksSketchDefinition)_rimSketch.GetDefinition();
                        sketchDef3.SetPlane(entityOffsetPlane1);
                        _rimSketch.Create();

                        ksDocument2D sketchEdit3 = (ksDocument2D)sketchDef3.BeginEdit();
                        //рисуем окружность
                        sketchEdit3.ksCircle(0, 0, rimRadius, 1);
                        sketchDef3.EndEdit();

                        #endregion // Создание смещенной плоскости для верхнего обода

                        #region  Выдавливание верхнего обода
                        ksEntity entityBossExtr3 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                        if (entityBossExtr3 != null)
                        {
                            ksBossExtrusionDefinition bossExtrDef3 = (ksBossExtrusionDefinition)entityBossExtr3.GetDefinition();
                            if (bossExtrDef3 != null)
                            {
                                // интерфейс структуры параметров выдавливания
                                ksExtrusionParam extrProp3 = (ksExtrusionParam)bossExtrDef3.ExtrusionParam();
                                // интерфейс структуры параметров тонкой стенки
                                ksThinParam thinProp3 = (ksThinParam)bossExtrDef3.ThinParam();
                                if (extrProp3 != null && thinProp3 != null)
                                {
                                    // эскиз операции выдавливания
                                    bossExtrDef3.SetSketch(_rimSketch);
                                    // направление выдавливания (прямое)
                                    extrProp3.direction = (short)Direction_Type.dtNormal;
                                    // тип выдавливания (строго на глубину)
                                    extrProp3.typeNormal = (short)End_Type.etBlind;
                                    // глубина выдавливания  ВЫСОТА ОБОДА
                                    extrProp3.depthNormal = rimHeight;
                                    thinProp3.thin        = true;
                                    // Толщина стенки в обратном направлении
                                    thinProp3.reverseThickness = rimWidth;
                                    // Направление формирования тонкой стенки
                                    thinProp3.thinType = (short)Direction_Type.dtBoth;
                                    // создадим операцию
                                    entityBossExtr3.Create();
                                }
                            }
                        }
                    }
                    #endregion Выдавливание верхнего обода

                    #region Создание плоскости для нижнего обода
                    ksEntity           entityBossExtr4 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                    ksSketchDefinition rimSketch2      = null;
                    if (entityBossExtr4 != null)
                    {
                        // создадим новый эскиз
                        var RimSketch2 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                        if (RimSketch2 != null)
                        {
                            // Получение интерфейса свойств эскиза
                            rimSketch2 = (ksSketchDefinition)RimSketch2.GetDefinition();

                            if (rimSketch2 != null)
                            {
                                // Получение интерфейса базовой плоскости XOY
                                var      basePlane2                = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                                ksEntity entityOffsetPlane2        = _part.NewEntity((short)Obj3dType.o3d_planeOffset);
                                ksPlaneOffsetDefinition offsetDef1 = (ksPlaneOffsetDefinition)entityOffsetPlane2.GetDefinition();
                                // толщина пластика + 0.1
                                offsetDef1.offset    = thicknessBottomDrumhead + 0.1;
                                offsetDef1.direction = false;
                                offsetDef1.SetPlane(basePlane2);
                                // создаем смещенную плоскость
                                entityOffsetPlane2.Create();

                                ksEntity _rimSketch2 = _part.NewEntity((short)Obj3dType.o3d_sketch);
                                var      sketchDef4  = (ksSketchDefinition)_rimSketch2.GetDefinition();
                                sketchDef4.SetPlane(entityOffsetPlane2);
                                _rimSketch2.Create();

                                ksDocument2D sketchEdit4 = (ksDocument2D)sketchDef4.BeginEdit();
                                //рисуем окружность
                                sketchEdit4.ksCircle(0, 0, rimRadius, 1);
                                sketchDef4.EndEdit();
                                #endregion Создание плоскости для нижнего обода

                                #region Выдавливание нижнего обода
                                ksEntity entityBossExtr5 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                                if (entityBossExtr4 != null)
                                {
                                    ksBossExtrusionDefinition bossExtrDef4 = (ksBossExtrusionDefinition)entityBossExtr4.GetDefinition();
                                    if (bossExtrDef4 != null)
                                    {
                                        // интерфейс структуры параметров выдавливания
                                        ksExtrusionParam extrProp4 = (ksExtrusionParam)bossExtrDef4.ExtrusionParam();
                                        // интерфейс структуры параметров тонкой стенки
                                        ksThinParam thinProp4 = (ksThinParam)bossExtrDef4.ThinParam();
                                        if (extrProp4 != null && thinProp4 != null)
                                        {
                                            // эскиз операции выдавливания
                                            bossExtrDef4.SetSketch(_rimSketch2);
                                            // направление выдавливания (обратное)
                                            extrProp4.direction = (short)Direction_Type.dtReverse;
                                            // тип выдавливания (строго на глубину)
                                            extrProp4.typeReverse = (short)End_Type.etBlind;
                                            // глубина выдавливания  ВЫСОТА ОБОДА
                                            extrProp4.depthReverse = rimHeight;
                                            thinProp4.thin         = true;
                                            // Толщина стенки в обратном направлении
                                            thinProp4.reverseThickness = rimWidth;
                                            // Направление формирования тонкой стенки
                                            thinProp4.thinType = (short)Direction_Type.dtBoth;
                                            // создадим операцию
                                            entityBossExtr4.Create();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 24
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( );    // завершение редактирования эскиза
                            }
                        }
                    }
                }
            }
        }
Esempio n. 25
0
        public void MakeTechnicalDrawings_STUPICA(Stupica stupica)
        {
            double multiply;    // = 0.4;  //масштаб 1:2.5

            if (stupica.D_external <= 30)
            {
                multiply = 5;
            }
            else if (stupica.D_external > 30 && stupica.D_external <= 37.5)
            {
                multiply = 4;
            }
            else if (stupica.D_external > 37.5 && stupica.D_external <= 60)
            {
                multiply = 2.5;
            }
            else if (stupica.D_external > 60 && stupica.D_external <= 75)
            {
                multiply = 2;
            }
            else if (stupica.D_external > 75 && stupica.D_external <= 150)
            {
                multiply = 1;
            }
            else if (stupica.D_external > 150 && stupica.D_external <= 300)
            {
                multiply = 0.5;
            }
            else if (stupica.D_external > 300 && stupica.D_external <= 375)
            {
                multiply = 0.4;
            }
            else if (stupica.D_external > 375 && stupica.D_external <= 600)
            {
                multiply = 0.25;
            }
            else if (stupica.D_external > 600 && stupica.D_external <= 750)
            {
                multiply = 0.2;
            }
            else
            {
                multiply = 1;
            }


            ksDynamicArray arr = (ksDynamicArray)_kompas.GetDynamicArray(ldefin2d.POINT_ARR);
            ksDocument2D   doc = (ksDocument2D)_kompas.Document2D();

            doc = (ksDocument2D)_kompas.Document2D();
            ksDocumentParam docPar  = (ksDocumentParam)_kompas.GetParamStruct((short)StructType2DEnum.ko_DocumentParam);
            ksDocumentParam docPar1 = (ksDocumentParam)_kompas.GetParamStruct((short)StructType2DEnum.ko_DocumentParam);

            if ((docPar != null) & (docPar1 != null))
            {
                // docPar.fileName = @"c:\2.cdw";
                //docPar.comment = "Create document";
                docPar.author = "unbekannte";
                docPar.regime = 0;
                docPar.type   = (short)DocType.lt_DocSheetStandart;
                ksSheetPar shPar = (ksSheetPar)docPar.GetLayoutParam();
                if (shPar != null)
                {
                    shPar.shtType    = 1;
                    shPar.layoutName = string.Empty;
                    ksStandartSheet stPar = (ksStandartSheet)shPar.GetSheetParam();
                    if (stPar != null)
                    {
                        stPar.format   = 3;    //2 - А2, 3 - А3 и тд
                        stPar.multiply = 1;    //кратность формата, увеличивает лист в размерах
                        stPar.direct   = true; //горизонтально
                    }
                }
                // Создали документ: лист, формат А3, горизонтально расположенный
                // и с системным штампом 1
                doc.ksCreateDocument(docPar);

                ksStamp stamp = (ksStamp)doc.GetStamp();
                if (stamp != null)
                {
                    if (stamp.ksOpenStamp() == 1)
                    {
                        stamp.ksColumnNumber(1);
                        Set_into_Stamp(doc, "Ступица фланцевой муфты");
                        stamp.ksColumnNumber(2);
                        Set_into_Stamp(doc, "-");
                        stamp.ksColumnNumber(3);
                        Set_into_Stamp(doc, "СТАЛЬ 35 ГОСТ 1050-2013");
                        stamp.ksColumnNumber(6);
                        string tmp = "";
                        if (multiply >= 1)
                        {
                            tmp = multiply.ToString() + ":1";
                        }
                        else
                        {
                            var M = Math.Round((1 / multiply), 1);
                            tmp = "1:" + M.ToString();
                        }
                        Set_into_Stamp(doc, tmp);
                        stamp.ksColumnNumber(7);
                        Set_into_Stamp(doc, "1");
                        stamp.ksColumnNumber(8);
                        Set_into_Stamp(doc, "3");
                        stamp.ksColumnNumber(9);
                        Set_into_Stamp(doc, "ТулГУ гр. 222131");



                        stamp.ksCloseStamp();
                    }
                }

                int         number = 0;
                ksViewParam parv1  = (ksViewParam)_kompas.GetParamStruct((short)StructType2DEnum.ko_ViewParam);
                if (parv1 != null)
                {
                    number = 1;

                    parv1.Init();
                    parv1.x      = 100;
                    parv1.y      = 150;
                    parv1.scale_ = multiply;
                    parv1.angle  = 0;                                   //угол поворота вида
                    parv1.color  = Color.FromArgb(10, 20, 10).ToArgb(); //цвет вида в активном состоянии
                    parv1.state  = ldefin2d.stACTIVE;
                    parv1.name   = "Вид слева";
                    // У документа создадим вид с номером 1, масштабом 0.5, под углом 45 гр

                    reference v = doc.ksCreateSheetView(parv1, ref number); //создать вид

                    // Создадим слой с номером 3
                    doc.ksLayer(3);

                    //основа
                    doc.ksLineSeg(0, 0,
                                  0, (stupica.D_external / 2 - stupica.b1), 1);            //с середины до верха
                    doc.ksLineSeg(0, (stupica.D_external / 2 - stupica.b1),
                                  (stupica.b1), (stupica.D_external / 2), 1);              //фаска
                    doc.ksLineSeg((stupica.b1), (stupica.D_external / 2),
                                  (stupica.l1 - stupica.b1), (stupica.D_external / 2), 1); //верхняя линия
                    doc.ksLineSeg((stupica.l1 - stupica.b1), (stupica.D_external / 2),
                                  (stupica.l1), (stupica.D_external / 2 - stupica.b1), 1); //faska
                    doc.ksLineSeg((stupica.l1), (stupica.D_external / 2 - stupica.b1),
                                  (stupica.l1), (stupica.d1 / 2 + stupica.R1), 1);         //сверху вниз до скругления
                    doc.ksArcByAngle((stupica.l1 + stupica.R1), (stupica.d1 / 2 + stupica.R1), (stupica.R1),
                                     180, 270, 1, 1);                                      //скругление
                    doc.ksLineSeg((stupica.l1 + stupica.R1), (stupica.d1 / 2),
                                  (stupica.l - stupica.b1), (stupica.d1 / 2), 1);          //линия внешней стороны стакана вправо
                    doc.ksLineSeg((stupica.l - stupica.b1), (stupica.d1 / 2),
                                  (stupica.l), (stupica.d1 / 2 - stupica.b1), 1);          //faska
                    doc.ksLineSeg((stupica.l), (stupica.d1 / 2 - stupica.b1),
                                  (stupica.l), 0, 1);

                    ///////зеркально
                    doc.ksLineSeg(0, 0,
                                  0, -(stupica.D_external / 2 - stupica.b1), 1);            //с середины до верха
                    doc.ksLineSeg(0, -(stupica.D_external / 2 - stupica.b1),
                                  (stupica.b1), -(stupica.D_external / 2), 1);              //фаска
                    doc.ksLineSeg((stupica.b1), -(stupica.D_external / 2),
                                  (stupica.l1 - stupica.b1), -(stupica.D_external / 2), 1); //верхняя линия
                    doc.ksLineSeg((stupica.l1 - stupica.b1), -(stupica.D_external / 2),
                                  (stupica.l1), -(stupica.D_external / 2 - stupica.b1), 1); //faska
                    doc.ksLineSeg((stupica.l1), -(stupica.D_external / 2 - stupica.b1),
                                  (stupica.l1), -(stupica.d1 / 2 + stupica.R1), 1);         //сверху вниз до скругления
                    doc.ksArcByAngle((stupica.l1 + stupica.R1), -(stupica.d1 / 2 + stupica.R1), (stupica.R1),
                                     90, 180, 1, 1);                                        //скругление
                    doc.ksLineSeg((stupica.l1 + stupica.R1), -(stupica.d1 / 2),
                                  (stupica.l - stupica.b1), -(stupica.d1 / 2), 1);          //линия внешней стороны стакана вправо
                    doc.ksLineSeg((stupica.l - stupica.b1), -(stupica.d1 / 2),
                                  (stupica.l), -(stupica.d1 / 2 - stupica.b1), 1);          //faska
                    doc.ksLineSeg((stupica.l), -(stupica.d1 / 2 - stupica.b1),
                                  (stupica.l), 0, 1);


                    //верхнее отверстие под болты
                    doc.ksLineSeg((0), (stupica.D_okr / 2 - stupica.d4 / 2),
                                  (0), (stupica.D_okr / 2 + stupica.d4 / 2), 1);                       //снизу вверх
                    doc.ksLineSeg((0), (stupica.D_okr / 2 + stupica.d4 / 2),
                                  (stupica.l1 - stupica.b2), (stupica.D_okr / 2 + stupica.d4 / 2), 1); //верхняя планка
                    doc.ksLineSeg((stupica.l1 - stupica.b2), (stupica.D_okr / 2 + stupica.d4 / 2),
                                  (stupica.l1 - stupica.b2), (stupica.D_okr / 2 - stupica.d4 / 2), 1); //сверху вниз
                    doc.ksLineSeg((0), (stupica.D_okr / 2 - stupica.d4 / 2),
                                  (stupica.l1 - stupica.b2), (stupica.D_okr / 2 - stupica.d4 / 2), 1); //нижняя планка
                    doc.ksLineSeg((stupica.l1 - stupica.b2), (stupica.D_okr / 2 + stupica.d4 / 2),
                                  (stupica.l1), (stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2), 1); //верхняя фаска
                    doc.ksLineSeg((stupica.l1), (stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2),
                                  (stupica.l1), (stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2), 1); //сверху вниз
                    doc.ksLineSeg((stupica.l1 - stupica.b2), (stupica.D_okr / 2 - stupica.d4 / 2),
                                  (stupica.l1), (stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2), 1); //нижняя фаска

                    //нижнее отверстие под болты
                    doc.ksLineSeg((0), -(stupica.D_okr / 2 - stupica.d4 / 2),
                                  (0), -(stupica.D_okr / 2 + stupica.d4 / 2), 1);                       //снизу вверх
                    doc.ksLineSeg((0), -(stupica.D_okr / 2 + stupica.d4 / 2),
                                  (stupica.l1 - stupica.b2), -(stupica.D_okr / 2 + stupica.d4 / 2), 1); //верхняя планка
                    doc.ksLineSeg((stupica.l1 - stupica.b2), -(stupica.D_okr / 2 + stupica.d4 / 2),
                                  (stupica.l1 - stupica.b2), -(stupica.D_okr / 2 - stupica.d4 / 2), 1); //сверху вниз
                    doc.ksLineSeg((0), -(stupica.D_okr / 2 - stupica.d4 / 2),
                                  (stupica.l1 - stupica.b2), -(stupica.D_okr / 2 - stupica.d4 / 2), 1); //нижняя планка
                    doc.ksLineSeg((stupica.l1 - stupica.b2), -(stupica.D_okr / 2 + stupica.d4 / 2),
                                  (stupica.l1), -(stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2), 1); //верхняя фаска
                    doc.ksLineSeg((stupica.l1), -(stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2),
                                  (stupica.l1), -(stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2), 1); //сверху вниз
                    doc.ksLineSeg((stupica.l1 - stupica.b2), -(stupica.D_okr / 2 - stupica.d4 / 2),
                                  (stupica.l1), -(stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2), 1); //нижняя фаска

                    //внутр кольцо верх
                    doc.ksLineSeg((0), (0),
                                  (0), (stupica.d2 / 2), 1);
                    doc.ksLineSeg((stupica.l2), (0),
                                  (stupica.l2), (stupica.d2 / 2), 1);
                    doc.ksLineSeg((0), (stupica.d2 / 2),
                                  (stupica.l2), (stupica.d2 / 2), 1);

                    //внутр кольцо низ
                    doc.ksLineSeg((0), (0),
                                  (0), -(stupica.d2 / 2), 1);
                    doc.ksLineSeg((stupica.l2), (0),
                                  (stupica.l2), -(stupica.d2 / 2), 1);
                    doc.ksLineSeg((0), -(stupica.d2 / 2),
                                  (stupica.l2), -(stupica.d2 / 2), 1);

                    //осн. отверстие верх
                    doc.ksLineSeg((stupica.l2), (stupica.d / 2),
                                  (stupica.l - stupica.b1), (stupica.d / 2), 1); //
                    doc.ksLineSeg((stupica.l2), (stupica.h - stupica.d / 2),
                                  (stupica.l), (stupica.h - stupica.d / 2), 1);  //
                    doc.ksLineSeg((stupica.l - stupica.b1), (stupica.d / 2),
                                  (stupica.l), (stupica.d / 2 + stupica.b1), 1); //фаска
                    doc.ksLineSeg((stupica.l - stupica.b1), (stupica.d / 2),
                                  (stupica.l - stupica.b1), (0), 1);             //фаска

                    //осн. отверстие низ
                    doc.ksLineSeg((stupica.l2), -(stupica.d / 2),
                                  (stupica.l - stupica.b1), -(stupica.d / 2), 1);
                    doc.ksLineSeg((stupica.l - stupica.b1), -(stupica.d / 2),
                                  (stupica.l), -(stupica.d / 2 + stupica.b1), 1); //фаска
                    doc.ksLineSeg((stupica.l - stupica.b1), -(stupica.d / 2),
                                  (stupica.l - stupica.b1), (0), 1);              //фаска

                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //
                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //
                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //
                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //

                    //освевые
                    doc.ksLineSeg((0) - 5, (0),
                                  (stupica.l) + 5, (0), 3);                   //
                    doc.ksLineSeg((0) - 5, (stupica.D_okr / 2),
                                  (stupica.l1) + 5, (stupica.D_okr / 2), 3);  //
                    doc.ksLineSeg((0) - 5, -(stupica.D_okr / 2),
                                  (stupica.l1) + 5, -(stupica.D_okr / 2), 3); //

                    if (doc.ksHatch(0, 45, 2, 0, 0, 0) == 1)
                    {
                        doc.ksLineSeg(0, stupica.D_okr / 2 + stupica.d4 / 2,
                                      0, (stupica.D_external / 2 - stupica.b1), 1);                        //от отверстия до верха
                        doc.ksLineSeg(0, (stupica.D_external / 2 - stupica.b1),
                                      (stupica.b1), (stupica.D_external / 2), 1);                          //фаска
                        doc.ksLineSeg((stupica.b1), (stupica.D_external / 2),
                                      (stupica.l1 - stupica.b1), (stupica.D_external / 2), 1);             //верхняя линия
                        doc.ksLineSeg((stupica.l1 - stupica.b1), (stupica.D_external / 2),
                                      (stupica.l1), (stupica.D_external / 2 - stupica.b1), 1);             //faska
                        doc.ksLineSeg((stupica.l1), (stupica.D_external / 2 - stupica.b1),
                                      (stupica.l1), (stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2), 1); //сверху вниз до фаски
                        doc.ksLineSeg((stupica.l1 - stupica.b2), (stupica.D_okr / 2 + stupica.d4 / 2),
                                      (stupica.l1), (stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2), 1); //верхняя фаска
                        doc.ksLineSeg((0), (stupica.D_okr / 2 + stupica.d4 / 2),
                                      (stupica.l1 - stupica.b2), (stupica.D_okr / 2 + stupica.d4 / 2), 1); //нижняя линия


                        doc.ksLineSeg((0), (stupica.d2 / 2),
                                      (0), (stupica.D_okr / 2 - stupica.d4 / 2), 1);                       //от кольца до отверстия
                        doc.ksLineSeg((0), (stupica.D_okr / 2 - stupica.d4 / 2),
                                      (stupica.l1 - stupica.b2), (stupica.D_okr / 2 - stupica.d4 / 2), 1); //нижняя планка
                        doc.ksLineSeg((stupica.l1 - stupica.b2), (stupica.D_okr / 2 - stupica.d4 / 2),
                                      (stupica.l1), (stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2), 1); //нижняя фаска
                        doc.ksLineSeg((stupica.l1), (stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2),
                                      (stupica.l1), (stupica.d1 / 2 + stupica.R1), 1);                     //нижняя фаска
                        doc.ksArcByAngle((stupica.l1 + stupica.R1), (stupica.d1 / 2 + stupica.R1), (stupica.R1),
                                         180, 270, 1, 1);                                                  //скругление
                        doc.ksLineSeg((stupica.l1 + stupica.R1), (stupica.d1 / 2),
                                      (stupica.l - stupica.b1), (stupica.d1 / 2), 1);                      //линия внешней стороны стакана вправо
                        doc.ksLineSeg((stupica.l - stupica.b1), (stupica.d1 / 2),
                                      (stupica.l), (stupica.d1 / 2 - stupica.b1), 1);                      //faska
                        doc.ksLineSeg((stupica.l), (stupica.d1 / 2 - stupica.b1),
                                      (stupica.l), (stupica.h - stupica.d / 2), 1);                        //до паза
                        doc.ksLineSeg((stupica.l2), (stupica.h - stupica.d / 2),
                                      (stupica.l), (stupica.h - stupica.d / 2), 1);                        //паз
                        doc.ksLineSeg((stupica.l2), (stupica.h - stupica.d / 2),
                                      (stupica.l2), (stupica.d2 / 2), 1);
                        doc.ksLineSeg((0), (stupica.d2 / 2),
                                      (stupica.l2), (stupica.d2 / 2), 1);

                        //зеркально
                        doc.ksLineSeg(0, -(stupica.D_okr / 2 + stupica.d4 / 2),
                                      0, -(stupica.D_external / 2 - stupica.b1), 1);                        //от отверстия до верха
                        doc.ksLineSeg(0, -(stupica.D_external / 2 - stupica.b1),
                                      (stupica.b1), -(stupica.D_external / 2), 1);                          //фаска
                        doc.ksLineSeg((stupica.b1), -(stupica.D_external / 2),
                                      (stupica.l1 - stupica.b1), -(stupica.D_external / 2), 1);             //верхняя линия
                        doc.ksLineSeg((stupica.l1 - stupica.b1), -(stupica.D_external / 2),
                                      (stupica.l1), -(stupica.D_external / 2 - stupica.b1), 1);             //faska
                        doc.ksLineSeg((stupica.l1), -(stupica.D_external / 2 - stupica.b1),
                                      (stupica.l1), -(stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2), 1); //сверху вниз до фаски
                        doc.ksLineSeg((stupica.l1 - stupica.b2), -(stupica.D_okr / 2 + stupica.d4 / 2),
                                      (stupica.l1), -(stupica.D_okr / 2 + stupica.d4 / 2 + stupica.b2), 1); //верхняя фаска
                        doc.ksLineSeg((0), -(stupica.D_okr / 2 + stupica.d4 / 2),
                                      (stupica.l1 - stupica.b2), -(stupica.D_okr / 2 + stupica.d4 / 2), 1); //нижняя линия


                        doc.ksLineSeg((0), -(stupica.d2 / 2),
                                      (0), -(stupica.D_okr / 2 - stupica.d4 / 2), 1);                       //от кольца до отверстия
                        doc.ksLineSeg((0), -(stupica.D_okr / 2 - stupica.d4 / 2),
                                      (stupica.l1 - stupica.b2), -(stupica.D_okr / 2 - stupica.d4 / 2), 1); //нижняя планка
                        doc.ksLineSeg((stupica.l1 - stupica.b2), -(stupica.D_okr / 2 - stupica.d4 / 2),
                                      (stupica.l1), -(stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2), 1); //нижняя фаска
                        doc.ksLineSeg((stupica.l1), -(stupica.D_okr / 2 - stupica.d4 / 2 - stupica.b2),
                                      (stupica.l1), -(stupica.d1 / 2 + stupica.R1), 1);                     //нижняя фаска
                        doc.ksArcByAngle((stupica.l1 + stupica.R1), -(stupica.d1 / 2 + stupica.R1), (stupica.R1),
                                         90, 180, 1, 1);                                                    //скругление
                        doc.ksLineSeg((stupica.l1 + stupica.R1), -(stupica.d1 / 2),
                                      (stupica.l - stupica.b1), -(stupica.d1 / 2), 1);                      //линия внешней стороны стакана вправо
                        doc.ksLineSeg((stupica.l - stupica.b1), -(stupica.d1 / 2),
                                      (stupica.l), -(stupica.d1 / 2 - stupica.b1), 1);                      //faska
                        doc.ksLineSeg((stupica.l), -(stupica.d1 / 2 - stupica.b1),
                                      (stupica.l), -(stupica.d / 2), 1);                                    //до отв
                        doc.ksLineSeg((stupica.l - stupica.b1), -(stupica.d / 2),
                                      (stupica.l - stupica.b1), -(stupica.d / 2 + stupica.b1), 1);          //фаска
                        doc.ksLineSeg((stupica.l2), -(stupica.d / 2),
                                      (stupica.l), -(stupica.d / 2), 1);                                    //отв
                        doc.ksLineSeg((stupica.l2), -(stupica.d / 2),
                                      (stupica.l2), -(stupica.d2 / 2), 1);
                        doc.ksLineSeg((0), -(stupica.d2 / 2),
                                      (stupica.l2), -(stupica.d2 / 2), 1);

                        reference telo = doc.ksEndObj();

                        ksHatchParam par = (ksHatchParam)_kompas.GetParamStruct((short)StructType2DEnum.ko_HatchParam);
                        if (par != null)
                        {
                            par.Init();
                            int t = doc.ksGetObjParam(telo, par, ldefin2d.ALLPARAM);

                            doc.ksDeleteMtr();

                            doc.ksMtr(0, 0, 0, 2, 2);

                            // заменить параметры штриховки
                            par.x = 0.8;

                            doc.ksDeleteMtr();
                        }
                    }


                    //////////   РАЗМЕРЫ
                    //горизонтальные
                    LinRazm(doc,
                            (stupica.b1), -(stupica.d2 / 2),
                            (stupica.b1), (stupica.d2 / 2),
                            1, -15, 0, 1); //d2
                    LinRazm(doc,
                            (stupica.b1), -(stupica.D_external / 2),
                            (stupica.b1), (stupica.D_external / 2),
                            1, -27, 0, 1); //D_external
                    LinRazm(doc,
                            (stupica.l - stupica.b1), -(stupica.d1 / 2),
                            (stupica.l - stupica.b1), (stupica.d1 / 2),
                            1, 27, 0, 1); //d1

                    //вертикальные
                    LinRazm(doc,
                            (0), -(stupica.d2 / 2),
                            (stupica.l2), -(stupica.d2 / 2),
                            2, 0, -15, 0); //l2
                    LinRazm(doc,
                            (stupica.l1 - stupica.b2), -(stupica.D_okr / 2),
                            (stupica.l1), -(stupica.D_okr / 2),
                            2, 0, -(stupica.D_external / 2 - stupica.D_okr / 2) * multiply - 15, 0, 3); //b2 - фаска отверстия
                    LinRazm(doc,
                            (0), -(stupica.D_external / 2 - stupica.b1),
                            (stupica.l1), -(stupica.D_external / 2 - stupica.b1),
                            2, 0, -27, 0); //l1
                    LinRazm(doc,
                            (0), (0),
                            (stupica.l), (0),
                            2, 0, -(stupica.D_external / 2) * multiply - 39, 0); //l
                    LinRazm(doc,
                            (stupica.l - stupica.b1), (0),
                            (stupica.l), (0),
                            2, 0, -(stupica.d1 / 2) * multiply - 15, 0, 3); //b1 - фаска ребра

                    set_rad_razm(stupica, doc);


                    liniya_s_obrivom(stupica, multiply, doc);
                }



                ksViewParam parv2 = (ksViewParam)_kompas.GetParamStruct((short)StructType2DEnum.ko_ViewParam);
                if (parv2 != null)
                {
                    number = 2;
                    parv2.Init();
                    parv2.x      = 300;
                    parv2.y      = 150;
                    parv2.scale_ = multiply;                            //масштаб вида
                    parv2.angle  = 0;                                   //угол поворота вида
                    parv2.color  = Color.FromArgb(10, 20, 10).ToArgb(); //цвет вида в активном состоянии
                    parv2.state  = ldefin2d.stACTIVE;
                    parv2.name   = "Вид спереди";
                    // У документа создадим вид с номером 1, масштабом 0.5, под углом 45 гр

                    reference v = doc.ksCreateSheetView(parv2, ref number); //создать вид

                    // Создадим слой с номером 5
                    doc.ksLayer(5);

                    //внешняя окр
                    doc.ksCircle(0, 0, (stupica.D_external / 2), 1);
                    doc.ksCircle(0, 0, (stupica.D_external / 2 - stupica.b1), 1);

                    //стакан
                    doc.ksCircle(0, 0, (stupica.d1 / 2), 1);
                    doc.ksCircle(0, 0, (stupica.d1 / 2 - stupica.b1), 1);

                    //осевая
                    doc.ksCircle(0, 0, (stupica.D_okr / 2), 3);

                    //паз
                    reference left = doc.ksLineSeg((-stupica.B / 2), (stupica.d / 2 - stupica.b1 * 5),
                                                   (-stupica.B / 2), (stupica.h - stupica.d / 2 - stupica.R), 1); //левая линия
                    reference right = doc.ksLineSeg((stupica.B / 2), (stupica.d / 2 - stupica.b1 * 5),
                                                    (stupica.B / 2), (stupica.h - stupica.d / 2 - stupica.R), 1); //правая линия
                    doc.ksArcByAngle((-stupica.B / 2 + stupica.R), (stupica.h - stupica.d / 2 - stupica.R), (stupica.R),
                                     90, 180, 1, 1);                                                              //скругление
                    doc.ksArcByAngle((stupica.B / 2 - stupica.R), (stupica.h - stupica.d / 2 - stupica.R), (stupica.R),
                                     0, 90, 1, 1);                                                                //скругление
                    doc.ksLineSeg((-stupica.B / 2 + stupica.R), (stupica.h - stupica.d / 2),
                                  (stupica.B / 2 - stupica.R), (stupica.h - stupica.d / 2), 1);                   //верхняя линия

                    //внутр окр
                    reference c1 = doc.ksCircle(0, 0, (stupica.d / 2), 1);
                    reference c2 = doc.ksCircle(0, 0, (stupica.d / 2 + stupica.b1), 1);

                    /*     doc.ksTrimmCurve(left,
                     *       (-master.B / 2), (master.h - master.d / 2 - master.R),
                     *       (-master.B / 2), (master.d / 2),
                     *       (-master.B / 2), (master.d / 2 + 0.5), 1);*/


                    ksMathPointParam p1 = (ksMathPointParam)_kompas.GetParamStruct((short)StructType2DEnum.ko_MathPointParam);


                    object afa = new object();

                    //точки пересечения считаю сам, т.к. компас... не будем говорить о плохом
                    var c1_l1 = line_cirle_itersection((stupica.d / 2), (-stupica.B / 2));
                    var c1_l2 = line_cirle_itersection((stupica.d / 2), (stupica.B / 2));
                    var c2_l1 = line_cirle_itersection((stupica.d / 2 + stupica.b1), (-stupica.B / 2));
                    var c2_l2 = line_cirle_itersection((stupica.d / 2 + stupica.b1), (stupica.B / 2));

                    doc.ksTrimmCurve(left,
                                     (-stupica.B / 2), (stupica.h - stupica.d / 2 - stupica.R),
                                     c1_l1.x, c1_l1.y, c1_l1.x, c1_l1.y, 1);
                    doc.ksTrimmCurve(right,
                                     (stupica.B / 2), (stupica.h - stupica.d / 2 - stupica.R),
                                     c1_l2.x, c1_l2.y, c1_l2.x, c1_l2.y, 1);
                    doc.ksTrimmCurve(c1, c1_l1.x, c1_l1.y, c1_l2.x, c1_l2.y, 0, -(stupica.d / 2), 1);
                    doc.ksTrimmCurve(c2, c2_l1.x, c2_l1.y, c2_l2.x, c2_l2.y, 0, -(stupica.d / 2 + stupica.b1), 1);

                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //
                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //
                    doc.ksLineSeg((0), (0),
                                  (0), (0), 1); //

                    int N_otv = (stupica.n + stupica.n3);
                    int angle = 360 / N_otv;
                    List <ksMathPointParam> list_of_holes = new List <ksMathPointParam>();
                    for (int i = 1; i <= N_otv; i++)
                    {
                        var c_otv = point_by_angle((stupica.D_okr / 2), 90 + angle * (i - 1));
                        list_of_holes.Add(c_otv);
                        if (i % 2 == 1)
                        {
                            doc.ksCircle(c_otv.x, c_otv.y, (stupica.d4 / 2), 1);
                            doc.ksLineSeg(c_otv.x, c_otv.y + (stupica.d4 / 2 + 5), c_otv.x, c_otv.y - (stupica.d4 / 2 + 5), 3);
                            doc.ksLineSeg(c_otv.x - (stupica.d4 / 2 + 5), c_otv.y, c_otv.x + (stupica.d4 / 2 + 5), c_otv.y, 3);
                        }
                        else
                        {
                            doc.ksCircle(c_otv.x, c_otv.y, (stupica.d3 / 2), 1);
                            doc.ksLineSeg(c_otv.x, c_otv.y + (stupica.d3 / 2 + 5), c_otv.x, c_otv.y - (stupica.d3 / 2 + 5), 3);
                            doc.ksLineSeg(c_otv.x - (stupica.d3 / 2 + 5), c_otv.y, c_otv.x + (stupica.d3 / 2 + 5), c_otv.y, 3);
                        }
                        //как сделать обозначения повернутыми к центру пока не придумал, время и так нема
                    }

                    //////////   РАЗМЕРЫ
                    //диаметры

                    Diam_Razmer(0, 0, (stupica.D_okr / 2), (int)((stupica.D_external - stupica.D_okr) / 2 * multiply) + 15, 1, 1, 45, doc);
                    Diam_Razmer(list_of_holes[0].x, list_of_holes[0].y, (stupica.d4 / 2), 5, 2, 1, 45, doc);
                    Diam_Razmer(list_of_holes[1].x, list_of_holes[1].y, (stupica.d3 / 2), 5, 2, 1, 45, doc);

                    LinRazm(doc,
                            -(stupica.B / 2), (stupica.h - stupica.d / 2 - stupica.R),
                            (stupica.B / 2), (stupica.h - stupica.d / 2 - stupica.R),
                            2, 0, 12, 0); //l1

                    LinRazm(doc,
                            (0), -(stupica.d / 2),
                            (0), (stupica.h - stupica.d / 2),
                            1, (stupica.d1 / 2) * multiply + 10, 0, 0); //l1
                }
            }
        }
Esempio n. 26
0
        /// <summary>
        /// Создание окружности с выдавливанием
        /// </summary>
        /// <param name="x1"></param>
        /// <param name="y1"></param>
        /// <param name="rad"></param>
        /// <param name="depth"></param>
        /// <param name="plane"></param>
        public void CreateCircle(double x1, double y1, double rad, double depth, string plane)
        {
            // ksPart part = (ksPart)doc.GetPart((short)Part_Type.pTop_Part);	// новый компонент
            var doc = (ksDocument3D)kompas.ActiveDocument3D();

            if (doc == null || doc.reference == 0)
            {
                doc = (ksDocument3D)kompas.Document3D();
                doc.Create(true, true);

                doc.author  = "Ethereal";
                doc.comment = "3D Steps - Step3d1";
                doc.UpdateDocumentParam();
            }
            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);  // установим плоскость базовой для эскиза
                        sketchDef.angle = 45;           // угол поворота эскиза
                        entitySketch.Create( );         // создадим эскиз1

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



                        // отверстие
                        sketchEdit.ksCircle(x1, y1, rad, 1);
                        sketchDef.EndEdit( );   // завершение редактирования эскиза
                        ksEntity entityExtr = (ksEntity)part.NewEntity((short)Obj3dType.o3d_baseExtrusion);
                        if (entityExtr != null)
                        {
                            // интерфейс свойств базовой операции выдавливания
                            ksBaseExtrusionDefinition extrusionDef =
                                (ksBaseExtrusionDefinition)entityExtr.GetDefinition( );
                            // интерфейс базовой операции выдавливания
                            if (extrusionDef != null)
                            {
                                extrusionDef.directionType = (short)Direction_Type.dtNormal;
                                // направление выдавливания
                                extrusionDef.SetSideParam(true,                    // прямое направление
                                                          (short)End_Type.etBlind, // строго на глубину
                                                          depth);                  // Расстояние выдавливания
                                extrusionDef.SetSketch(entitySketch);              // эскиз операции выдавливания

                                entityExtr.Create( );                              // создать операцию
                                sketchDef.EndEdit( );                              // завершение редактирования эскиза
                            }
                        }
                    }
                }
            }
        }
Esempio n. 27
0
        ///<summary>
        /// Процедура построениея верхнего и нижнего пластиков
        ///</summary>
        private void CreateDrumhead(double kadloHeight, double kadloRadius, double thicknessTopDrumhead, double thicknessBottomDrumhead)
        {
            // Создание плоскости для верхнего пластика
            #region
            ksSketchDefinition definitionSketch = null;
            // Проверка на существование компонента сборки
            if (_part != null)
            {
                // создадим новый эскиз
                var DrumheadSketch = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                if (DrumheadSketch != null)
                {
                    // Получение интерфейса свойств эскиза
                    definitionSketch = (ksSketchDefinition)DrumheadSketch.GetDefinition();
                    if (definitionSketch != null)
                    {
                        // Получение интерфейса базовой плоскости XOY
                        var basePlane = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        // создаем эскиз для смещенной плоскости
                        ksEntity entityOffsetPlane = _part.NewEntity((short)Obj3dType.o3d_planeOffset);
                        // получение интерфейса свойств эскиза для смещенной плоскости
                        ksPlaneOffsetDefinition offsetDef = (ksPlaneOffsetDefinition)entityOffsetPlane.GetDefinition();
                        // расстояние смещение
                        offsetDef.offset = kadloHeight;
                        // направление смещения
                        offsetDef.direction = true;
                        // назначение плоскости переноса
                        offsetDef.SetPlane(basePlane);
                        // создание смещенной плоскости
                        entityOffsetPlane.Create();

                        ksEntity _sketch    = _part.NewEntity((short)Obj3dType.o3d_sketch);
                        var      sketchDef2 = (ksSketchDefinition)_sketch.GetDefinition();
                        sketchDef2.SetPlane(entityOffsetPlane);
                        _sketch.Create();

                        ksDocument2D sketchEdit2 = (ksDocument2D)sketchDef2.BeginEdit(); //начало редактирования эскиза
                        sketchEdit2.ksCircle(0, 0, kadloRadius, 1);                      //рисуем окружность для пластика
                        sketchDef2.EndEdit();                                            // завершение редактирования
                        #endregion
                        // Выдавливание верхнего пластика
                        #region
                        ksEntity entityBossExtr1 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                        if (entityBossExtr1 != null)
                        {
                            ksBossExtrusionDefinition bossExtrDef = (ksBossExtrusionDefinition)entityBossExtr1.GetDefinition();
                            if (bossExtrDef != null)
                            {
                                // интерфейс структуры параметров выдавливания
                                ksExtrusionParam extrProp = (ksExtrusionParam)bossExtrDef.ExtrusionParam();
                                // интерфейс структуры параметров тонкой стенки
                                ksThinParam thinProp = (ksThinParam)bossExtrDef.ThinParam();
                                if (extrProp != null)
                                {
                                    // эскиз операции выдавливания
                                    bossExtrDef.SetSketch(_sketch);
                                    // направление выдавливания (прямое)
                                    extrProp.direction = (short)Direction_Type.dtNormal;
                                    // тип выдавливания (строго на глубину)
                                    extrProp.typeNormal = (short)End_Type.etBlind;
                                    // глубина выдавливания
                                    extrProp.depthNormal = thicknessTopDrumhead;
                                    // создадим операцию
                                    entityBossExtr1.Create();
                                }
                            }
                        }
                    }
                    #endregion
                    // Создание плоскости для нижнего пластика
                    #region
                    // получим интерфейс базовой плоскости XOY
                    ksEntity planeXOY = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                    ksEntity iSketch  = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                    if (iSketch != null)
                    {
                        ksEntity entitySketch1 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                        if (entitySketch1 != null)
                        {
                            // интерфейс свойств эскиза
                            ksSketchDefinition sketchDef1 = (ksSketchDefinition)entitySketch1.GetDefinition();
                            if (sketchDef1 != null)
                            {
                                // установим плоскость
                                sketchDef1.SetPlane(planeXOY);
                                // создадим эскиз
                                entitySketch1.Create();

                                // интерфейс редактора эскиза
                                ksDocument2D sketchEdit1 = (ksDocument2D)sketchDef1.BeginEdit();
                                sketchEdit1.ksCircle(0, 0, kadloRadius, 1);
                                // завершение редактирования эскиза
                                sketchDef1.EndEdit();
                                #endregion

                                // Выдавливание нижнего пластика
                                #region
                                ksEntity entityBossExtr2 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                                if (entityBossExtr2 != null)
                                {
                                    ksBossExtrusionDefinition bossExtrDef1 = (ksBossExtrusionDefinition)entityBossExtr2.GetDefinition();
                                    if (bossExtrDef1 != null)
                                    {
                                        // интерфейс структуры параметров выдавливания
                                        ksExtrusionParam extrProp1 = (ksExtrusionParam)bossExtrDef1.ExtrusionParam();
                                        // интерфейс структуры параметров тонкой стенки
                                        ksThinParam thinProp1 = (ksThinParam)bossExtrDef1.ThinParam();
                                        if (extrProp1 != null)
                                        {
                                            // эскиз операции выдавливания
                                            bossExtrDef1.SetSketch(entitySketch1);
                                            // направление выдавливания (обратное)
                                            extrProp1.direction = (short)Direction_Type.dtReverse;
                                            // тип выдавливания (строго на глубину)
                                            extrProp1.typeReverse = (short)End_Type.etBlind;
                                            // глубина выдавливания
                                            extrProp1.depthReverse = thicknessBottomDrumhead;
                                            // создадим операцию
                                            entityBossExtr2.Create();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 28
0
        ///<summary>
        /// Создание креплений
        /// </summary>
        private void CreateMountong(double kadloHeight, double thicknessTopDrumhead, double thicknessBottomDrumhead, double rimCenter, int numberMounting)
        {
            if (_part != null)
            {
                // интерфейс свойств эскиза
                ksEntity mount = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                if (mount != null)
                {
                    // Получение интерфейса свойств эскиза
                    ksSketchDefinition rimSketch = (ksSketchDefinition)mount.GetDefinition();
                    if (rimSketch != null)
                    {
                        ksEntity basePlane;
                        // Получение интерфейса базовой плоскости XOY
                        basePlane = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        // установим плоскость базовой для эскиза
                        rimSketch.SetPlane(basePlane);
                        ksEntity entityOffsetPlane          = _part.NewEntity((short)Obj3dType.o3d_planeOffset);
                        ksPlaneOffsetDefinition offsetDef01 = (ksPlaneOffsetDefinition)entityOffsetPlane.GetDefinition();
                        // Расстояние смещения
                        offsetDef01.offset    = thicknessBottomDrumhead;
                        offsetDef01.direction = false;
                        offsetDef01.SetPlane(basePlane);
                        // создаем смещенную плоскость
                        entityOffsetPlane.Create();
                        // установим плоскость базовой для эскиза
                        rimSketch.SetPlane(offsetDef01);
                        // создадим эскиз
                        mount.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 entityBossExtr3 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                        if (entityBossExtr3 != null)
                        {
                            ksBossExtrusionDefinition bossExtrDef3 = (ksBossExtrusionDefinition)entityBossExtr3.GetDefinition();
                            if (bossExtrDef3 != null)
                            {
                                // интерфейс структуры параметров выдавливания
                                ksExtrusionParam extrProp3 = (ksExtrusionParam)bossExtrDef3.ExtrusionParam();
                                // интерфейс структуры параметров тонкой стенки
                                ksThinParam thinProp3 = (ksThinParam)bossExtrDef3.ThinParam();
                                if (extrProp3 != null)
                                {
                                    // эскиз операции выдавливания
                                    bossExtrDef3.SetSketch(rimSketch);
                                    // направление выдавливания
                                    extrProp3.direction = (short)Direction_Type.dtNormal;
                                    // тип выдавливания
                                    extrProp3.typeNormal = (short)End_Type.etBlind;
                                    // Высота выдавливания
                                    extrProp3.depthNormal = kadloHeight;
                                    // создадим операцию
                                    entityBossExtr3.Create();
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 29
0
        ///<summary>
        /// Процедура построения кадла
        /// </summary>
        private void CreateKadlo(double kadloRadius, double kadloHeight, double kadloThickness)
        {
            ksDocument3D iDocument3D = (ksDocument3D)_kompas.Document3D();

            if (iDocument3D.Create(false /*видимый*/, true /*деталь*/))
            {
                // новый компонент
                _part = (ksPart)iDocument3D.GetPart((short)Part_Type.pTop_Part);
                if (_part != null)
                {
                    // получим интерфейс базовой плоскости XOY
                    ksEntity planeXOY = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                    ksEntity iSketch  = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                    if (iSketch != null)
                    {
                        // создадим новый эскиз
                        ksEntity entitySketch1 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                        if (entitySketch1 != null)
                        {
                            // интерфейс свойств эскиза
                            ksSketchDefinition sketchDef1 = (ksSketchDefinition)entitySketch1.GetDefinition();
                            if (sketchDef1 != null)
                            {
                                // установим плоскость
                                sketchDef1.SetPlane(planeXOY);
                                // создадим эскиз
                                entitySketch1.Create();

                                // интерфейс редактора эскиза
                                ksDocument2D sketchEdit1 = (ksDocument2D)sketchDef1.BeginEdit();
                                sketchEdit1.ksCircle(0, 0, kadloRadius, 1);
                                // завершение редактирования эскиза
                                sketchDef1.EndEdit();

                                // создание операции выдавливания
                                ksEntity entityBossExtr = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                                if (entityBossExtr != null)
                                {
                                    // Получение свойств интерфейса выдавливания
                                    ksBossExtrusionDefinition bossExtrDef = (ksBossExtrusionDefinition)entityBossExtr.GetDefinition();
                                    if (bossExtrDef != null)
                                    {
                                        // интерфейс структуры параметров выдавливания
                                        ksExtrusionParam extrProp = (ksExtrusionParam)bossExtrDef.ExtrusionParam();
                                        // интерфейс структуры параметров тонкой стенки
                                        ksThinParam thinProp = (ksThinParam)bossExtrDef.ThinParam();
                                        if (extrProp != null && thinProp != null)
                                        {
                                            // эскиз операции выдавливания
                                            bossExtrDef.SetSketch(entitySketch1);
                                            // направление выдавливания (обратное)
                                            extrProp.direction = (short)Direction_Type.dtNormal;
                                            // тип выдавливания (строго на глубину)
                                            extrProp.typeNormal = (short)End_Type.etBlind;
                                            // глубина выдавливания
                                            extrProp.depthNormal = kadloHeight;
                                            // наличие тонкой стенки
                                            thinProp.thin = true;
                                            //Толщина стенки в обратном направлении
                                            thinProp.reverseThickness = kadloThickness;
                                            //Направление формирования тонкой стенки
                                            thinProp.thinType = (short)Direction_Type.dtBoth;
                                            // создадим операцию
                                            entityBossExtr.Create();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 30
0
        ///<summary>
        ///Создание подструнника
        ///</summary>
        private void CreateSnare(bool ExistSnare, int stringSnare, double kadloRadius, double thicknessBottomDrumhead)
        {
            // Проверка на существование компонента сборки
            if (_part != null)
            {
                // создадим новый эскиз
                var SnareSketch = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                if (SnareSketch != null)
                {
                    // Получение интерфейса свойств эскиза
                    var definitionSnare = (ksSketchDefinition)SnareSketch.GetDefinition();
                    if (definitionSnare != null)
                    {
                        // Получение интерфейса базовой плоскости XOY
                        var      basePlane                = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOY);
                        ksEntity entityOffsetPlane        = _part.NewEntity((short)Obj3dType.o3d_planeOffset);
                        ksPlaneOffsetDefinition offsetDef = (ksPlaneOffsetDefinition)entityOffsetPlane.GetDefinition();
                        offsetDef.offset    = thicknessBottomDrumhead;
                        offsetDef.direction = false;
                        offsetDef.SetPlane(basePlane);
                        // создаем смещенную плоскость
                        entityOffsetPlane.Create();
                        ksEntity snare    = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                        var      defSnare = (ksSketchDefinition)snare.GetDefinition();
                        defSnare.SetPlane(offsetDef);
                        snare.Create();
                        ksDocument2D SnareEdit = (ksDocument2D)defSnare.BeginEdit();
                        // Рисуем основание подструнника
                        SnareEdit.ksLineSeg(-15, kadloRadius - 5, 15, kadloRadius - 5, 1);
                        SnareEdit.ksLineSeg(15, kadloRadius - 5, 15, kadloRadius - 10, 1);
                        SnareEdit.ksLineSeg(15, kadloRadius - 10, -15, kadloRadius - 10, 1);
                        SnareEdit.ksLineSeg(-15, kadloRadius - 10, -15, kadloRadius - 5, 1);

                        SnareEdit.ksLineSeg(-15, -kadloRadius + 5, 15, -kadloRadius + 5, 1);
                        SnareEdit.ksLineSeg(15, -kadloRadius + 5, 15, -kadloRadius + 10, 1);
                        SnareEdit.ksLineSeg(15, -kadloRadius + 10, -15, -kadloRadius + 10, 1);
                        SnareEdit.ksLineSeg(-15, -kadloRadius + 10, -15, -kadloRadius + 5, 1);

                        defSnare.EndEdit();

                        // Выдавливание подструнника
                        ksEntity entityBossExtr3 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                        if (entityBossExtr3 != null)
                        {
                            ksBossExtrusionDefinition bossExtrDef3 = (ksBossExtrusionDefinition)entityBossExtr3.GetDefinition();
                            if (bossExtrDef3 != null)
                            {
                                // интерфейс структуры параметров выдавливания
                                ksExtrusionParam extrProp3 = (ksExtrusionParam)bossExtrDef3.ExtrusionParam();
                                if (extrProp3 != null)
                                {
                                    // эскиз операции выдавливания
                                    bossExtrDef3.SetSketch(snare);
                                    // направление выдавливания (обратное)
                                    extrProp3.direction = (short)Direction_Type.dtReverse;
                                    // тип выдавливания (строго на глубину)
                                    extrProp3.typeReverse = (short)End_Type.etBlind;
                                    // глубина выдавливания
                                    extrProp3.depthReverse = 4;
                                    // создадим операцию
                                    entityBossExtr3.Create();
                                }
                            }
                        }
                        // Создание струн подструнника
                        var StringSketch = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                        if (StringSketch != null)
                        {
                            // Получение интерфейса свойств эскиза
                            var definitionString = (ksSketchDefinition)StringSketch.GetDefinition();
                            if (definitionString != null)
                            {
                                // Получение интерфейса базовой плоскости XOZ
                                var      stringPlane    = (ksEntity)_part.GetDefaultEntity((short)Obj3dType.o3d_planeXOZ);
                                ksEntity stSnare        = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_sketch);
                                var      defStringSnare = (ksSketchDefinition)stSnare.GetDefinition();
                                defStringSnare.SetPlane(stringPlane);
                                stSnare.Create();
                                ksDocument2D stringSnareEdit = (ksDocument2D)defStringSnare.BeginEdit();
                                // В ряд рисуются круги (сечение струн)
                                int k = 1;
                                for (double x = -11; x < 12; x += 3)
                                {
                                    stringSnareEdit.ksCircle(x, thicknessBottomDrumhead + 2, 1, 1);
                                    if (k < stringSnare)
                                    {
                                        k++;
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                                defStringSnare.EndEdit();

                                // Выдавливание струн подструнника
                                ksEntity entityBossExtr4 = (ksEntity)_part.NewEntity((short)Obj3dType.o3d_bossExtrusion);
                                if (entityBossExtr4 != null)
                                {
                                    ksBossExtrusionDefinition bossExtrDef3 = (ksBossExtrusionDefinition)entityBossExtr4.GetDefinition();
                                    if (bossExtrDef3 != null)
                                    {
                                        // интерфейс структуры параметров выдавливания
                                        ksExtrusionParam extrProp3 = (ksExtrusionParam)bossExtrDef3.ExtrusionParam();
                                        if (extrProp3 != null)
                                        {
                                            // эскиз операции выдавливания
                                            bossExtrDef3.SetSketch(stSnare);
                                            // направление выдавливания (обе стороны)
                                            extrProp3.direction = (short)Direction_Type.dtBoth;
                                            // тип выдавливания (до ближайшей поверхности)
                                            extrProp3.typeReverse = (short)End_Type.etUpToNearSurface;
                                            extrProp3.typeNormal  = (short)End_Type.etUpToNearSurface;
                                            // создадим операцию
                                            entityBossExtr4.Create();
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }