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

                    extrusionDef.SetSketch(sketch);
                    entityExtr.Create();
                    entityExtr.Update();
                }
                return(true);
            }
            catch
            {
                return(false);
            }
        }
        /// <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;
        }
        /// <summary>
        /// Метод, выполняющий выдавливание по эскизу
        /// </summary>
        /// <param name="part">Интерфейс компонента</param>
        /// <param name="sketch">Эскиз</param>
        /// <param name="height">Высота выдавливания</param>
        /// <param name="type">Тип выдавливания</param>
        private void ExtrudeSketch(ksPart part, ksEntity sketch,
                                   double height, bool type)
        {
            ksEntity entityExtrusion = (ksEntity)part.NewEntity((short)
                                                                Obj3dType.o3d_baseExtrusion);
            ksBaseExtrusionDefinition extrusionDefinition =
                (ksBaseExtrusionDefinition)entityExtrusion.GetDefinition();

            if (type == false)
            {
                extrusionDefinition.directionType = (short)Direction_Type.
                                                    dtReverse;
                extrusionDefinition.SetSideParam(false,
                                                 (short)End_Type.etBlind, height);
            }
            if (type == true)
            {
                extrusionDefinition.directionType = (short)Direction_Type.
                                                    dtNormal;
                extrusionDefinition.SetSideParam(true,
                                                 (short)End_Type.etBlind, height);
            }
            extrusionDefinition.SetSketch(sketch);
            entityExtrusion.Create();
        }
示例#4
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();                    // создать операцию
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
示例#5
0
            public override ksEntity Execute()
            {
                ksEntity extrusion = Part.NewEntity((short)Obj3dType.o3d_baseExtrusion);
                ksBaseExtrusionDefinition definition = extrusion.GetDefinition();

                definition.SetSideParam(true, 0, Model.GripLength, 0, true);
                definition.SetSketch(_drawSketchCommand.Execute());
                extrusion.Create();
                return(extrusion);
            }
示例#6
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();                    // создать операцию
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
示例#7
0
        /// <summary>
        /// Элемент выдавливания
        /// </summary>
        /// <param name="ksEntityDraw">эскиз</param>
        /// <param name="ksEntityExtrusion">выдавливание</param>
        private void ExstrusionMethod(ksEntity ksEntityDraw,
                                      ksEntity ksEntityExtrusion)
        {
            ksBaseExtrusionDefinition ksBaseExtrusionDefinition =
                (ksBaseExtrusionDefinition)ksEntityExtrusion.
                GetDefinition();

            ksBaseExtrusionDefinition.SetSideParam(true,
                                                   (short)End_Type.etBlind,
                                                   mouseSetting.TheHeightOfTheFirstLevelOfTheMouseProperty,
                                                   0, true);
            ksBaseExtrusionDefinition.SetSketch(ksEntityDraw);
            ksEntityExtrusion.Create();
        }
示例#8
0
        /// <summary>
        /// Выдваливание
        /// </summary>
        /// <param name="size"></param>
        /// <param name="ksEntity"></param>
        /// <param name="name"></param>
        /// <param name="ksEntityExtrusion"></param>
        private void Exstrusion(double size, ksEntity ksEntity,
                                string name, ksEntity ksEntityExtrusion)
        {
            ksEntityExtrusion = (ksEntity)_ksPart.NewEntity((int)Obj3dType.o3d_baseExtrusion);
            ksBaseExtrusionDefinition ksBaseExtrusionDefinition =
                (ksBaseExtrusionDefinition)ksEntityExtrusion.GetDefinition();

            ksBaseExtrusionDefinition.SetSideParam(true, (short)End_Type.etBlind, size, 0, true);
            ksBaseExtrusionDefinition.SetSketch(ksEntity);
            ksEntityExtrusion.name     = name;
            ksEntityExtrusion.useColor = 0;
            ksEntityExtrusion.SetAdvancedColor(3223857, 0.9, 0.8, 0.7, 0.6, 1, 0.4);
            ksEntityExtrusion.Create();
        }
示例#9
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();                        // создать операцию
                            }
                        }
                    }
                }
            }
        }
        /// <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;
        }
示例#11
0
        /// <summary>
        /// Выдавливание
        /// </summary>
        /// <param name="size">длина</param>
        /// <param name="ksEntity">эскиз</param>
        /// <param name="name">название</param>
        /// <param name="ksEntityExtrusion">выдавливание</param>
        private void Extrusion(double size, ksEntity ksEntity,
                               string name, ksEntity ksEntityExtrusion)
        {
            double angle = CuttingСorners(_bucket.DiameterOfTheBottom,
                                          _bucket.TheDiameterOfTheThroat, _bucket.TheHeightOfTheBucket);
            const int blueColor = 10046464;

            ksEntityExtrusion = (ksEntity)_ksPart.NewEntity(
                (int)Obj3dType.o3d_baseExtrusion);
            ksBaseExtrusionDefinition baseExtrusionDefinition =
                (ksBaseExtrusionDefinition)ksEntityExtrusion.GetDefinition();

            baseExtrusionDefinition.SetSideParam(true, (short)End_Type.etBlind,
                                                 size, angle, true);
            baseExtrusionDefinition.SetSketch(ksEntity);
            ksEntityExtrusion.name     = name;
            ksEntityExtrusion.useColor = 0;
            ksEntityExtrusion.SetAdvancedColor(blueColor, 0.9, 0.8,
                                               0.7, 0.6, 1, 0.4);
            ksEntityExtrusion.Create();
        }
示例#12
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( );                              // завершение редактирования эскиза
                            }
                        }
                    }
                }
            }
        }