Ejemplo n.º 1
0
        /// <summary>
        /// Provides information about the intersection of two circles.
        /// </summary>
        /// <param name="circle1">circle 1</param>
        /// <param name="circle2">circle 2</param>
        /// <returns>
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Unknown"/> if status is unknown.
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Disjoint"/> if the circles don't touch anywhere.
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Overlap"/> if there is an overlapping area.
        /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.AEnclosesB"/> if circle2 lies completely inside circle1 and doesn't intersect.
        /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.BEnclosesA"/> if circle1 lies completely inside circle2 and doesn't intersect.
        /// Additionally to Overlap and AEnclosesB/BEnclosesA: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Identical"/> if the centre points are equal and the radius is equal.
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Tangents"/> if the outer edge of circle1 touches the outer edge of circle2.
        /// </returns>
        public static AreaCode Intersect(Circle2D circle1, Circle2D circle2)
        {
            AreaCode retval = AreaCode.Unknown;

            // the circles are identical
            if (circle1.Equals(circle2))
            {
                retval =
                    AreaCode.AEnclosesB |
                    AreaCode.BEnclosesA |
                    AreaCode.Identical |
                    AreaCode.Intersect;
            }
            // the circles are not identical
            else
            {
                double distance = circle1.Centre.Distance(circle2.Centre);

                // the distance between the centres equals the sum of the radii
                // so the circles are tangents of each other
                if (distance == circle1.Radius + circle2.Radius)
                    retval = AreaCode.Tangents;
                // the distance between the centres is greater than the sum of the radii
                // therefore the circles must be disjoint
                else if (distance > circle1.Radius + circle2.Radius)
                    retval = AreaCode.Disjoint;

                // the distance between the centres is lower than the sum of the radii
                // therefore they must overlap in some way
                else if (distance < circle1.Radius + circle2.Radius)
                {
                    retval = AreaCode.Overlap;

                    // the sum of the distance and radius B is lower than radius A
                    // therefore: A encloses B
                    if (distance + circle2.Radius < circle1.Radius)
                        retval = retval | AreaCode.AEnclosesB;

                    // the sum of the distance and radius A is lower than radius B
                    // therefore: B encloses A
                    else if (distance + circle1.Radius < circle2.Radius)
                        retval = retval | AreaCode.BEnclosesA;
                    // no other possibility holds, the circles intersect
                    else
                        retval = retval | AreaCode.Intersect;
                }
            }
            return retval;
        }
Ejemplo n.º 2
0
 public static void CreateCam(double angle)
 {
     double dRad = angle*dPi/180;
     double dDSin1 = iCircle1Rad*Math.Sin(dRad);
     double dDCos1 = iCircle1Rad*Math.Cos(dRad);
     double dDSin2 = iCircle2Rad*Math.Sin(dRad);
     double dDCos2 = iCircle2Rad*Math.Cos(dRad);
     double dCSin = iCircleDist*Math.Sin(dRad);
     double dCCos = iCircleDist*Math.Cos(dRad);
     oCurrentSketch = oPartBody.Sketches.Add ( oPlaneYZ );
     Factory2D oFactory2D = oCurrentSketch.OpenEdition();
     double dRad1 = dRad - dPi/4;
     double dRad2 = dRad + dPi/4;
     oCurrentLine1 = oFactory2D.CreateLine( iCenterX - dDSin1, iCenterY + dDCos1, iCenterX + dCCos + dDSin2,  iCenterY - dCSin + dDCos2);
     oCurrentLine2 = oFactory2D.CreateLine( iCenterX + dDSin1, iCenterY - dDCos1, iCenterX + dCCos - dDSin2,  iCenterY - dCSin - dDCos2 );
     oCurrentCircle1 = oFactory2D.CreateCircle( iCenterX, iCenterY, iCircle1Rad,   dRad2,    dRad1);
     oCurrentCircle2 = oFactory2D.CreateCircle( iCenterX + dCCos, iCenterY + dCSin, iCircle2Rad,   dRad1,    dRad2);
     Reference oRefLine1 = oPart.CreateReferenceFromObject(oCurrentLine1);
     Reference oRefCircle1 = oPart.CreateReferenceFromObject(oCurrentCircle1);
     Reference oRefLine2 = oPart.CreateReferenceFromObject(oCurrentLine2);
     Reference oRefCircle2 = oPart.CreateReferenceFromObject(oCurrentCircle2);
     Reference oRefLine1StartPt = oPart.CreateReferenceFromObject(oCurrentLine1.StartPoint);
     Reference oRefLine1EndPt = oPart.CreateReferenceFromObject(oCurrentLine1.EndPoint);
     Reference oRefLine2StartPt = oPart.CreateReferenceFromObject(oCurrentLine2.StartPoint);
     Reference oRefLine2EndPt = oPart.CreateReferenceFromObject(oCurrentLine2.EndPoint);
     Reference oRefCircle1StartPt = oPart.CreateReferenceFromObject(oCurrentCircle1.StartPoint);
     Reference oRefCircle1EndPt = oPart.CreateReferenceFromObject(oCurrentCircle1.EndPoint);
     Reference oRefCircle2StartPt = oPart.CreateReferenceFromObject(oCurrentCircle2.StartPoint);
     Reference oRefCircle2EndPt = oPart.CreateReferenceFromObject(oCurrentCircle2.EndPoint);
     Constraints oConstraints = oCurrentSketch.Constraints;
     Constraint oConstraint = oConstraints.AddMonoEltCst(CatConstraintType.catCstTypeReference, oRefCircle1);
     oConstraint = oConstraints.AddMonoEltCst(CatConstraintType.catCstTypeReference, oRefCircle2);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeTangency, oRefLine1, oRefCircle1);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeTangency, oRefCircle2, oRefLine1);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeOn, oRefCircle1StartPt, oRefLine1StartPt);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeOn, oRefCircle2EndPt, oRefLine1EndPt);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeTangency, oRefLine2, oRefCircle1);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeTangency, oRefLine2, oRefCircle2);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeOn, oRefCircle1EndPt, oRefLine2StartPt);
     oConstraint = oConstraints.AddBiEltCst(CatConstraintType.catCstTypeOn, oRefCircle2StartPt, oRefLine2EndPt);
     oCurrentSketch.CloseEdition();
     ShapeFactory oShapeFactory = (ShapeFactory)oPart.ShapeFactory;
     Pad oPad = oShapeFactory.AddNewPad ( oCurrentSketch,  iCamThickness + iCurrentLevel );
     oPad.SecondLimit.Dimension.Value = iCurrentLevel*-1;
 }
Ejemplo n.º 3
0
            public bool IsInside(CartesianPoint point)
            {
                // Shapes
                var rectHull    = new Rectangular2DBoundary(minX, maxX, minY, maxY);
                var leftCircle  = new Circle2D(new CartesianPoint(leftHoleX, leftHoleY), holeRadius);
                var rightCircle = new Circle2D(new CartesianPoint(rightHoleX, rightHoleY), holeRadius);

                // Intrnal points lie inside the rectangle, but outside the circular holes.
                if (rectHull.IsInside(point))
                {
                    if (leftCircle.FindRelativePositionOfPoint(point) == CirclePointPosition.Outside)
                    {
                        return(true);
                    }
                    if (rightCircle.FindRelativePositionOfPoint(point) == CirclePointPosition.Outside)
                    {
                        return(true);
                    }
                }
                return(false);
            }
Ejemplo n.º 4
0
        public SEC()
        {
            referencepointService = new ReferencepointService(new ReferencepointRepository(new FruitFlyContext()));
            GetAllPoints().Wait();

            // Make the clusters
            clusters  = new List <Point2D> [k];
            centroids = new Circle2D[k];

            // Select k points from points and set them as centroids.
            // Also create the clusters
            for (int i = 0; i < k; i++)
            {
                clusters[i]  = new List <Point2D>();
                centroids[i] = new Circle2D(new Point2D(0, 0), 0);

                // @TODO make the point selection random
                // Create the center of the SEC.
                centroids[i].p.x = points[i].x;
                centroids[i].p.y = points[i].y;
            }
        }
        public void setMittelpunkt(double a, double i)
        {
            // Skizze umbenennen
            hsp_catiaProfil.set_Name("Kreis");

            // Rechteck in Skizze einzeichnen
            // Skizze oeffnen
            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();
            Factory2D catFactory2D2 = hsp_catiaProfil.OpenEdition();

            // Kreis erzeugen
            // erst die Punkte


            Circle2D circle2D = catFactory2D1.CreateCircle(0, 0, i, 0, 0);
            Circle2D circle3D = catFactory2D2.CreateCircle(0, 0, a, 0, 0);

            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();
        }
        public bool ErzeugeProfilTascheRohr(Double innendurchmesser, bool skizzeerstellt)
        {
            if (skizzeerstellt == true)
            {
                if (innendurchmesser > 0)
                {
                    // Skizze umbenennen
                    catiaSketch1.set_Name("Rohrinnen");

                    // Rechteck in Skizze einzeichnen
                    // Skizze oeffnen
                    Factory2D catFactory2D1 = catiaSketch1.OpenEdition();

                    Circle2D circle2D1   = catFactory2D1.CreateClosedCircle(0.000000, 0.000000, innendurchmesser / 2);
                    Point2D  catPoint2D1 = catFactory2D1.CreatePoint(0, 0);
                    circle2D1.CenterPoint = catPoint2D1;

                    catiaSketch1.CloseEdition();
                    catiaPart.Part.Update();
                    skizzeerstellt = true;
                }
                else
                {
                    MessageBox.Show("Fehler beim Erstellen des Profils:\rDie Werte dürfen nicht null sein!");
                    skizzeerstellt = false;
                }
            }
            else
            {
                MessageBox.Show("Fehler beim Erstellen des Profils:\rEs konnte keine Skizze erstellt werden!");
                skizzeerstellt = false;
            }


            return(skizzeerstellt);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// If a fixed enrichment area is applied, all nodes inside a circle around the tip are enriched with tip
        /// functions. They can still be enriched with Heaviside functions, if they do not belong to the tip
        /// element(s).
        /// </summary>
        /// <param name="tipNodes"></param>
        /// <param name="tipElement"></param>
        private void ApplyFixedEnrichmentArea(HashSet <XNode> tipNodes, XContinuumElement2D tipElement)
        {
            if (tipEnrichmentAreaRadius > 0)
            {
                var enrichmentArea = new Circle2D(crackTip, tipEnrichmentAreaRadius);
                foreach (var element in Mesh.FindElementsInsideCircle(enrichmentArea, tipElement))
                {
                    bool completelyInside = true;
                    foreach (var node in element.Nodes)
                    {
                        CirclePointPosition position = enrichmentArea.FindRelativePositionOfPoint(node);
                        if ((position == CirclePointPosition.Inside) || (position == CirclePointPosition.On))
                        {
                            tipNodes.Add(node);
                        }
                        else
                        {
                            completelyInside = false;
                        }
                    }
                    if (completelyInside)
                    {
                        element.EnrichmentItems.Add(CrackTipEnrichments);
                    }
                }

                #region alternatively

                /* // If there wasn't a need to enrich the elements, this is more performant
                 * foreach (var node in mesh.FindNodesInsideCircle(enrichmentArea, true, tipElement))
                 * {
                 *  tipNodes.Add(node); // Nodes of tip element(s) will not be included twice
                 * } */
                #endregion
            }
        }
Ejemplo n.º 8
0
 public void setUp()
 {
     center = new Point2D(12.0d, 14.0d);
     testCircle = new Circle2D(center, 10.0d);
     zeroPoint = new Point2D(0.0d, 0.0d);
 }
Ejemplo n.º 9
0
 public static void CreatePatternBearing()
 {
     oCurrentSketch = oPartBody.Sketches.Add ( oPlaneYZ );
     Factory2D oFactory2D = oCurrentSketch.OpenEdition();
     oCurrentCircle1 = oFactory2D.CreateClosedCircle ( iCenterX, iCenterY, iBearingDiam/2 );
     oCurrentSketch.CloseEdition();
     ShapeFactory oShapeFactory = (ShapeFactory)oPart.ShapeFactory;
     Pad oPad = oShapeFactory.AddNewPad ( oCurrentSketch,  iBearingLength );
     OriginElements originElements1 = oPart.OriginElements;
     Reference oRefPlaneXY = oPart.CreateReferenceFromGeometry( oPart.OriginElements.PlaneXY );
     RectPattern rectPattern1 = oShapeFactory.AddNewRectPattern(oPad,iNumberOfCylinders+1,1,iCylinderSpacing,0,1,1,oRefPlaneXY,oRefPlaneXY,true,true,0);
     iCurrentLevel =  iBearingLength;
 }
Ejemplo n.º 10
0
        private void button1_Click(object sender, EventArgs e)
        {
            INFITF.Application Catia;


            try
            {
                Catia = (INFITF.Application)Marshal.GetActiveObject("CATIA.Application");
            }


            catch
            {
                Catia         = (INFITF.Application)Activator.CreateInstance(Type.GetTypeFromProgID("CATIA.Application"));
                Catia.Visible = true;
            }
            INFITF.Documents Docts = Catia.Documents;

            MECMOD.PartDocument PrtDoc = (MECMOD.PartDocument)Docts.Add("Part");

            MECMOD.Part Prt = PrtDoc.Part;

            MECMOD.Bodies Bodis = Prt.Bodies;

            MECMOD.Body PartBody = Bodis.Item(1);

            MECMOD.Body Body = Bodis.Add();

            MECMOD.Sketches Skts = Body.Sketches;


            INFITF.Reference plane = (INFITF.Reference)Prt.OriginElements.PlaneXY;

            MECMOD.Sketch Skt = Skts.Add(plane);

            MECMOD.Factory2D Fac2D = Skt.OpenEdition();



            Point2D Pt1 = Fac2D.CreatePoint(50, 50);
            Point2D Pt2 = Fac2D.CreatePoint(50, 100);
            Point2D Pt3 = Fac2D.CreatePoint(100, 100);
            Point2D Pt4 = Fac2D.CreatePoint(100, 50);


            //  <<  Create Line >>
            Line2D Lin1 = Fac2D.CreateLine(50, 50, 50, 100);

            Line2D Lin2 = Fac2D.CreateLine(50, 100, 100, 100);

            Line2D Lin3 = Fac2D.CreateLine(100, 100, 100, 50);

            Line2D Lin4 = Fac2D.CreateLine(100, 50, 50, 50);

            //     Line2D Lin22 = MCreateLine(Fac2d, Pt1, Pt2);



            //라인의 시작점부터 마지막점을 결정

            Lin1.StartPoint = Pt1;
            Lin1.EndPoint   = Pt2;
            Lin2.StartPoint = Pt2;
            Lin2.EndPoint   = Pt3;
            Lin3.StartPoint = Pt3;
            Lin3.EndPoint   = Pt4;
            Lin4.StartPoint = Pt4;
            Lin4.EndPoint   = Pt1;

            INFITF.Reference rline1 = Prt.CreateReferenceFromGeometry(Lin1);
            INFITF.Reference rline2 = Prt.CreateReferenceFromGeometry(Lin2);
            INFITF.Reference rline3 = Prt.CreateReferenceFromGeometry(Lin3);
            INFITF.Reference rline4 = Prt.CreateReferenceFromGeometry(Lin4);
            INFITF.Reference rlineH = Prt.CreateReferenceFromGeometry(Skt.AbsoluteAxis.HorizontalReference);
            INFITF.Reference rlineV = Prt.CreateReferenceFromGeometry(Skt.AbsoluteAxis.VerticalReference);

            MECMOD.Constraint d1 = Skt.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rline1, rline3);
            MECMOD.Constraint d2 = Skt.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rline2, rline4);
            MECMOD.Constraint d3 = Skt.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rlineH, rline4);
            MECMOD.Constraint d4 = Skt.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rlineV, rline1);

            Skt.CloseEdition();//Skech조건 끝 //

            //PAD를 하기 위해서 조건문을 만든다.//
            PARTITF.ShapeFactory ShpFac = (PARTITF.ShapeFactory)Prt.ShapeFactory;
            //그 shapeFactory를 돌출하기 위해서 AddNewPad를 사용해서 50만큼 돌출한다.//
            ShpFac.AddNewPad(Skt, 50);



            //새로운 Body2를 만들기 //
            MECMOD.Body Body2 = Bodis.Add();
            //planed을 기준으로 Skt2를 만든다.//
            MECMOD.Sketch Skt2 = (MECMOD.Sketch)Body2.Sketches.Add(plane);
            //스켓이 시작 //
            Fac2D = Skt2.OpenEdition();
            //  X=75,Y=75 를 중심으로 D=20의  원을  만들기//
            Circle2D Cir2D = Fac2D.CreateClosedCircle(75, 75, 20);

            //스켓을 끝내기//
            Skt2.CloseEdition();
            //PAD  80만큼 //
            ShpFac.AddNewPad(Skt2, 80);

            //Body3 만들기 //
            Body Body3 = Prt.Bodies.Add();
            //Skt3를 Body2 안에 plane면을 기준으로  Sketche를 한다.
            Sketch Skt3 = Body2.Sketches.Add(plane);

            //스킷을 시작//
            Fac2D = Skt3.OpenEdition();
            //  X=75,Y=75 를 중심으로 D=5의  원을  만들기//
            Fac2D.CreateClosedCircle(75, 75, 5);
            //스켓3을 끝내기//
            Skt3.CloseEdition();
            //스켓3을 80만큼 PAD를 한다.
            ShpFac.AddNewPad(Skt3, 80);
            /////////////////
            //PartBody에 Prat In Work Object를 사용해서 조건을 만든다.
            Prt.InWorkObject = PartBody;

            ShpFac.AddNewAdd(Body);     //PartBody에 Body를추가
            ShpFac.AddNewAdd(Body2);    //PartBody에 Body2를추가
            ShpFac.AddNewRemove(Body3); //PartBody에 Body3를 제거한다


            Prt.Update();
        }
Ejemplo n.º 11
0
 public bool collide(Circle2D r)
 {
     return((r.Radius + Radius) >= (r.Center - Center).magnitude);
 }
Ejemplo n.º 12
0
        static void Main(string[] args)
        {
            INFITF.Application catia;
            try
            {
                catia = (INFITF.Application)Marshal.GetActiveObject("CATIA.Appication");
            }
            catch (Exception)
            {
                catia = (INFITF.Application)Activator.CreateInstance(Type.GetTypeFromProgID("CATIA.Application"));
            }
            catia.Visible = true;
            //open the file
            PartDocument prtDoc = (PartDocument)catia.Documents.Open(@"C:\Users\517-11\Desktop\saori\Automation\Catia-v5-Automation\DraftingAABoltUsingScript\7_Drafting_the_bolt\Bolt.CATPart");

            DrawingDocument drwDoc = (DrawingDocument)catia.Documents.Open(@"C:\Users\517-11\Desktop\saori\Automation\Catia-v5-Automation\DraftingAABoltUsingScript\7_Drafting_the_bolt\TitleBlock.CATDrawing");
            //3.get the active sheet
            DrawingSheet drwSheet = drwDoc.DrawingRoot.ActiveSheet;

            ////4. add a new view------------------------------------------------
            DrawingView FrntView = drwSheet.Views.Add("Front View");

            //5.Translate the view x;400 y;150
            FrntView.x = 400;
            FrntView.y = 150;
            //6.get the generativeBehavior
            DrawingViewGenerativeBehavior FrntVwGB = FrntView.GenerativeBehavior;

            // define a front view with the xy plan 1,0,0,0,1,0
            FrntVwGB.DefineFrontView(1, 0, 0, 0, 1, 0);
            //7.assouciated the 3d docuemnt(bolt) with this view.
            //ref; DrawingViewGenerativeBehavior (Object)
            //PartDocument prtToDoc = (PartDocument)catia.Documents.Item("CATPart1");
            //FrntView.GenerativeBehavior.Document = prtToDoc;
            FrntView.GenerativeBehavior.Document = prtDoc;

            //8.Add a top view x;400 y;600------------------------------------
            DrawingView Topvw = drwSheet.Views.Add("TopView");

            Topvw.x = 400;
            Topvw.y = 600;
            DrawingViewGenerativeBehavior TopVwGB = Topvw.GenerativeBehavior;

            TopVwGB.DefineProjectionView(TopVwGB, CatProjViewType.catTopView);
            //9. assouciated the 3d docuemnt(bolt) with this view.
            Topvw.GenerativeBehavior.Document = prtDoc;

            //10.  Activate the view -----------------------------------
            //& get its Factory2D to create a circle int each view.
            //C1(30,30,10) c2(30,,)
            FrntView.Activate();
            Factory2D facF = FrntView.Factory2D;
            Circle2D  c1   = facF.CreateClosedCircle(30, 30, 10);

            Topvw.Activate();
            Factory2D facT = Topvw.Factory2D;
            Circle2D  c2   = facT.CreateClosedCircle(30, 30, 20);


            //text 추가하기---------------
            FrntView.Activate();
            DrawingText Ftxt = FrntView.Texts.Add("Front View", 100, 100);

            Ftxt.SetFontSize(0, 0, 12);

            DrawingLeader FDleadr = Ftxt.Leaders.Add(0, 0);

            //txt cnrk--------------------
            Topvw.Activate();
            DrawingText Ttxt = Topvw.Texts.Add("Top View", -45, 130);

            Ttxt.SetFontSize(0, 0, 12);

            DrawingLeader TDleadr = Ttxt.Leaders.Add(0, 0);

            //table추가하기
            DrawingTable table = FrntView.Tables.Add(100, 80, 2, 3, 14, 40);

            //table.

            //11. update the drawing document.
            drwDoc.Update();
        }
Ejemplo n.º 13
0
 internal static AreaCode Intersect(Rectangle2D rectangle2D, Circle2D circle2D)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 14
0
        public void ErzeugeProfil(Zahnrad Zahnrad1)
        {
            // geometrisches Set auswaehlen und umbenennen
            HybridBodies catHybridBodies1 = hsp_catiaPart.Part.HybridBodies;
            HybridBody   catHybridBody1;

            try
            {
                catHybridBody1 = catHybridBodies1.Item("Geometrisches Set.1");
            }
            catch (Exception)
            {
                MessageBox.Show("Kein geometrisches Set gefunden! " + Environment.NewLine +
                                "Ein PART manuell erzeugen und ein darauf achten, dass 'Geometisches Set' aktiviert ist.",
                                "Fehler", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }
            catHybridBody1.set_Name("Profile");
            // neue Skizze im ausgewaehlten geometrischen Set anlegen
            Sketches       catSketches1      = catHybridBody1.HybridSketches;
            OriginElements catOriginElements = hsp_catiaPart.Part.OriginElements;
            Reference      catReference1     = (Reference)catOriginElements.PlaneYZ;

            hsp_catiaProfil = catSketches1.Add(catReference1);

            // Achsensystem in Skizze erstellen
            ErzeugeAchsensystem();

            // Part aktualisieren
            hsp_catiaPart.Part.Update();

            //Nullpunkt
            double x0 = 0;
            double y0 = 0;

            //Hilfsgrößen von Wilkos PDF
            double Teilkreisradius   = Zahnrad1.d / 2;
            double Hilfskreisradius  = Teilkreisradius * 0.94;
            double Fußkreisradius    = Teilkreisradius - (1.25 * Zahnrad1.m);
            double Kopfkreisradius   = Teilkreisradius + Zahnrad1.m;
            double Verrundungsradius = 0.35 * Zahnrad1.m;

            double Alpha         = 20;
            double Beta          = 90 / Zahnrad1.z;
            double Betarad       = Math.PI * Beta / 180;
            double Gamma         = 90 - (Alpha - Beta);
            double Gammarad      = Math.PI * Gamma / 180;
            double Totalangel    = 360.0 / Zahnrad1.z;
            double Totalangelrad = Math.PI * Totalangel / 180;


            //Punkte
            //LinkerEvolKreis Mittelp. Koordinaten
            double xMPEvo_links = Hilfskreisradius * Math.Cos(Gammarad);
            double yMPEvo_links = Hilfskreisradius * Math.Sin(Gammarad);

            //Schnittpkt. auf Evolvente und Teilkreisradius
            double xPunktAufEvolvente = -Teilkreisradius *Math.Sin(Betarad);

            double yPunktAufEvolvente = Teilkreisradius * Math.Cos(Betarad);

            //Evolventenkreis Radius
            double EvolventenkreisRadius = Math.Sqrt(Math.Pow((xMPEvo_links - xPunktAufEvolvente), 2) + Math.Pow((yMPEvo_links - yPunktAufEvolvente), 2));

            //Koordinaten Schnittpunkt Kopfkreis und Evolventenkreis
            double xEvolventenkopfkreis_links = Schnittpunkt_X(x0, y0, Kopfkreisradius, xMPEvo_links, yMPEvo_links, EvolventenkreisRadius);
            double yEvolventenkopfkreis_links = Schnittpunkt_Y(x0, y0, Kopfkreisradius, xMPEvo_links, yMPEvo_links, EvolventenkreisRadius);

            //Mittelpunktkoordinaten Verrundung
            double xMittelpunktVerrundung_links = Schnittpunkt_X(x0, y0, Fußkreisradius + Verrundungsradius, xMPEvo_links, yMPEvo_links, EvolventenkreisRadius + Verrundungsradius);
            double yMittelpunktVerrundung_links = Schnittpunkt_Y(x0, y0, Fußkreisradius + Verrundungsradius, xMPEvo_links, yMPEvo_links, EvolventenkreisRadius + Verrundungsradius);

            //Schnittpubktkoordinaten Verrundung - Evolventenkreis
            double x_SP_EvolventeVerrundung_links = Schnittpunkt_X(xMPEvo_links, yMPEvo_links, EvolventenkreisRadius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);
            double y_SP_EvolventeVerrundung_links = Schnittpunkt_Y(xMPEvo_links, yMPEvo_links, EvolventenkreisRadius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);

            //Schnittpunktkoordinaten Verrundung - Fußkreis
            double x_SP_FußkreisradiusVerrundung_links = Schnittpunkt_X(x0, y0, Fußkreisradius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);
            double y_SP_FußkreisradiusVerrundung_links = Schnittpunkt_Y(x0, y0, Fußkreisradius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);

            //Koordinaten Anfangspunkt Fußkreis
            double Hilfswinkel            = Totalangelrad - Math.Atan(Math.Abs(x_SP_FußkreisradiusVerrundung_links) / Math.Abs(y_SP_FußkreisradiusVerrundung_links));
            double x_AnfangspunktFußkreis = Fußkreisradius * Math.Sin(Hilfswinkel);
            double y_AnfangspunktFußkreis = Fußkreisradius * Math.Cos(Hilfswinkel);

            //Skizze umbenennen und öffnen
            hsp_catiaProfil.set_Name("Zahnradskizze");
            Factory2D catfactory2D1 = hsp_catiaProfil.OpenEdition();

            //Nun die Punkte in die Skizze
            Point2D Ursprung = catfactory2D1.CreatePoint(x0, y0);
            Point2D EndpunktEvolventenkreis = catfactory2D1.CreatePoint(x_AnfangspunktFußkreis, y_AnfangspunktFußkreis);
            Point2D VerrundungLinksAnfang   = catfactory2D1.CreatePoint(x_SP_FußkreisradiusVerrundung_links, y_SP_FußkreisradiusVerrundung_links);
            Point2D VerrundungRechtsEnde    = catfactory2D1.CreatePoint(-x_SP_FußkreisradiusVerrundung_links, y_SP_FußkreisradiusVerrundung_links);
            Point2D MPVerrundungLinks       = catfactory2D1.CreatePoint(xMittelpunktVerrundung_links, yMittelpunktVerrundung_links);
            Point2D MPVerrundungRechts      = catfactory2D1.CreatePoint(-xMittelpunktVerrundung_links, yMittelpunktVerrundung_links);
            Point2D VerrundungEndeLinks     = catfactory2D1.CreatePoint(x_SP_EvolventeVerrundung_links, y_SP_EvolventeVerrundung_links);
            Point2D VerrundungAnfangRechts  = catfactory2D1.CreatePoint(-x_SP_EvolventeVerrundung_links, y_SP_EvolventeVerrundung_links);
            Point2D MPEvolventeLinks        = catfactory2D1.CreatePoint(xMPEvo_links, yMPEvo_links);
            Point2D MPEvolventeRechts       = catfactory2D1.CreatePoint(-xMPEvo_links, yMPEvo_links);
            Point2D EvolventenEndeLinks     = catfactory2D1.CreatePoint(xEvolventenkopfkreis_links, yEvolventenkopfkreis_links);
            Point2D EvolventenEndeRechts    = catfactory2D1.CreatePoint(-xEvolventenkopfkreis_links, yEvolventenkopfkreis_links);

            //Kreise

            Circle2D Fußkreis = catfactory2D1.CreateCircle(x0, y0, Fußkreisradius, 0, Math.PI * 2);

            Fußkreis.CenterPoint = Ursprung;
            Fußkreis.StartPoint  = EndpunktEvolventenkreis;
            Fußkreis.EndPoint    = VerrundungRechtsEnde;

            Circle2D VerrundungLinks = catfactory2D1.CreateCircle(xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius, 0, Math.PI * 2);

            VerrundungLinks.CenterPoint = MPVerrundungLinks;
            VerrundungLinks.StartPoint  = VerrundungLinksAnfang;
            VerrundungLinks.EndPoint    = VerrundungEndeLinks;

            Circle2D EvolventenkreisLinks = catfactory2D1.CreateCircle(xMPEvo_links, yMPEvo_links, EvolventenkreisRadius, 0, Math.PI * 2);

            EvolventenkreisLinks.CenterPoint = MPEvolventeLinks;
            EvolventenkreisLinks.StartPoint  = EvolventenEndeLinks;
            EvolventenkreisLinks.EndPoint    = VerrundungEndeLinks;

            Circle2D Kopfkreis = catfactory2D1.CreateCircle(x0, y0, Kopfkreisradius, 0, Math.PI * 2);

            Kopfkreis.CenterPoint = Ursprung;
            Kopfkreis.StartPoint  = EvolventenEndeRechts;
            Kopfkreis.EndPoint    = EvolventenEndeLinks;

            Circle2D EvolventenkreisRechts = catfactory2D1.CreateCircle(-xMPEvo_links, yMPEvo_links, EvolventenkreisRadius, 0, Math.PI * 2);

            EvolventenkreisRechts.CenterPoint = MPEvolventeRechts;
            EvolventenkreisRechts.StartPoint  = VerrundungAnfangRechts;
            EvolventenkreisRechts.EndPoint    = EvolventenEndeRechts;

            Circle2D VerrundungRechts = catfactory2D1.CreateCircle(-xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius, 0, Math.PI * 2);

            VerrundungRechts.CenterPoint = MPVerrundungRechts;
            VerrundungRechts.StartPoint  = VerrundungAnfangRechts;
            VerrundungRechts.EndPoint    = VerrundungRechtsEnde;

            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();

            ShapeFactory       shapeFactory1       = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;
            HybridShapeFactory hybridShapeFactory1 = (HybridShapeFactory)hsp_catiaPart.Part.HybridShapeFactory;

            Factory2D factory2D1 = hsp_catiaProfil.Factory2D;

            HybridShapePointCoord ursprung    = hybridShapeFactory1.AddNewPointCoord(0, 0, 0);
            Reference             refUrsprung = hsp_catiaPart.Part.CreateReferenceFromObject(ursprung);

            HybridShapeDirection xRichtung    = hybridShapeFactory1.AddNewDirectionByCoord(1, 0, 0);
            Reference            refxRichtung = hsp_catiaPart.Part.CreateReferenceFromObject(xRichtung);

            CircPattern kreismuster = shapeFactory1.AddNewSurfacicCircPattern(factory2D1, 1, 2, 0, 0, 1, 1, refUrsprung, refxRichtung, false, 0, true, false);

            kreismuster.CircularPatternParameters = CatCircularPatternParameters.catInstancesandAngularSpacing;
            AngularRepartition angularRepartition1 = kreismuster.AngularRepartition;
            Angle angle1 = angularRepartition1.AngularSpacing;

            angle1.Value = Convert.ToDouble(360 / Zahnrad1.z);
            AngularRepartition angularRepartition2 = kreismuster.AngularRepartition;
            IntParam           intParam1           = angularRepartition2.InstancesCount;

            intParam1.Value = Convert.ToInt32(Zahnrad1.z) + 1;


            //Kreismusterenden verbinden

            Reference           refKreismuster = hsp_catiaPart.Part.CreateReferenceFromObject(kreismuster);
            HybridShapeAssemble verbindung     = hybridShapeFactory1.AddNewJoin(refKreismuster, refKreismuster);
            Reference           refVerbindung  = hsp_catiaPart.Part.CreateReferenceFromObject(verbindung);

            hybridShapeFactory1.GSMVisibility(refVerbindung, 0);

            hsp_catiaPart.Part.MainBody.InsertHybridShape(verbindung);

            hsp_catiaPart.Part.Update();

            ErzeugeBlock(Zahnrad1, refVerbindung, shapeFactory1);


            Sketches       sketchesBohrung   = catHybridBody1.HybridSketches;
            OriginElements catoriginelements = hsp_catiaPart.Part.OriginElements;
            Reference      refmxPlaneX       = (Reference)catoriginelements.PlaneYZ;

            hsp_catiaProfil = catSketches1.Add(refmxPlaneX);

            ErzeugeAchsensystem();

            hsp_catiaPart.Part.Update();

            hsp_catiaProfil.set_Name("Bohrung");

            Factory2D catfactory2D2 = hsp_catiaProfil.OpenEdition();

            Circle2D KreisFürBohrungsskizze = catfactory2D2.CreateClosedCircle(x0, y0, Zahnrad1.bd / 2);

            hsp_catiaProfil.CloseEdition();

            hsp_catiaPart.Part.Update();

            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;
            Pocket Tasche = shapeFactory1.AddNewPocket(hsp_catiaProfil, Zahnrad1.b);

            hsp_catiaPart.Part.Update();
        }
Ejemplo n.º 15
0
        //InnenVerzahnung
        public void ErstelleProfilInnen(Data dat)
        {
            //geometrisches set auswählen und umbenennen
            HybridBodies catHybridBodies_I = hsp_catiaPart.Part.HybridBodies;
            HybridBody   catHybridBody_I;

            try
            {
                catHybridBody_I = catHybridBodies_I.Item("Geometrisches Set.1");
            }
            catch (Exception)
            {
                MessageBox.Show("Kein geometrisches Set gefunden!\nEin PART manuell erzeugen und darauf achten, dass ein 'Geometisches Set' aktiviert ist.", "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }
            catHybridBody_I.set_Name("Profile");

            //Neue Skizze im ausgewählten geometrischen Set anlegen
            Sketches       catSketches_I       = catHybridBody_I.HybridSketches;
            OriginElements catOriginElements_I = hsp_catiaPart.Part.OriginElements;
            Reference      catReference_I      = (Reference)catOriginElements_I.PlaneYZ;

            hsp_catiaProfil = catSketches_I.Add(catReference_I);

            //Achsensystem in Skizze erzeugen
            ErzeugeAchsensystem();

            //Part aktualisieren
            hsp_catiaPart.Part.Update();

            hsp_catiaProfil.set_Name("InnenverzahnungBlock");
            Factory2D catFactory_I = hsp_catiaProfil.OpenEdition();

            Circle2D catC2D_I = catFactory_I.CreateClosedCircle(0, 0, dat.getFußkreisdurchmesser_iZahnrad1());

            hsp_catiaProfil.CloseEdition();
            hsp_catiaPart.Part.Update();

            ShapeFactory       SF_I  = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;
            HybridShapeFactory HSF_I = (HybridShapeFactory)hsp_catiaPart.Part.HybridShapeFactory;

            //Erzeuge Block aus Skizze
            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;
            Pad myPad = SF_I.AddNewPad(hsp_catiaProfil, dat.getBreiteZahnrad1());

            hsp_catiaPart.Part.Update();



            //Neue Skizze im ausgewählten geometrischen Set anlegen
            Sketches       catSketches1      = catHybridBody_I.HybridSketches;
            OriginElements catOriginElements = hsp_catiaPart.Part.OriginElements;
            Reference      catReference1     = (Reference)catOriginElements.PlaneYZ;

            hsp_catiaProfil = catSketches1.Add(catReference1);

            //Achsensystem in Skizze erzeugen
            ErzeugeAchsensystem();

            //Part aktualisieren
            hsp_catiaPart.Part.Update();


            //HilfsRadien
            double d_r  = (dat.getModulZahnrad1() * dat.getZaehnezahlZahnrad1()) / 2;
            double hk_r = d_r * 1.06;
            double da_r = d_r - (1.25 * dat.getModulZahnrad1());
            double df_r = d_r + dat.getModulZahnrad1();
            double vd_r = 0.35 * dat.getModulZahnrad1();

            //HilfsWinkel
            double alpha   = 20;
            double beta    = 90 / dat.getZaehnezahlZahnrad1();
            double beta_r  = Math.PI * beta / 180;
            double gamma   = 90 - (alpha - beta);
            double gamma_r = Math.PI * gamma / 180;
            double ta      = 360.0 / dat.getZaehnezahlZahnrad1();
            double ta_r    = Math.PI * ta / 180;

            //Nullpunkte
            double x0 = 0;
            double y0 = 0;

            //MittelPunkt EvolventenKreis
            double MP_EvolventenKreis_x = hk_r * Math.Cos(gamma_r);
            double MP_EvolventenKreis_y = hk_r * Math.Sin(gamma_r);

            // SchnittPunkt Evolventenkreis & Teilkreisradius
            double SP_EvolventenTeilKreis_x = -d_r *Math.Sin(beta_r);

            double SP_EvolventenTeilKreis_y = d_r * Math.Cos(beta_r);

            //Evolventenkreis Radius
            double Evolventenkreis_r = Math.Sqrt(Math.Pow((MP_EvolventenKreis_x - SP_EvolventenTeilKreis_x), 2) + Math.Pow((MP_EvolventenKreis_y - SP_EvolventenTeilKreis_y), 2));

            //SchnittPunkt Evolventenkreis & Kopfkreisradius
            double SP_EvolventenKopfKreis_x = Schnittpunkt_x(x0, y0, da_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r);
            double SP_EvolventenKopfKreis_y = Schnittpunkt_y(x0, y0, da_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r);

            //MittelPunkt VerrundungsRadius
            double MP_Verrundung_x = Schnittpunkt_x(x0, y0, df_r + vd_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r + vd_r);
            double MP_Verrundung_y = Schnittpunkt_y(x0, y0, df_r + vd_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r + vd_r);

            //SchnittPunkt Evolventenkreis & Verrundungsradius
            double SP_EvolventeVerrundung_x = Schnittpunkt_x(MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);
            double SP_EvolventeVerrundung_y = Schnittpunkt_y(MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);

            //SchnittPunkt Fußkreis & Verrundungs Radius
            double SP_FußkreisVerrundungsRadius_x = Schnittpunkt_x(x0, y0, df_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);
            double SP_FußkreisVerrundungsRadius_y = Schnittpunkt_y(x0, y0, df_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);

            //StartPunkt Fußkreis Radius
            double phi = ta_r - Math.Atan(Math.Abs(SP_FußkreisVerrundungsRadius_x) / Math.Abs(SP_FußkreisVerrundungsRadius_y));
            double StartPkt_Fußkreis_x = -df_r *Math.Sin(phi);

            double StartPkt_Fußkreis_y = df_r * Math.Cos(phi);

            //Skizze umbenennen und öffnen
            hsp_catiaProfil.set_Name("InnenverzahnungEinzel");
            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();

            //Punkte
            Point2D catP2D_Ursprung = catFactory2D1.CreatePoint(x0, y0);

            Point2D catP2D_StartPkt_Fußkreis             = catFactory2D1.CreatePoint(StartPkt_Fußkreis_x, StartPkt_Fußkreis_y);
            Point2D catP2D_SP_FußkreisVerrundungsRadius1 = catFactory2D1.CreatePoint(SP_FußkreisVerrundungsRadius_x, SP_FußkreisVerrundungsRadius_y);
            Point2D catP2D_SP_FußkreisVerrundungsRadius2 = catFactory2D1.CreatePoint(-SP_FußkreisVerrundungsRadius_x, SP_FußkreisVerrundungsRadius_y);

            Point2D catP2D_MP_EvolventenKreis1 = catFactory2D1.CreatePoint(MP_EvolventenKreis_x, MP_EvolventenKreis_y);
            Point2D catP2D_MP_EvolventenKreis2 = catFactory2D1.CreatePoint(-MP_EvolventenKreis_x, MP_EvolventenKreis_y);

            Point2D catP2D_SP_EvolventenKopfKreis1 = catFactory2D1.CreatePoint(SP_EvolventenKopfKreis_x, SP_EvolventenKopfKreis_y);
            Point2D catP2D_SP_EvolventenKopfKreis2 = catFactory2D1.CreatePoint(-SP_EvolventenKopfKreis_x, SP_EvolventenKopfKreis_y);

            Point2D catP2D_MP_Verrundung1 = catFactory2D1.CreatePoint(MP_Verrundung_x, MP_Verrundung_y);
            Point2D catP2D_MP_Verrundung2 = catFactory2D1.CreatePoint(-MP_Verrundung_x, MP_Verrundung_y);

            Point2D catP2D_SP_EvolventeVerrundung1 = catFactory2D1.CreatePoint(SP_EvolventeVerrundung_x, SP_EvolventeVerrundung_y);
            Point2D catP2D_SP_EvolventeVerrundung2 = catFactory2D1.CreatePoint(-SP_EvolventeVerrundung_x, SP_EvolventeVerrundung_y);


            //Kreise
            Circle2D catC2D_Frußkreis = catFactory2D1.CreateCircle(x0, y0, df_r, 0, 0);

            catC2D_Frußkreis.CenterPoint = catP2D_Ursprung;
            catC2D_Frußkreis.StartPoint  = catP2D_SP_FußkreisVerrundungsRadius1;
            catC2D_Frußkreis.EndPoint    = catP2D_StartPkt_Fußkreis;

            Circle2D catC2D_Kopfkreis = catFactory2D1.CreateCircle(x0, y0, da_r, 0, 0);

            catC2D_Kopfkreis.CenterPoint = catP2D_Ursprung;
            catC2D_Kopfkreis.StartPoint  = catP2D_SP_EvolventenKopfKreis2;
            catC2D_Kopfkreis.EndPoint    = catP2D_SP_EvolventenKopfKreis1;

            Circle2D catC2D_EvolventenKreis1 = catFactory2D1.CreateCircle(MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, 0, 0);

            catC2D_EvolventenKreis1.CenterPoint = catP2D_MP_EvolventenKreis1;
            catC2D_EvolventenKreis1.StartPoint  = catP2D_SP_EvolventenKopfKreis1;
            catC2D_EvolventenKreis1.EndPoint    = catP2D_SP_EvolventeVerrundung1;

            Circle2D catC2D_Evolventenkreis2 = catFactory2D1.CreateCircle(-MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, 0, 0);

            catC2D_Evolventenkreis2.CenterPoint = catP2D_MP_EvolventenKreis2;
            catC2D_Evolventenkreis2.StartPoint  = catP2D_SP_EvolventeVerrundung2;
            catC2D_Evolventenkreis2.EndPoint    = catP2D_SP_EvolventenKopfKreis2;

            Circle2D catC2D_VerrundungsKreis1 = catFactory2D1.CreateCircle(MP_Verrundung_x, MP_Verrundung_y, vd_r, 0, 0);

            catC2D_VerrundungsKreis1.CenterPoint = catP2D_MP_Verrundung1;
            catC2D_VerrundungsKreis1.StartPoint  = catP2D_SP_FußkreisVerrundungsRadius1;
            catC2D_VerrundungsKreis1.EndPoint    = catP2D_SP_EvolventeVerrundung1;

            Circle2D catC2D_VerrundungsKreis2 = catFactory2D1.CreateCircle(-MP_Verrundung_x, MP_Verrundung_y, vd_r, 0, 0);

            catC2D_VerrundungsKreis2.CenterPoint = catP2D_MP_Verrundung2;
            catC2D_VerrundungsKreis2.StartPoint  = catP2D_SP_EvolventeVerrundung2;
            catC2D_VerrundungsKreis2.EndPoint    = catP2D_SP_FußkreisVerrundungsRadius2;

            hsp_catiaProfil.CloseEdition();

            hsp_catiaPart.Part.Update();

            //Skizze und Referenzen
            Factory2D Factory2D1 = hsp_catiaProfil.Factory2D;

            HybridShapePointCoord Ursprung    = HSF_I.AddNewPointCoord(0, 0, 0);
            Reference             RefUrsprung = hsp_catiaPart.Part.CreateReferenceFromObject(Ursprung);
            HybridShapeDirection  XDir        = HSF_I.AddNewDirectionByCoord(1, 0, 0);
            Reference             RefXDir     = hsp_catiaPart.Part.CreateReferenceFromObject(XDir);

            //Kreismuster mit Daten füllen
            CircPattern Kreismuster = SF_I.AddNewSurfacicCircPattern(Factory2D1, 1, 2, 0, 0, 1, 1, RefUrsprung, RefXDir, false, 0, true, false);

            Kreismuster.CircularPatternParameters = CatCircularPatternParameters.catInstancesandAngularSpacing;
            AngularRepartition angularRepartition1 = Kreismuster.AngularRepartition;
            Angle angle1 = angularRepartition1.AngularSpacing;

            angle1.Value = Convert.ToDouble(360 / dat.getZaehnezahlZahnrad1());
            AngularRepartition angularRepartition2 = Kreismuster.AngularRepartition;
            IntParam           intParam1           = angularRepartition2.InstancesCount;

            intParam1.Value = Convert.ToInt32(dat.getZaehnezahlZahnrad1()) + 1;

            //geschlossene Kontur
            Reference           Ref_Kreismuster = hsp_catiaPart.Part.CreateReferenceFromObject(Kreismuster);
            HybridShapeAssemble Verbindung      = HSF_I.AddNewJoin(Ref_Kreismuster, Ref_Kreismuster);
            Reference           Ref_Verbindung  = hsp_catiaPart.Part.CreateReferenceFromObject(Verbindung);

            HSF_I.GSMVisibility(Ref_Verbindung, 0);

            hsp_catiaPart.Part.Update();

            /*Bodies bodies = hsp_catiaPart.Part.Bodies;
             * Body myBody = bodies.Add();
             * myBody.set_Name("Zahnrad");
             * myBody.InsertHybridShape(Verbindung);
             *
             * hsp_catiaPart.Part.Update();*/

            //Tasche für Innenverzahnung(grob)
            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;

            Pocket catPocketInnen = SF_I.AddNewPocketFromRef(Ref_Verbindung, dat.getBreiteZahnrad1());

            hsp_catiaPart.Part.Update();
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Provides information about if the point lies in the circle.
        /// </summary>
        /// <param name="circle2D">The circle.</param>
        /// <param name="point">The point.</param>
        /// <returns>
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Unknown"/> if status is unknown.
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Disjoint"/> if the point lies outside the circle.
        /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Overlap"/> if the point lies inside or on the circle edge.
        /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.AEnclosesB"/> if the point lies inside and not on the edge.
        /// Additionally to Overlap and AEnclosesB: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Identical"/> if the point equals the centre point of the circle.
        /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Tangents"/> if the point lies on the edge of the circle.
        /// </returns>
        public static AreaCode Intersect(Circle2D circle2D, Point point)
        {
            AreaCode retval = AreaCode.Unknown;
            if (circle2D.Centre.Distance((Point)point) < circle2D.Radius)
                retval = AreaCode.Overlap | AreaCode.AEnclosesB;
            else if (circle2D.Centre.Equals(point))
                retval = AreaCode.Overlap | AreaCode.AEnclosesB | AreaCode.Identical;
            else if (circle2D.Centre.Distance((Point)point) == circle2D.Radius)
                retval = AreaCode.Overlap | AreaCode.Tangents;
            else retval = AreaCode.Disjoint;

            return retval;
        }
Ejemplo n.º 17
0
        //		private Border FindNextBorder()
        //		{
        //			// Alle Cluster enthalten zwei Punkte. Suche einen Joint, dessen angeschlossener
        //			// ICurve2D länger als maxGap ist (warum eigentlich?)
        //			// Gehe solange durch die Cluster, bis wieder der erste Punkt erreicht ist
        //			Joint StartWith = null;
        //			foreach (Cluster cl in clusterSet)
        //			{
        //				foreach (Joint lp in cl.Points)
        //				{
        //					if (lp.curve.Length>maxGap)
        //					{
        //						StartWith = lp;
        //						RemoveJoint(lp,cl);
        //						break;
        //					}
        //				}
        //				if (StartWith!=null) break;
        //			}
        //			if (StartWith==null) return null; // keinen Anfang gefunden
        //			Joint LastPoint = StartWith;
        //			Cluster goon = null;
        //			BorderBuilder makeBorder = new BorderBuilder();
        //			makeBorder.Precision = clusterSize;
        //			while ((goon = ExtractCurve(LastPoint.curve,!LastPoint.isStartPoint))!=null)
        //			{
        //				makeBorder.AddSegment(LastPoint.curve.CloneReverse(!LastPoint.isStartPoint));
        //				if (goon.Points.Count==0) break; // auf den letzten und ersten Punkt gestoßen
        //				LastPoint = (Joint)goon.Points[0]; // es sollte ja nur diesen einen geben
        //				RemoveJoint(LastPoint,goon); // damit müsste dieser Cluster verschwinden
        //			}
        //			return makeBorder.BuildBorder();
        //		}
        //		private bool FindSimpleBorder(Set clusterSet, ArrayList AllBorders, Set UsedJoints, ICurve2D startWith, bool forward)
        //		{
        //			Set tmpUsedJoints = new Set();
        //			tmpUsedJoints.Add(new UsedJoint(startWith,forward));
        //			// Anfangskante gefunden, wie gehts weiter
        //			BorderBuilder bb = new BorderBuilder();
        //			bb.Precision = clusterSize;
        //			if (forward) bb.AddSegment(startWith.Clone());
        //			else bb.AddSegment(startWith.CloneReverse(true));
        //
        //			while (!bb.IsClosed)
        //			{
        //				Cluster cl = FindCluster(startWith, bb.EndPoint, false);
        //				if (cl==null) return false; // eine angefangene Border geht nicht weiter, sollte nicht passieren, da keine Sackgassen
        //				int ind = -1;
        //				double sa = -1.0;
        //				for (int i=0; i<cl.Points.Count; ++i)
        //				{
        //					Joint j = cl.Points[i] as Joint;
        //					if (j.curve==startWith) continue; // nicht auf der Stelle rückwärts weiter
        //					UsedJoint uj = new UsedJoint(j.curve,j.isStartPoint);
        //					if (!UsedJoints.Contains(uj) && !tmpUsedJoints.Contains(uj))
        //					{
        //						SweepAngle d;
        //						if (j.isStartPoint) d = new SweepAngle(bb.EndDirection,j.curve.StartDirection);
        //						else d = new SweepAngle(bb.EndDirection,j.curve.EndDirection.Opposite());
        //						// d zwischen -PI und +PI
        //						if (d+Math.PI > sa)
        //						{	// je mehr nach links umso größer is d
        //							sa = d+Math.PI;
        //							ind = i;
        //						}
        //					}
        //				}
        //				if (ind>=0)
        //				{
        //					Joint j = cl.Points[ind] as Joint;
        //					if (j.isStartPoint) bb.AddSegment(j.curve.Clone());
        //					else bb.AddSegment(j.curve.CloneReverse(true));
        //					tmpUsedJoints.Add(new UsedJoint(j.curve,j.isStartPoint));
        //					startWith = j.curve;
        //				}
        //				else
        //				{
        //					return false; // kein weitergehen möglich
        //				}
        //			}
        //			if (bb.IsOriented)
        //			{
        //				Border bdr = bb.BuildBorder();
        //				AllBorders.Add(bdr);
        //				foreach (UsedJoint uj in tmpUsedJoints)
        //				{
        //					if (!UsedJoints.Contains(uj))
        //					{
        //						UsedJoints.Add(uj);
        //					}
        //					else
        //					{
        //						int dbg = 0;
        //					}
        //				}
        //				return true;
        //			}
        //			return false;
        //		}
        //		private bool FindSimpleBorder(Set clusterSet, ArrayList AllBorders, Set UsedJoints)
        //		{
        //			// es wird eine minimale Border gesucht: von irgend einem Cluster ausgehend immer
        //			// linksrum bis man wieder am Anfang ist.
        //			// UsedJoints enthält UsedJoint objekte, damit man feststellen kann, ob eine Kante bereits
        //			// benutzt ist oder nicht
        //			ICurve2D startWith = null;
        //			bool forward = false;
        //			foreach (Cluster cl in clusterSet)
        //			{
        //				for (int i=0; i<cl.Points.Count; ++i)
        //				{
        //					UsedJoint uj = new UsedJoint();
        //					Joint j = cl.Points[i] as Joint;
        //					uj.curve = j.curve;
        //					uj.forward = true;
        //					if (!UsedJoints.Contains(uj))
        //					{
        //						forward = j.isStartPoint;
        //						startWith = j.curve;
        //						if (FindSimpleBorder(clusterSet,AllBorders,UsedJoints,startWith,forward))
        //							return true;
        //					}
        //					uj.forward = false;
        //					if (!UsedJoints.Contains(uj))
        //					{
        //						forward = !j.isStartPoint;
        //						startWith = j.curve;
        //						if (FindSimpleBorder(clusterSet,AllBorders,UsedJoints,startWith,forward))
        //							return true;
        //					}
        //				}
        //			}
        //			return false;
        //		}
        private Joint[] SortCluster()
        {   // sortiert die Kanten (Joints) in einem Cluster im Gegenuhrzeigersinn
            // liefert alle Kanten

            // Verwerfen von identischen Kanten:
            // Zwei Kanten in einem Cluster, die das selbe "Gegencluster" haben
            // stehen im Verdacht identisch zu sein. Ihre Mittelpunkte werden auf
            // identität überprüft und die Kanten werden ggf. entfernt.
            foreach (Cluster cl in clusterSet)
            {
                for (int i = 0; i < cl.Joints.Count - 1; ++i)
                {
                    int duplicate = -1;
                    for (int j = i + 1; j < cl.Joints.Count; ++j)
                    {
                        Cluster cl1;
                        Cluster cl2;
                        Joint   j1 = cl.Joints[i] as Joint;
                        Joint   j2 = cl.Joints[j] as Joint;
                        if (j1.StartCluster == cl)
                        {
                            cl1 = j1.EndCluster;
                        }
                        else
                        {
                            cl1 = j1.StartCluster;
                        }
                        if (j2.StartCluster == cl)
                        {
                            cl2 = j2.EndCluster;
                        }
                        else
                        {
                            cl2 = j2.StartCluster;
                        }
                        if (cl1 == cl2)
                        {   // zwei Kanten verbinden dieselben Cluster. Sie könnten identisch sein
                            ICurve2D curve1 = j1.curve.CloneReverse(j1.StartCluster != cl);
                            ICurve2D curve2 = j2.curve.CloneReverse(j2.StartCluster != cl);
                            // curve1 und curve2 haben jetzt die selbe Richtung
                            GeoPoint2D p1 = curve1.PointAt(0.5);
                            GeoPoint2D p2 = curve2.PointAt(0.5);
                            if (Geometry.Dist(p1, p2) < clusterSize)
                            {
                                duplicate = j;
                                break;
                            }
                        }
                    }
                    if (duplicate > 0)
                    {
                        cl.Joints.RemoveAt(duplicate);
                    }
                }
            }
            // zu kurze Joints werden entfern
            foreach (Cluster cl in clusterSet)
            {
                for (int i = cl.Joints.Count - 1; i >= 0; --i)
                {
                    Joint j1 = cl.Joints[i] as Joint;
                    if (j1.curve.Length < this.clusterSize)
                    {
                        cl.Joints.RemoveAt(i);
                    }
                }
            }

            UntypedSet allJoints = new UntypedSet();

            foreach (Cluster cl in clusterSet)
            {
                if (cl.Joints.Count < 3)
                {
                    foreach (Joint j in cl.Joints)
                    {
                        if (!allJoints.Contains(j))
                        {
                            allJoints.Add(j);
                        }
                    }
                    continue;
                }
                // zwei Punkte im cluster muss man nicht sortieren
                double minDist = double.MaxValue;
                foreach (Joint j in cl.Joints)
                {
                    if (!allJoints.Contains(j))
                    {
                        allJoints.Add(j);
                    }
                    GeoPoint2D p;
                    if (j.StartCluster == cl)
                    {
                        p = j.EndCluster.center;
                    }
                    else
                    {
                        if (j.EndCluster != cl)
                        {
                            throw new CurveGraphException("SortCluster");
                        }
                        p = j.StartCluster.center;
                    }
                    double d = Geometry.Dist(cl.center, p);
                    if (d == 0.0)
                    {
                        if (j.StartCluster == j.EndCluster)
                        {
                            continue;
                        }
                        throw new CurveGraphException("SortCluster");
                    }
                    if (d < minDist)
                    {
                        minDist = d;
                    }
                }
                // Kreis um cl mit halber Entfernung zum nächsten Knoten als Radius
                Circle2D c2d = new Circle2D(cl.center, minDist / 2.0);
                foreach (Joint j in cl.Joints)
                {
                    GeoPoint2DWithParameter[] ip = c2d.Intersect(j.curve);
                    if (ip.Length > 0)
                    {
                        for (int i = 0; i < ip.Length; ++i)
                        {
                            if (j.curve.IsParameterOnCurve(ip[i].par2))
                            {
                                Angle a = new Angle(ip[i].p, cl.center);
                                j.tmpAngle = a.Radian;
                                break;
                            }
                        }
                    }
                    else
                    {
                        // darf nicht vorkommen, eine Kante schneidet nicht den Kreis um
                        // den Knoten mit halbem Radius zum nächsten knoten
                        // der Sortierwert bleibt halt 0.0, aber man sollte solche Kanten
                        // entfernen ...
                        // kommt vor, das Problem liegt bei regle4!!!
                        if (j.StartCluster == cl)
                        {   // curve startet hier
                            j.tmpAngle = j.curve.StartDirection.Angle;
                        }
                        else
                        {
                            j.tmpAngle = j.curve.EndDirection.Opposite().Angle;
                        }
                    }
                }
                cl.Joints.Sort(); // es wird nach tmpAngle sortiert
            }
            Joint[] res = new Joint[allJoints.Count];
            int     ii  = 0;

            foreach (Joint j in allJoints)
            {   // die Kurve exakt ausrichten
                try
                {
                    j.curve.StartPoint = j.StartCluster.center;
                    j.curve.EndPoint   = j.EndCluster.center;
                }
                catch (Curve2DException) { } // z.B. Kreise endpunkt setzen
                res[ii] = j;
                ++ii;
            }
            return(res);
        }
Ejemplo n.º 18
0
 /// <summary>
 /// Provides information about if the stroke intersects the circle.
 /// </summary>
 /// <param name="stroke">The stroke.</param>
 /// <returns>
 /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Unknown"/> if status is unknown.
 /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Disjoint"/> if the stroke lies outside the circle.
 /// <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Overlap"/> if the stroke lies inside, intersects or is a tangent of the circle.
 /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.AEnclosesB"/> if the stroke lies completely inside the circle.
 /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Intersect"/> if the stroke intersects the circle.
 /// Additionally to Overlap: <see cref="Kanji.DesktopApp.Interfaces.AreaCode.Tangents"/> if the stroke is a tangent of the circle.
 /// </returns>
 public static AreaCode Intersect(Circle2D circle2D, IStroke stroke)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 19
0
 public static AreaCode Intersect(Circle2D circle2D, Square2D square2D)
 {
     return Area.Intersect(circle2D, square2D as Rectangle2D);
 }
Ejemplo n.º 20
0
        public void SonderIPE_DrawSketch(double SonderIPE_Breite, double SonderIPE_Hoehe, double Flanschbreite, double Stegbreite)
        {
            double b  = SonderIPE_Breite;
            double h  = SonderIPE_Hoehe;
            double f  = Flanschbreite;
            double s  = Stegbreite;
            double R  = 2 * s;  // Definition des Eckenradius nach DIN 1025-2 und DIN 1025-5
            double bs = (b - s) / 2;

            CATIA_SonderIPE_2D.set_Name("I-Profil");

            Factory2D SonderIPE_Factory = CATIA_SonderIPE_2D.OpenEdition();

            // Definition der Geometrie

            // Definition der Radienmittelpunkte
            Point2D Mittelpunkt1 = SonderIPE_Factory.CreatePoint((bs - R), (f + R));
            Point2D Mittelpunkt2 = SonderIPE_Factory.CreatePoint((bs + s + R), (f + R));
            Point2D Mittelpunkt3 = SonderIPE_Factory.CreatePoint((bs + s + R), (h - f - R));
            Point2D Mittelpunkt4 = SonderIPE_Factory.CreatePoint((bs - R), (h - f - R));

            // Definition der Konturpunkte
            Point2D Konturpunkt1  = SonderIPE_Factory.CreatePoint(0, 0);
            Point2D Konturpunkt2  = SonderIPE_Factory.CreatePoint(b, 0);
            Point2D Konturpunkt3  = SonderIPE_Factory.CreatePoint(b, f);
            Point2D Konturpunkt4  = SonderIPE_Factory.CreatePoint((bs + s + R), f);
            Point2D Konturpunkt5  = SonderIPE_Factory.CreatePoint((bs + s), (f + R));
            Point2D Konturpunkt6  = SonderIPE_Factory.CreatePoint((bs + s), (h - f - R));
            Point2D Konturpunkt7  = SonderIPE_Factory.CreatePoint((bs + s + R), (h - f));
            Point2D Konturpunkt8  = SonderIPE_Factory.CreatePoint(b, (h - f));
            Point2D Konturpunkt9  = SonderIPE_Factory.CreatePoint(b, h);
            Point2D Konturpunkt10 = SonderIPE_Factory.CreatePoint(0, h);
            Point2D Konturpunkt11 = SonderIPE_Factory.CreatePoint(0, (h - f));
            Point2D Konturpunkt12 = SonderIPE_Factory.CreatePoint((bs - R), (h - f));
            Point2D Konturpunkt13 = SonderIPE_Factory.CreatePoint(bs, (h - f - R));
            Point2D Konturpunkt14 = SonderIPE_Factory.CreatePoint(bs, (f + R));
            Point2D Konturpunkt15 = SonderIPE_Factory.CreatePoint((bs - R), f);
            Point2D Konturpunkt16 = SonderIPE_Factory.CreatePoint(0, f);

            // Defintion der Linien
            Line2D Linie12 = SonderIPE_Factory.CreateLine(0, 0, b, 0);

            Linie12.StartPoint = Konturpunkt1;
            Linie12.EndPoint   = Konturpunkt2;

            Line2D Linie23 = SonderIPE_Factory.CreateLine(b, 0, b, f);

            Linie23.StartPoint = Konturpunkt2;
            Linie23.EndPoint   = Konturpunkt3;

            Line2D Linie34 = SonderIPE_Factory.CreateLine(b, f, (bs + s + R), f);

            Linie34.StartPoint = Konturpunkt3;
            Linie34.EndPoint   = Konturpunkt4;

            Line2D Linie56 = SonderIPE_Factory.CreateLine((bs + s), (f + R), (bs + s), (h - f - R));

            Linie56.StartPoint = Konturpunkt5;
            Linie56.EndPoint   = Konturpunkt6;

            Line2D Linie78 = SonderIPE_Factory.CreateLine((bs + s + R), (h - f), b, (h - f));

            Linie78.StartPoint = Konturpunkt7;
            Linie78.EndPoint   = Konturpunkt8;

            Line2D Linie89 = SonderIPE_Factory.CreateLine(b, (h - f), b, h);

            Linie89.StartPoint = Konturpunkt8;
            Linie89.EndPoint   = Konturpunkt9;

            Line2D Linie910 = SonderIPE_Factory.CreateLine(b, h, 0, h);

            Linie910.StartPoint = Konturpunkt9;
            Linie910.EndPoint   = Konturpunkt10;

            Line2D Linie1011 = SonderIPE_Factory.CreateLine(0, h, 0, (h - f));

            Linie1011.StartPoint = Konturpunkt10;
            Linie1011.EndPoint   = Konturpunkt11;

            Line2D Linie1112 = SonderIPE_Factory.CreateLine(0, (h - f), (bs - R), (h - f));

            Linie1112.StartPoint = Konturpunkt11;
            Linie1112.EndPoint   = Konturpunkt12;

            Line2D Linie1314 = SonderIPE_Factory.CreateLine(bs, (h - f - R), bs, (f + R));

            Linie1314.StartPoint = Konturpunkt13;
            Linie1314.EndPoint   = Konturpunkt14;

            Line2D Linie1516 = SonderIPE_Factory.CreateLine((bs - R), f, 0, f);

            Linie1516.StartPoint = Konturpunkt15;
            Linie1516.EndPoint   = Konturpunkt16;

            Line2D Linie161 = SonderIPE_Factory.CreateLine(0, f, 0, 0);

            Linie161.StartPoint = Konturpunkt16;
            Linie161.EndPoint   = Konturpunkt1;

            // Definition der Eckenverrundungen
            Circle2D Eckenverrundung1 = SonderIPE_Factory.CreateCircle((bs - R), (f + R), R, 0, 0);

            Eckenverrundung1.CenterPoint = Mittelpunkt1;
            Eckenverrundung1.StartPoint  = Konturpunkt15;
            Eckenverrundung1.EndPoint    = Konturpunkt14;

            Circle2D Eckenverrundung2 = SonderIPE_Factory.CreateCircle((bs + s + R), (f + R), R, 0, 0);

            Eckenverrundung2.CenterPoint = Mittelpunkt2;
            Eckenverrundung2.StartPoint  = Konturpunkt5;
            Eckenverrundung2.EndPoint    = Konturpunkt4;

            Circle2D Eckenverrundung3 = SonderIPE_Factory.CreateCircle((bs + s + R), (h - f - R), R, 0, 0);

            Eckenverrundung3.CenterPoint = Mittelpunkt3;
            Eckenverrundung3.StartPoint  = Konturpunkt7;
            Eckenverrundung3.EndPoint    = Konturpunkt6;

            Circle2D Eckenverrundung4 = SonderIPE_Factory.CreateCircle((bs - R), (h - f - R), R, 0, 0);

            Eckenverrundung4.CenterPoint = Mittelpunkt4;
            Eckenverrundung4.StartPoint  = Konturpunkt13;
            Eckenverrundung4.EndPoint    = Konturpunkt12;

            CATIA_SonderIPE_2D.CloseEdition();

            CATIA_SonderIPE_Part.Part.Update();
        }
Ejemplo n.º 21
0
// #if UNITY_EDITOR
//  public virtual void DrawGizmos (Color color)
//  {
//      GizmosManager.GizmosEntry gizmosEntry = new GizmosManager.GizmosEntry();
//      gizmosEntry.setColor = true;
//      gizmosEntry.color = color;
//      gizmosEntry.onDrawGizmos += DrawGizmos;
//      GizmosManager.gizmosEntries.Add(gizmosEntry);
//  }

//  public virtual void DrawGizmos (params object[] args)
//  {
//      Gizmos.DrawRay(start, end - start);
//  }
// #endif

    public virtual bool DoIIntersectWithCircle(Circle2D circle)
    {
        return((ClosestPoint(circle.center) - circle.center).sqrMagnitude <= circle.radius * circle.radius);
    }
        private bool showLineDiam()
        {
            ArrayList usable1Curves = new ArrayList();
            Plane     pl;
            double    mindist = double.MaxValue;

            if (tangCurves == null)
            {
                return(false);
            }
            for (int i = 0; i < tangCurves.Length; ++i)
            {
                if (tangCurves[i].GetPlanarState() == PlanarState.Planar)
                {
                    pl = tangCurves[i].GetPlane();
                }
                else
                { // Element hat keine Ebene: Eine machen, falls möglich!
                    try { pl = new Plane(tangCurves[i].StartPoint, tangCurves[i].EndPoint, circlePoint); }
                    catch (PlaneException) { break; }
                }
                if (Precision.IsPointOnPlane(radiusPoint, pl))
                {
                    ICurve2D     l2D1          = tangCurves[i].GetProjectedCurve(pl);
                    ICurve2D     l2D2          = new Circle2D(pl.Project(circlePoint), 0.0);
                    ICurve2D     l2D3          = new Circle2D(pl.Project(radiusPoint), 0.0);
                    GeoPoint2D[] tangentPoints = Curves2D.TangentCircle(l2D1, l2D2, l2D3, pl.Project(objectPoint), pl.Project(circlePoint), pl.Project(radiusPoint));
                    if (tangentPoints.Length > 0)
                    {                                     // eine gültige Linie ist gefunden
                        usable1Curves.Add(tangCurves[i]); // zur lokalen Liste zufügen
                        for (int l = 0; l < tangentPoints.Length; l += 4)
                        {
                            double dist = Geometry.Dist(tangentPoints[l + 1], pl.Project(objectPoint)) +
                                          Geometry.Dist(tangentPoints[l + 2], pl.Project(circlePoint)) +
                                          Geometry.Dist(tangentPoints[l + 3], pl.Project(radiusPoint));
                            if (dist < mindist)
                            {
                                mindist  = dist;
                                selected = usable1Curves.Count - 1; // merken, welche Kurven die aktuell benutzten sind
                                // selSol / 6 entspricht div 6, um einige Zeilen tiefer weitere 6 Möglichkeiten auswählen zu können
                                // (/ 4) und (* 4), da pro Lösung vier Punkte geliefert werden
                                int m = (l + 4 * (Math.Abs(selSol) % (tangentPoints.Length / 4))) % tangentPoints.Length;
                                center     = tangentPoints[m];
                                arcRadCalc = Geometry.Dist(tangentPoints[m + 1], center) * 2.0;
                            }
                        }
                        if (mindist < double.MaxValue)
                        {
                            //										base.MultiSolution = true;
                            base.MultiSolutionCount = tangentPoints.Length / 4;
                            arc.SetCirclePlaneCenterRadius(pl, pl.ToGlobal(center), arcRad);
                            tangCurves            = (ICurve[])usable1Curves.ToArray(typeof(ICurve)); // überschreibt die eigentliche Liste und wird unten an den Sender zurückgeliefert
                            base.ShowActiveObject = true;
                            return(true);
                        }
                    }
                }
            }
            base.ShowActiveObject   = false;
            base.MultiSolutionCount = 0;
            //            base.MultiSolution = false;
            return(false);
        }
Ejemplo n.º 23
0
        public void Stirnzahnrad(MainWindow.Außenverzahnung av)
        {
            //Profil Erstellen

            //Nullpunkt
            double x0 = 0;
            double y0 = 0;

            //Hilfsgrößen
            double Teilkreisradius   = av.d / 2;
            double Hilfskreisradius  = Teilkreisradius * 0.94;
            double Fußkreisradius    = Teilkreisradius - (1.25 * av.m);
            double Kopfkreisradius   = Teilkreisradius + av.m;
            double Verrundungsradius = 0.35 * av.m;

            double Alpha         = 2;
            double Alpharad      = Math.PI * Alpha / 180;
            double Beta          = 140 / av.z;
            double Betarad       = Math.PI * Beta / 180;
            double Gamma         = 90 - (Alpha - Beta);
            double Gammarad      = Math.PI * Gamma / 180;
            double Totalangel    = 360.0 / av.z;
            double Totalangelrad = Math.PI * Totalangel / 180;


            //Punkte
            //Kopfkreis
            double xKopfkreis = -Kopfkreisradius *Math.Sin(Alpharad);

            double yKopfkreis = Kopfkreisradius * Math.Cos(Alpharad);

            //Fußkreis
            double xFußkreis = -Fußkreisradius *Math.Sin(Betarad);

            double yFußkreis = Fußkreisradius * Math.Cos(Betarad);

            //Koordinaten Anfangspunkt Fußkreis
            double Hilfswinkel            = Totalangelrad - Math.Atan(Math.Abs(xFußkreis) / Math.Abs(yFußkreis));
            double x_AnfangspunktFußkreis = Fußkreisradius * Math.Sin(Hilfswinkel);
            double y_AnfangspunktFußkreis = Fußkreisradius * Math.Cos(Hilfswinkel);

            //Skizze umbenennen und öffnen
            hsp_catiaProfil.set_Name("Zahnradskizze");
            Factory2D catfactory2D1 = hsp_catiaProfil.OpenEdition();

            //Nun die Punkte in die Skizze
            Point2D point_Ursprung          = catfactory2D1.CreatePoint(x0, y0);
            Point2D point_KopfkreisLinks    = catfactory2D1.CreatePoint(xKopfkreis, yKopfkreis);
            Point2D point_FußkreisLinks     = catfactory2D1.CreatePoint(xFußkreis, yFußkreis);
            Point2D point_KopfkreisRechts   = catfactory2D1.CreatePoint(-xKopfkreis, yKopfkreis);
            Point2D point_FußkreisRechts    = catfactory2D1.CreatePoint(-xFußkreis, yFußkreis);
            Point2D point_AnfangspunktLinks = catfactory2D1.CreatePoint(-x_AnfangspunktFußkreis, y_AnfangspunktFußkreis);

            //Linien
            Line2D line_FußkreisKopfkreis = catfactory2D1.CreateLine(xFußkreis, yFußkreis, xKopfkreis, yKopfkreis);

            line_FußkreisKopfkreis.StartPoint = point_FußkreisLinks;
            line_FußkreisKopfkreis.EndPoint   = point_KopfkreisLinks;

            Line2D line_KopfkreisFußkreis = catfactory2D1.CreateLine(-xKopfkreis, yKopfkreis, -xFußkreis, yFußkreis);

            line_KopfkreisFußkreis.StartPoint = point_KopfkreisRechts;
            line_KopfkreisFußkreis.EndPoint   = point_FußkreisRechts;


            //Kreise
            Circle2D circle_KopfkreisLinksRechts = catfactory2D1.CreateCircle(x0, y0, Kopfkreisradius, 0, Math.PI * 2);

            circle_KopfkreisLinksRechts.CenterPoint = point_Ursprung;
            circle_KopfkreisLinksRechts.EndPoint    = point_KopfkreisLinks;
            circle_KopfkreisLinksRechts.StartPoint  = point_KopfkreisRechts;

            Circle2D circle_AnfangFußkreis = catfactory2D1.CreateCircle(x0, x0, Fußkreisradius, 0, Math.PI * 2);

            circle_AnfangFußkreis.CenterPoint = point_Ursprung;
            circle_AnfangFußkreis.EndPoint    = point_AnfangspunktLinks;
            circle_AnfangFußkreis.StartPoint  = point_FußkreisLinks;

            hsp_catiaProfil.CloseEdition();

            hsp_catiaPart.Part.Update();


            //Profilerstellen Ende

            //Kreismuster

            ShapeFactory       SF  = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;
            HybridShapeFactory HSF = (HybridShapeFactory)hsp_catiaPart.Part.HybridShapeFactory;
            Part myPart            = hsp_catiaPart.Part;

            Factory2D             Factory2D2  = hsp_catiaProfil.Factory2D;
            HybridShapePointCoord Ursprung    = HSF.AddNewPointCoord(0, 0, 0);
            Reference             RefUrsprung = myPart.CreateReferenceFromObject(Ursprung);
            HybridShapeDirection  XDir        = HSF.AddNewDirectionByCoord(1, 0, 0);
            Reference             RefXDir     = myPart.CreateReferenceFromObject(XDir);

            CircPattern Kreismuster = SF.AddNewSurfacicCircPattern(Factory2D2, 1, 2, 0, 0, 1, 1, RefUrsprung, RefXDir, false, 0, true, false);

            Kreismuster.CircularPatternParameters = CatCircularPatternParameters.catInstancesandAngularSpacing;
            AngularRepartition angularRepartition1 = Kreismuster.AngularRepartition;
            Angle angle1 = angularRepartition1.AngularSpacing;

            angle1.Value = Convert.ToDouble(360 / Convert.ToDouble(av.z));
            AngularRepartition angularRepartition2 = Kreismuster.AngularRepartition;
            IntParam           intParam1           = angularRepartition2.InstancesCount;

            intParam1.Value = Convert.ToInt32(av.z) + 1;

            Reference           Ref_Kreismuster = myPart.CreateReferenceFromObject(Kreismuster);
            HybridShapeAssemble Verbindung      = HSF.AddNewJoin(Ref_Kreismuster, Ref_Kreismuster);
            Reference           Ref_Verbindung  = myPart.CreateReferenceFromObject(Verbindung);

            HSF.GSMVisibility(Ref_Verbindung, 0);
            myPart.Update();
            Bodies bodies = myPart.Bodies;
            Body   myBody = bodies.Add();

            myBody.set_Name("Zahnrad");
            myBody.InsertHybridShape(Verbindung);
            myPart.Update();

            myPart.InWorkObject = myBody;
            Pad myPad = SF.AddNewPadFromRef(Ref_Verbindung, av.t);

            myPart.Update();


            //Bohrung
            Reference RefBohrung1       = hsp_catiaPart.Part.CreateReferenceFromBRepName("FSur:(Face:(Brp:(Pad.1;2);None:();Cf11:());WithTemporaryBody;WithoutBuildError;WithInitialFeatureSupport;MonoFond;MFBRepVersion_CXR15)", myPad);
            Hole      catBohrung1       = SF.AddNewHoleFromPoint(0, 0, 0, RefBohrung1, 0);
            Length    catLengthBohrung1 = catBohrung1.Diameter;

            catLengthBohrung1.Value = Convert.ToDouble(av.d / 2);

            hsp_catiaPart.Part.Update();
        }
Ejemplo n.º 24
0
 public static bool IsCollision(Circle2D circle, Line2D line)
 {
     return(IsCollision(line, circle));
 }
Ejemplo n.º 25
0
 public static AreaCode Intersect(Circle2D circle2D, Rectangle2D rectangle2D)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 26
0
        // This is where the clustering gets done.
        public void Cluster()
        {
            bool Running = true;

            Circle2D[] previousCentroids = new Circle2D[k];

            while (Running)
            {
                Array.Copy(centroids, previousCentroids, centroids.Length);

                // Calculate the distance of the remaining points and
                // cluster them into the SEC. Based on the minimum-distance principle.
                for (int i = 0; i < numberOfReferencePoints; i++)
                {
                    double oldDistance  = Int32.MaxValue;
                    double newDistance  = 0;
                    int    clusterIndex = 0;

                    for (int j = 0; j < k; ++j)
                    {
                        newDistance = distance(points[i].x, centroids[j].p.x, points[i].y, centroids[j].p.y);

                        // If the new distance is smaller than the others we have seen
                        // update the distance and the cluster.
                        if (newDistance <= oldDistance)
                        {
                            oldDistance  = newDistance;
                            clusterIndex = j;
                        }
                    }

                    points[i].classification = clusterIndex; // This is the cluster where the point resides
                    clusters[clusterIndex].Add(points[i]);
                }

                // Perform the SmallestEnclosingCircle algorithm on our current clusters
                for (int i = 0; i < k; i++)
                {
                    SmallestEnclosingCircle(ref clusters[i], ref centroids[i]);
                }

                // @Note:
                // Debugging only
                System.Console.WriteLine("Smallest Enclosing Cirlce (SEC) Complete: ");
                System.Console.WriteLine("");
                for (int i = 0; i < k; i++)
                {
                    System.Console.WriteLine("      ({0},{1}), {2}", centroids[i].p.x, centroids[i].p.y, centroids[i].radius);
                }

                // Now we need to decide if the algorithm has to run again.
                // @TODO:
                // Implement some kind of threshhold definition.
                // Right now we just see if the previous centroid is the same as the current one,
                // we could see if the radius decrease is smaller than something.. -bjarke, 21th March 2020.
                int numberOfEquals = 0;
                for (int i = 0; i < k; i++)
                {
                    if (previousCentroids[i].p == centroids[i].p)
                    {
                        numberOfEquals++;
                    }
                }

                if (numberOfEquals == k)
                {
                    // @TODO:
                    // Entering this if-statement, means that the clustering is done. Now we have to insert
                    // each point back into the database, along with their classification (clusterIndex).
                    // Furthermore we will add the centroid center coordinates to the database.
                    UpdateCategories(clusters);

                    Running = false; // SEC is done
                }

                // If the algorithm isn't done yet, clear the clusters and redo the clustering.
                for (int i = 0; i < k; i++)
                {
                    clusters[i].Clear();
                }

                Array.Copy(centroids, previousCentroids, centroids.Length);
            }
        }
Ejemplo n.º 27
0
 public static bool IsCollision(Circle2D circle, Triangle2D tri)
 {
     return(IsCollision(tri, circle));
 }
Ejemplo n.º 28
0
        public void ErstelleProfilAußenverzahnung(Data dat)
        {
            //HilfsRadien
            double d_r  = dat.getTeilkreisdurchmesserZahnrad1() / 2;
            double hk_r = d_r * 0.94;
            double df_r = d_r - (1.25 * dat.getModulZahnrad1());
            double da_r = d_r + dat.getModulZahnrad1();
            double vd_r = 0.35 * dat.getModulZahnrad1();

            //HilfsWinkel
            double alpha   = 20;
            double beta    = 90 / dat.getZaehnezahlZahnrad1();
            double beta_r  = Math.PI * beta / 180;
            double gamma   = 90 - (alpha - beta);
            double gamma_r = Math.PI * gamma / 180;
            double ta      = 360.0 / dat.getZaehnezahlZahnrad1();
            double ta_r    = Math.PI * ta / 180;

            //Nullpunkte
            double x0 = 0;
            double y0 = 0;

            //MittelPunkt EvolventenKreis
            double MP_EvolventenKreis_x = hk_r * Math.Cos(gamma_r);
            double MP_EvolventenKreis_y = hk_r * Math.Sin(gamma_r);

            // SchnittPunkt Evolventenkreis & Teilkreisradius
            double SP_EvolventenTeilKreis_x = -d_r *Math.Sin(beta_r);

            double SP_EvolventenTeilKreis_y = d_r * Math.Cos(beta_r);

            //Evolventenkreis Radius
            double Evolventenkreis_r = Math.Sqrt(Math.Pow((MP_EvolventenKreis_x - SP_EvolventenTeilKreis_x), 2) + Math.Pow((MP_EvolventenKreis_y - SP_EvolventenTeilKreis_y), 2));

            //SchnittPunkt Evolventenkreis & Kopfkreisradius
            double SP_EvolventenKopfKreis_x = Schnittpunkt_x(x0, y0, da_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r);
            double SP_EvolventenKopfKreis_y = Schnittpunkt_y(x0, y0, da_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r);

            //MittelPunkt VerrundungsRadius
            double MP_Verrundung_x = Schnittpunkt_x(x0, y0, df_r + vd_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r + vd_r);
            double MP_Verrundung_y = Schnittpunkt_y(x0, y0, df_r + vd_r, MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r + vd_r);

            //SchnittPunkt Evolventenkreis & Verrundungsradius
            double SP_EvolventeVerrundung_x = Schnittpunkt_x(MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);
            double SP_EvolventeVerrundung_y = Schnittpunkt_y(MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);

            //SchnittPunkt Fußkreis & Verrundungs Radius
            double SP_FußkreisVerrundungsRadius_x = Schnittpunkt_x(x0, y0, df_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);
            double SP_FußkreisVerrundungsRadius_y = Schnittpunkt_y(x0, y0, df_r, MP_Verrundung_x, MP_Verrundung_y, vd_r);

            //StartPunkt Fußkreis Radius
            double phi = ta_r - Math.Atan(Math.Abs(SP_FußkreisVerrundungsRadius_x) / Math.Abs(SP_FußkreisVerrundungsRadius_y));
            double StartPkt_Fußkreis_x = -df_r *Math.Sin(phi);

            double StartPkt_Fußkreis_y = df_r * Math.Cos(phi);

            //Skizze umbenennen und öffnen
            hsp_catiaProfil.set_Name("AußenverzahnungEinzel");
            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();

            //Punkte
            Point2D catP2D_Ursprung = catFactory2D1.CreatePoint(x0, y0);

            Point2D catP2D_StartPkt_Fußkreis             = catFactory2D1.CreatePoint(StartPkt_Fußkreis_x, StartPkt_Fußkreis_y);
            Point2D catP2D_SP_FußkreisVerrundungsRadius1 = catFactory2D1.CreatePoint(SP_FußkreisVerrundungsRadius_x, SP_FußkreisVerrundungsRadius_y);
            Point2D catP2D_SP_FußkreisVerrundungsRadius2 = catFactory2D1.CreatePoint(-SP_FußkreisVerrundungsRadius_x, SP_FußkreisVerrundungsRadius_y);

            Point2D catP2D_MP_EvolventenKreis1 = catFactory2D1.CreatePoint(MP_EvolventenKreis_x, MP_EvolventenKreis_y);
            Point2D catP2D_MP_EvolventenKreis2 = catFactory2D1.CreatePoint(-MP_EvolventenKreis_x, MP_EvolventenKreis_y);

            Point2D catP2D_SP_EvolventenKopfKreis1 = catFactory2D1.CreatePoint(SP_EvolventenKopfKreis_x, SP_EvolventenKopfKreis_y);
            Point2D catP2D_SP_EvolventenKopfKreis2 = catFactory2D1.CreatePoint(-SP_EvolventenKopfKreis_x, SP_EvolventenKopfKreis_y);

            Point2D catP2D_MP_Verrundung1 = catFactory2D1.CreatePoint(MP_Verrundung_x, MP_Verrundung_y);
            Point2D catP2D_MP_Verrundung2 = catFactory2D1.CreatePoint(-MP_Verrundung_x, MP_Verrundung_y);

            Point2D catP2D_SP_EvolventeVerrundung1 = catFactory2D1.CreatePoint(SP_EvolventeVerrundung_x, SP_EvolventeVerrundung_y);
            Point2D catP2D_SP_EvolventeVerrundung2 = catFactory2D1.CreatePoint(-SP_EvolventeVerrundung_x, SP_EvolventeVerrundung_y);


            //Kreise
            Circle2D catC2D_Frußkreis = catFactory2D1.CreateCircle(x0, y0, df_r, 0, 0);

            catC2D_Frußkreis.CenterPoint = catP2D_Ursprung;
            catC2D_Frußkreis.StartPoint  = catP2D_SP_FußkreisVerrundungsRadius1;
            catC2D_Frußkreis.EndPoint    = catP2D_StartPkt_Fußkreis;

            Circle2D catC2D_Kopfkreis = catFactory2D1.CreateCircle(x0, y0, da_r, 0, 0);

            catC2D_Kopfkreis.CenterPoint = catP2D_Ursprung;
            catC2D_Kopfkreis.StartPoint  = catP2D_SP_EvolventenKopfKreis2;
            catC2D_Kopfkreis.EndPoint    = catP2D_SP_EvolventenKopfKreis1;

            Circle2D catC2D_EvolventenKreis1 = catFactory2D1.CreateCircle(MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, 0, 0);

            catC2D_EvolventenKreis1.CenterPoint = catP2D_MP_EvolventenKreis1;
            catC2D_EvolventenKreis1.StartPoint  = catP2D_SP_EvolventenKopfKreis1;
            catC2D_EvolventenKreis1.EndPoint    = catP2D_SP_EvolventeVerrundung1;

            Circle2D catC2D_Evolventenkreis2 = catFactory2D1.CreateCircle(-MP_EvolventenKreis_x, MP_EvolventenKreis_y, Evolventenkreis_r, 0, 0);

            catC2D_Evolventenkreis2.CenterPoint = catP2D_MP_EvolventenKreis2;
            catC2D_Evolventenkreis2.StartPoint  = catP2D_SP_EvolventeVerrundung2;
            catC2D_Evolventenkreis2.EndPoint    = catP2D_SP_EvolventenKopfKreis2;

            Circle2D catC2D_VerrundungsKreis1 = catFactory2D1.CreateCircle(MP_Verrundung_x, MP_Verrundung_y, vd_r, 0, 0);

            catC2D_VerrundungsKreis1.CenterPoint = catP2D_MP_Verrundung1;
            catC2D_VerrundungsKreis1.StartPoint  = catP2D_SP_FußkreisVerrundungsRadius1;
            catC2D_VerrundungsKreis1.EndPoint    = catP2D_SP_EvolventeVerrundung1;

            Circle2D catC2D_VerrundungsKreis2 = catFactory2D1.CreateCircle(-MP_Verrundung_x, MP_Verrundung_y, vd_r, 0, 0);

            catC2D_VerrundungsKreis2.CenterPoint = catP2D_MP_Verrundung2;
            catC2D_VerrundungsKreis2.StartPoint  = catP2D_SP_EvolventeVerrundung2;
            catC2D_VerrundungsKreis2.EndPoint    = catP2D_SP_FußkreisVerrundungsRadius2;

            hsp_catiaProfil.CloseEdition();

            hsp_catiaPart.Part.Update();
        }
Ejemplo n.º 29
0
 public static bool IsCollision(Circle2D circle, Rectangle2D rect)
 {
     return(IsCollision(rect, circle));
 }
Ejemplo n.º 30
0
 public bool Overlap(Circle2D c)
 {
     return((c.Center - Center).SqrMagnitude() < ((c.R + R) * (c.R + R)));
 }
Ejemplo n.º 31
0
        public void ErzeugeVierkantrohr(Double r_ah, Double r_ih, Double r_ab, Double r_ib)
        {
            hsp_catiaProfil.set_Name("VierkantRohr");
            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();

            Point2D catPoint2D1 = catFactory2D1.CreatePoint(r_ab - r_ib, r_ah);
            Point2D catPoint2D2 = catFactory2D1.CreatePoint(r_ab, r_ah + r_ib - r_ab);
            Point2D catPoint2D3 = catFactory2D1.CreatePoint(r_ab, 0);
            Point2D catPoint2D4 = catFactory2D1.CreatePoint(0, 0);

            Point2D catPoint2D5 = catFactory2D1.CreatePoint((r_ab - r_ib) / 2, r_ih + (r_ah - r_ih) / 2);
            Point2D catPoint2D6 = catFactory2D1.CreatePoint(r_ib + (r_ab - r_ib) / 2, r_ih + (r_ah - r_ih) / 2);
            Point2D catPoint2D7 = catFactory2D1.CreatePoint(r_ib + (r_ab - r_ib) / 2, (r_ah - r_ih) / 2);
            Point2D catPoint2D8 = catFactory2D1.CreatePoint((r_ab - r_ib) / 2, (r_ah - r_ih) / 2);

            Point2D catPoint2D9  = catFactory2D1.CreatePoint(0, r_ah + r_ib - r_ab);
            Point2D catPoint2D10 = catFactory2D1.CreatePoint(r_ab - r_ib, r_ah - (r_ab - r_ib));

            Point2D catPoint2D11 = catFactory2D1.CreatePoint(r_ib, r_ah);
            Point2D catPoint2D12 = catFactory2D1.CreatePoint(r_ib, r_ah + r_ib - r_ab);

            Circle2D catCircle2D1 = catFactory2D1.CreateCircle(r_ab - r_ib, r_ah - (r_ab - r_ib), r_ab - r_ib, r_ab - r_ib, r_ab - r_ib);

            catCircle2D1.CenterPoint = catPoint2D10;
            catCircle2D1.StartPoint  = catPoint2D1;
            catCircle2D1.EndPoint    = catPoint2D9;

            Circle2D catCircle2D2 = catFactory2D1.CreateCircle(r_ib, r_ah + r_ib - r_ab, r_ab - r_ib, r_ab - r_ib, r_ab - r_ib);

            catCircle2D2.CenterPoint = catPoint2D12;
            catCircle2D2.StartPoint  = catPoint2D2;
            catCircle2D2.EndPoint    = catPoint2D11;

            Line2D catLine2D1 = catFactory2D1.CreateLine(r_ab - r_ib, r_ah, r_ib, r_ah);

            catLine2D1.StartPoint = catPoint2D1;
            catLine2D1.EndPoint   = catPoint2D11;

            Line2D catLine2D2 = catFactory2D1.CreateLine(r_ab, r_ah + r_ab - r_ib, r_ab, 0);

            catLine2D2.StartPoint = catPoint2D2;
            catLine2D2.EndPoint   = catPoint2D3;

            Line2D catLine2D3 = catFactory2D1.CreateLine(r_ab, 0, 0, 0);

            catLine2D3.StartPoint = catPoint2D3;
            catLine2D3.EndPoint   = catPoint2D4;

            Line2D catLine2D4 = catFactory2D1.CreateLine(0, 0, 0, r_ah + r_ib - r_ab);

            catLine2D4.StartPoint = catPoint2D4;
            catLine2D4.EndPoint   = catPoint2D9;

            Line2D catLine2D5 = catFactory2D1.CreateLine((r_ab - r_ib) / 2, r_ih + (r_ah - r_ih) / 2, r_ib + (r_ab - r_ib) / 2, r_ih + (r_ah - r_ih) / 2);

            catLine2D5.StartPoint = catPoint2D5;
            catLine2D5.EndPoint   = catPoint2D6;

            Line2D catLine2D6 = catFactory2D1.CreateLine(r_ib + (r_ab - r_ib) / 2, r_ih + (r_ah - r_ih) / 2, r_ib + (r_ab - r_ib) / 2, (r_ah - r_ih) / 2);

            catLine2D6.StartPoint = catPoint2D6;
            catLine2D6.EndPoint   = catPoint2D7;

            Line2D catLine2D7 = catFactory2D1.CreateLine(r_ib + (r_ab - r_ib) / 2, (r_ah - r_ih) / 2, (r_ab - r_ib) / 2, (r_ah - r_ih) / 2);

            catLine2D7.StartPoint = catPoint2D7;
            catLine2D7.EndPoint   = catPoint2D8;

            Line2D catLine2D8 = catFactory2D1.CreateLine((r_ab - r_ib) / 2, (r_ah - r_ih) / 2, (r_ab - r_ib) / 2, r_ih + (r_ah - r_ih) / 2);

            catLine2D8.StartPoint = catPoint2D8;
            catLine2D8.EndPoint   = catPoint2D5;

            hsp_catiaProfil.CloseEdition();
            hsp_catiaPart.Part.Update();
        }
Ejemplo n.º 32
0
        public void Stirnzahnrad(Außenverzahnung av)
        {
            //Profil erstellen
            //Nullpunkt
            double x0 = 0;
            double y0 = 0;

            //Hilfsgrößen
            double Teilkreisradius   = av.d / 2;
            double Hilfskreisradius  = Teilkreisradius * 0.94;
            double Fußkreisradius    = Teilkreisradius - (1.25 * av.m);
            double Kopfkreisradius   = Teilkreisradius + av.m;
            double Verrundungsradius = 0.35 * av.m;

            double Alpha         = 20;
            double Beta          = 90 / av.z;
            double Betarad       = Math.PI * Beta / 180;
            double Gamma         = 90 - (Alpha - Beta);
            double Gammarad      = Math.PI * Gamma / 180;
            double Totalangel    = 360.0 / av.z;
            double Totalangelrad = Math.PI + Totalangel / 180;

            //Punkte erzeugen
            //Kleiner Kreis
            double xMittelpunktaufEvol_links = Hilfskreisradius * Math.Cos(Gammarad);
            double yMittelpunktaufEvol_links = Hilfskreisradius * Math.Sin(Gammarad);

            //Schnittpunkt auf Evolvente und Teilkreisradius
            double xPunktaufEvolvente = -Teilkreisradius *Math.Sin(Betarad);

            double yPunktaufEvolvente = Teilkreisradius * Math.Cos(Betarad);

            //Evolventenkreis Radius
            double EvolventenkreisRadius = Math.Sqrt(Math.Pow((xMittelpunktaufEvol_links - xPunktaufEvolvente), 2) + Math.Pow((yMittelpunktaufEvol_links - yPunktaufEvolvente), 2));

            //Koordinaten Schnittpunkt Kopfkreis und Evolventenkreis
            double xEvolventenkopfkreis_links = Schnittpunkt_X(x0, y0, Kopfkreisradius, xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius);
            double yEvolventenkopfkreis_links = Schnittpunkt_Y(x0, y0, Kopfkreisradius, xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius);

            //Mittelpunktkoordinaten Verrundung
            double xMittelpunktVerrundung_links = Schnittpunkt_X(x0, y0, Fußkreisradius + Verrundungsradius, xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius + Verrundungsradius);
            double yMittelpunktVerrundung_links = Schnittpunkt_Y(x0, y0, Fußkreisradius + Verrundungsradius, xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius + Verrundungsradius);

            //Schnittpunktkoordinaten Verrundung - Evolventenkreis
            double x_SP_EvolventeVerrundung_links = Schnittpunkt_X(xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);
            double y_SP_EvolventeVerrundung_links = Schnittpunkt_Y(xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);

            //Schnittpunktkoordinaten Verrundung - Fußkreis
            double x_SP_FußkreisradiusVerrundung_links = Schnittpunkt_X(x0, y0, Fußkreisradius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);
            double y_SP_FußkreisradiusVerrundung_links = Schnittpunkt_Y(x0, y0, Fußkreisradius, xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius);

            //Koordinaten Anfangspunkt Fußkreis
            double Hilfswinkel            = Totalangelrad - Math.Atan(Math.Abs(x_SP_FußkreisradiusVerrundung_links) / Math.Abs(y_SP_FußkreisradiusVerrundung_links));
            double x_AnfangspunktFußkreis = -Fußkreisradius *Math.Sin(Hilfswinkel);

            double y_AnfangspunktFußkreis = Fußkreisradius * Math.Cos(Hilfswinkel);

            //Ende

            //Skizze umbenennen
            hsp_catiaProfil.set_Name("Zahnrad-Test");
            Factory2D catfactory2D1 = hsp_catiaProfil.OpenEdition();

            //Punkte in Skizze
            Point2D point_Ursprung                   = catfactory2D1.CreatePoint(x0, y0);
            Point2D pointAnfangFußkreisLinks         = catfactory2D1.CreatePoint(x_AnfangspunktFußkreis, y_AnfangspunktFußkreis);
            Point2D pointFußkreisVerrundungLinks     = catfactory2D1.CreatePoint(x_SP_FußkreisradiusVerrundung_links, y_SP_FußkreisradiusVerrundung_links);
            Point2D pointFußkreisVerrundungRechts    = catfactory2D1.CreatePoint(-x_SP_FußkreisradiusVerrundung_links, y_SP_FußkreisradiusVerrundung_links);
            Point2D pointMittelpunktVerrundungLinks  = catfactory2D1.CreatePoint(xMittelpunktVerrundung_links, yMittelpunktVerrundung_links);
            Point2D pointMittelpunktVerrundungRechts = catfactory2D1.CreatePoint(-xMittelpunktVerrundung_links, yMittelpunktVerrundung_links);
            Point2D pointVerrundungEvolventeLinks    = catfactory2D1.CreatePoint(x_SP_EvolventeVerrundung_links, y_SP_EvolventeVerrundung_links);
            Point2D pointVerrundungEvolventeRechts   = catfactory2D1.CreatePoint(-x_SP_EvolventeVerrundung_links, y_SP_EvolventeVerrundung_links);
            Point2D pointMittelpunktevolventeLinks   = catfactory2D1.CreatePoint(xMittelpunktaufEvol_links, xMittelpunktaufEvol_links);
            Point2D pointMittelpunktevolventeRechts  = catfactory2D1.CreatePoint(-xMittelpunktaufEvol_links, yMittelpunktaufEvol_links);
            Point2D pointEvolventenKopfkreisLinks    = catfactory2D1.CreatePoint(xEvolventenkopfkreis_links, yEvolventenkopfkreis_links);
            Point2D pointEvolventenKopfkreisRechts   = catfactory2D1.CreatePoint(-xEvolventenkopfkreis_links, yEvolventenkopfkreis_links);

            //Kreise
            Circle2D KreisFußkreis = catfactory2D1.CreateCircle(x0, y0, Fußkreisradius, 0, Math.PI * 2);

            KreisFußkreis.CenterPoint = point_Ursprung;
            KreisFußkreis.StartPoint  = pointFußkreisVerrundungLinks;
            KreisFußkreis.EndPoint    = pointAnfangFußkreisLinks;

            Circle2D KreisVerrundungLinks = catfactory2D1.CreateCircle(xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius, 0, Math.PI * 2);

            KreisVerrundungLinks.CenterPoint = pointMittelpunktVerrundungLinks;
            KreisVerrundungLinks.StartPoint  = pointFußkreisVerrundungLinks;
            KreisVerrundungLinks.EndPoint    = pointVerrundungEvolventeLinks;

            Circle2D KreisEvolventenkreisLinks = catfactory2D1.CreateCircle(xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius, 0, Math.PI * 2);

            KreisEvolventenkreisLinks.CenterPoint = pointMittelpunktevolventeLinks;
            KreisEvolventenkreisLinks.StartPoint  = pointEvolventenKopfkreisLinks;
            KreisEvolventenkreisLinks.EndPoint    = pointVerrundungEvolventeLinks;

            Circle2D KreisKopfkreis = catfactory2D1.CreateCircle(x0, y0, Kopfkreisradius, 0, Math.PI * 2);

            KreisKopfkreis.CenterPoint = point_Ursprung;
            KreisKopfkreis.StartPoint  = pointEvolventenKopfkreisRechts;
            KreisKopfkreis.EndPoint    = pointEvolventenKopfkreisLinks;

            Circle2D KreisEvolventenkreisRechts = catfactory2D1.CreateCircle(-xMittelpunktaufEvol_links, yMittelpunktaufEvol_links, EvolventenkreisRadius, 0, Math.PI * 2);

            KreisEvolventenkreisRechts.CenterPoint = pointMittelpunktVerrundungRechts;
            KreisEvolventenkreisRechts.StartPoint  = pointVerrundungEvolventeRechts;
            KreisEvolventenkreisRechts.EndPoint    = pointEvolventenKopfkreisRechts;

            Circle2D KreisVerrundungRechts = catfactory2D1.CreateCircle(-xMittelpunktVerrundung_links, yMittelpunktVerrundung_links, Verrundungsradius, 0, Math.PI * 2);

            KreisVerrundungRechts.CenterPoint = pointMittelpunktVerrundungRechts;
            KreisVerrundungRechts.StartPoint  = pointVerrundungEvolventeRechts;
            KreisVerrundungRechts.EndPoint    = pointFußkreisVerrundungRechts;

            //Skizzierer schließen
            hsp_catiaProfil.CloseEdition();

            //Aktualisieren
            hsp_catiaPart.Part.Update();



            //Kreismuster erstellen
            //Deklarierung
            ShapeFactory       SF  = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;
            HybridShapeFactory HSF = (HybridShapeFactory)hsp_catiaPart.Part.HybridShapeFactory;
            Part myPart            = hsp_catiaPart.Part;

            Factory2D             Factory2D1  = hsp_catiaProfil.Factory2D;
            HybridShapePointCoord Ursprung    = HSF.AddNewPointCoord(0, 0, 0);
            Reference             RefUrsprung = myPart.CreateReferenceFromObject(Ursprung);
            HybridShapeDirection  XDir        = HSF.AddNewDirectionByCoord(1, 0, 0);
            Reference             RefXDir     = myPart.CreateReferenceFromObject(XDir);

            //Kreismuster Daten ausfüllen
            CircPattern Kreismuster = SF.AddNewSurfacicCircPattern(Factory2D1, 1, 2, 0, 0, 1, 1, RefUrsprung, RefXDir, false, 0, true, false);

            Kreismuster.CircularPatternParameters = CatCircularPatternParameters.catInstancesandAngularSpacing;
            AngularRepartition angularRepartition1 = Kreismuster.AngularRepartition;
            Angle angle1 = angularRepartition1.AngularSpacing;

            angle1.Value = Convert.ToDouble(360 / Convert.ToDouble(av.z));
            AngularRepartition angularRepartition2 = Kreismuster.AngularRepartition;
            IntParam           intParam1           = angularRepartition2.InstancesCount;

            intParam1.Value = Convert.ToInt32(av.z) + 1;

            //geschlossene Kontur herstellen
            Reference           Ref_Kreismuster = myPart.CreateReferenceFromObject(Kreismuster);
            HybridShapeAssemble Verbindung      = HSF.AddNewJoin(Ref_Kreismuster, Ref_Kreismuster);
            Reference           Ref_Verbindung  = myPart.CreateReferenceFromObject(Verbindung);

            HSF.GSMVisibility(Ref_Verbindung, 0);
            myPart.Update();
            Bodies bodies = myPart.Bodies;
            Body   myBody = bodies.Add();

            myBody.set_Name("Zahnrad");
            myBody.InsertHybridShape(Verbindung);
            myPart.Update();
        }
 public static bool Overlap(Box2D box1, Circle2D circle1)
 {
     // logic goes here
 }
Ejemplo n.º 34
0
        public static Point?GetNearest(Circle2D c, Point p)
        {
            Ray2D r = new Ray2D(c.Center, p);

            return(GetNearest(r.Intersection(c), p));
        }
 public static bool Overlap(Circle2D circle1, Box2D box1)
 {
     return(Overlap(box1, circle1));    // No need to rewrite it twice
 }
Ejemplo n.º 36
0
        private void button1_Click(object sender, EventArgs e)
        {
            INFITF.Application catia; //add the reference - catia v5 infiit interface...

            try
            {
                //열려 있는 catia가져오기
                catia = (INFITF.Application)Marshal.GetActiveObject("CATIA.Application");
            }
            catch (Exception)
            {
                //catia 실행하기
                catia         = (INFITF.Application)Activator.CreateInstance(Type.GetTypeFromProgID("CATIA.Application"));
                catia.Visible = true;
            }

            MECMOD.PartDocument prtDoc = (MECMOD.PartDocument)catia.Documents.Add("Part");
            MECMOD.Part         prt    = prtDoc.Part;
            MECMOD.Bodies       bdys   = prt.Bodies;
            MECMOD.Body         bdy    = bdys.Add();
            MECMOD.Sketches     skts   = bdy.Sketches;

            INFITF.Reference xypln = (INFITF.Reference)prt.OriginElements.PlaneXY;
            Sketch           skt1  = skts.Add(xypln);

            Factory2D fac2d = skt1.OpenEdition();   //fac2d안에서 sketch가 이루어진다. fac2d cketch의 기능을 쓸수있다

            Point2D p1 = fac2d.CreatePoint(10, 10);
            Point2D p2 = fac2d.CreatePoint(10, 30);
            Point2D p3 = fac2d.CreatePoint(40, 30);
            Point2D p4 = fac2d.CreatePoint(40, 10);

            //method를 만들고 line생성
            Line2D lin1 = CreateLine(fac2d, p1, p2);
            Line2D lin2 = CreateLine(fac2d, p2, p3);
            Line2D lin3 = CreateLine(fac2d, p3, p4);
            Line2D lin4 = CreateLine(fac2d, p4, p1);

            CatConstraintType cnstDis = CatConstraintType.catCstTypeDistance;


            MECMOD.Constraint d1 = createCnst(prt, skt1, cnstDis, lin1, lin3);
            MECMOD.Constraint d2 = createCnst(prt, skt1, cnstDis, lin2, lin4);
            MECMOD.Constraint d3 = createCnst(prt, skt1, cnstDis, skt1.AbsoluteAxis.HorizontalReference, lin4);
            MECMOD.Constraint d4 = createCnst(prt, skt1, cnstDis, skt1.AbsoluteAxis.VerticalReference, lin1);

            /*
             * INFITF.Reference rline1 = prt.CreateReferenceFromGeometry(lin1);
             * INFITF.Reference rline2 = prt.CreateReferenceFromGeometry(lin2);
             * INFITF.Reference rline3 = prt.CreateReferenceFromGeometry(lin3);
             * INFITF.Reference rline4 = prt.CreateReferenceFromGeometry(lin4);
             * INFITF.Reference rlineH = prt.CreateReferenceFromGeometry(skt1.AbsoluteAxis.HorizontalReference);
             * INFITF.Reference rlineV = prt.CreateReferenceFromGeometry(skt1.AbsoluteAxis.VerticalReference);
             *
             * MECMOD.Constraint d1 = skt1.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rline1, rline3);
             * MECMOD.Constraint d2 = skt1.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rline2, rline4);
             * MECMOD.Constraint d3 = skt1.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rlineH, rline4);
             * MECMOD.Constraint d4 = skt1.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, rlineV, rline1);
             */
            skt1.CloseEdition();

            //create a circlr
            Sketch    skt2   = skts.Add(xypln);
            Factory2D fac2d1 = skt2.OpenEdition();

            //fac2d = skt2.OpenEdition();   //이렇게 함녀 된다.

            INFITF.Reference H = prt.CreateReferenceFromGeometry(skt2.AbsoluteAxis.HorizontalReference);
            INFITF.Reference V = prt.CreateReferenceFromGeometry(skt2.AbsoluteAxis.VerticalReference);

            Circle2D c = fac2d1.CreateClosedCircle(40, 30, 10);

            c.CenterPoint = p3;
            // MECMOD.Constraint orPtH = skt2.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance,H,(INFITF.Reference)c);
            //MECMOD.Constraint orPtV = skt2.Constraints.AddBiEltCst(CatConstraintType.catCstTypeDistance, V, (INFITF.Reference)c);
            MECMOD.Constraint r = skt2.Constraints.AddMonoEltCst(CatConstraintType.catCstTypeRadius, (INFITF.Reference)c);

            skt2.CloseEdition();

            ShapeFactory ShpFac = (ShapeFactory)prt.ShapeFactory;
            //pad
            Pad pad = ShpFac.AddNewPad(skt1, 20);

            //poket
            Pocket pock = ShpFac.AddNewPocket(skt2, 20);

            pock.DirectionOrientation = CatPrismOrientation.catRegularOrientation;

            prt.Update();
        }
 public static bool Overlap(Circle2D circle1, Circle2D circle2)
 {
     // logic goes here
 }
Ejemplo n.º 38
0
    // Start is called before the first frame update
    void Start()
    {
        var      p         = new MVector3(1, 0, 0);
        var      aaaaa     = new UnityEngine.Quaternion(1, 1, 1, 1);
        var      ptemp     = new UnityEngine.Vector3(0.5f, 0, 0);
        var      a         = aaaaa * aaaaa * aaaaa * ptemp;
        Matrix33 rotation  = Matrix33.AngleAxis(45, new MVector3(0, 0, 1));
        Matrix33 rotation2 = Matrix33.AngleAxis(-45, new MVector3(0, 0, 1));

        Debug.Log(p * rotation);
        Debug.Log(p * rotation * rotation2);
        Debug.Log(p * (rotation * rotation2));

        Debug.Log("-------------------------------------------------------------");
        Matrix44 mul = Matrix44.AngleAxisTranslate(45, new MVector3(0, 0, 1), new MVector3(1, 1, 0));

        Debug.Log(p * mul);
        Debug.Log(p * (mul * mul.Inverse()));

        Debug.Log("-------------------------------------------------------------");
        Matrix44 r          = Matrix44.AngleAxis(45, new MVector3(0, 0, 1));
        Matrix44 t          = Matrix44.Translate(new MVector3(1, 1, 0));
        Matrix44 composite  = r * t;
        Matrix44 composite2 = t.Inverse() * r.Inverse();

        Debug.Log(p * composite);
        Debug.Log(p * composite * composite2);
        Debug.Log(p * composite * composite.Inverse());

        mMesh     = GetComponent <MeshFilter>().mesh;
        mVertices = mMesh.vertices;
        mNormals  = mMesh.normals;


        var temp = new Matrix33(10, 0, 0, 0, 10, 0, 0, 0, 1);

        var temp2       = temp.Inverse();
        var tempInverse = new Matrix33(0, 0, 0, 0, 0, 0, -3, -4, 1);

        p   = new MVector3(0, 0, 1);
        p   = p * temp;
        p.z = 1;
        p   = p * tempInverse;
        var t3 = temp * tempInverse;

        t = Matrix44.Translate(new MVector3(3, 4, 5));
        r = Matrix44.AngleAxis(30, new MVector3(0, 1, 0));
        var s = Matrix44.Scale(new MVector3(0.5f, 2, 1));

        p = new MVector3(1, 1, 1);
        var p1 = p * s * r * t;

        p = p1 * t.Inverse() * r.Inverse() * s.Inverse();

        var ray2d1 = new MRay(new MVector3(1, -1, 0), new MVector3(1, 1, 0));

        var   aaa  = ray2d1.GetNearestPos(new MVector3(1, 1, 0));
        float aaaa = 1;

        var plane1 = new MPlane(new MVector3(1, 1, 1), 1);
        var pos1   = plane1.GetNearestPos(new MVector3(5, 5, 5));
        var pos2   = plane1.GetNearestPos(new MVector3(-5, -5, -5));

        var plane2 = new MPlane(new MVector3(-1, -1, -1), -1);
        var pos3   = plane2.GetNearestPos(new MVector3(5, 5, 5));
        var pos4   = plane2.GetNearestPos(new MVector3(-5, -5, -5));

        var plane3 = new MPlane(new MVector3(-1, -1, -1), 1);
        var pos5   = plane3.GetNearestPos(new MVector3(5, 5, 5));
        var pos6   = plane3.GetNearestPos(new MVector3(-5, -5, -5));

        // 三角形测试
        pos1 = new MVector3(0, 0, 3);
        pos2 = new MVector3(0, 1, 3);
        pos3 = new MVector3(1, 0, 3);
        var triangle1 = new Triangle(pos1, pos2, pos3);
        var result    = triangle1.InclusionPos(pos1);
        var targetPos = MVector3.zero;

        result = triangle1.InclusionPos(pos2);
        result = triangle1.GetGravityPos(pos2, out targetPos);
        result = triangle1.InclusionPos(pos3);
        result = triangle1.GetGravityPos(pos3, out targetPos);
        float dis = 0;

        result = triangle1.Raycast(new MRay(new MVector3(0.4f, 0.6f, -0.2567f), new MVector3(0, 0, 1)), out dis);
        pos4   = new MVector3(0.5f, 0.5f, 3);
        result = triangle1.InclusionPos(pos4);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        pos4   = new MVector3(0.4f, 0.4f, 0.1f);
        result = triangle1.InclusionPos(pos4);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        pos4   = new MVector3(0.6f, 0.6f, 3);
        result = triangle1.InclusionPos(pos4);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        pos4   = new MVector3(-0.1f, -0.1f, 3);
        result = triangle1.InclusionPos(pos4);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        result = triangle1.GetGravityPos(pos4, out targetPos);
        result = triangle1.InclusionPos(pos3);
        result = triangle1.GetGravityPos(pos3, out targetPos);
        result = triangle1.GetGravityPos(pos3, out targetPos);
        var tempxxx = 0;

        Circle2D c1 = new Circle2D(MVector2.zero, 1);
        var      t1 = c1.GetNearestPos(new MVector2(2, 0));
        var      t2 = c1.GetNearestPos(new MVector2(0.5f, 0));

        tempxxx = 0;

        var      r1 = new MRay2D(new MVector2(1, 1), new MVector2(0, -1));
        var      r2 = new MRay2D(new MVector2(10, 0), new MVector2(1, 0));
        MVector2 r12v;
        bool     r12r = r1.Interact(r2, out r12v);

        float c10, c11;
        bool  r10 = c1.IntersectRay(r1, out c10, out c11);

        tempxxx = 0;
    }
Ejemplo n.º 39
0
 public static void CreateCylinder(double thickness, double radius)
 {
     oCurrentSketch = oPartBody.Sketches.Add ( oPlaneYZ );
     Factory2D oFactory2D = (Factory2D)oCurrentSketch.OpenEdition();
     oCurrentCircle1 = oFactory2D.CreateClosedCircle (iCenterX, iCenterY, radius);
     oCurrentSketch.CloseEdition();
     ShapeFactory oShapeFactory = (ShapeFactory)oPart;
     Pad oPad = oShapeFactory.AddNewPad ( oCurrentSketch,  thickness + iCurrentLevel );
     oPad.SecondLimit.Dimension.Value = iCurrentLevel*-1;
     iCurrentLevel = iCurrentLevel + thickness;
 }