Beispiel #1
0
        //Ende I Profil


        //Hier Enden die Formprofile!!!



        // Hier beginnen die runden Profile!!!

        //Anfang RundHohlProfil!!

        internal void ErzeugeProfilRundHohlProfil(RundHohlProfil rundHohlProfil)
        {
            hspB1_catia_Profil.set_Name("RundHohlProfil");
            Factory2D factory2D = hspB1_catia_Profil.OpenEdition();


            //Setzen der Punkte/Kreise

            Point2D catpoint2D1 = factory2D.CreatePoint(0, 0);

            Circle2D catCircle2D1 = factory2D.CreateCircle(0, 0, rundHohlProfil.Durchmesser / 2, 0, 0);

            catCircle2D1.CenterPoint = catpoint2D1;

            Circle2D catCircle2D2 = factory2D.CreateCircle(0, 0, (rundHohlProfil.Durchmesser / 2 - rundHohlProfil.Wandstärke), 0, 0);

            catCircle2D2.CenterPoint = catpoint2D1;


            // Skizzierer verlassen
            hspB1_catia_Profil.CloseEdition();

            // Part aktualisieren
            hspB1_catiaPart.Part.Update();
        }
Beispiel #2
0
        static void Logo(Factory2D F, float X, float Y, float Height, float Fatness)
        {
            const double AngleOffset = 0.09;

            Ellipse2D LeftUpper = F.CreateEllipse(X, Y - Fatness / 2 + Height,
                                                  0, 0, Height / 2, Height, -3 * Math.PI / 2, -Math.PI / 2);

            Ellipse2D RightUpperUpper = F.CreateEllipse(X, Y - Fatness / 2 + Height,
                                                        0, 0, Height / 2 - Fatness, Height - Fatness, Math.PI / 2, Math.PI - AngleOffset);

            Ellipse2D RightUpperLower = F.CreateEllipse(X, Y - Fatness / 2 + Height,
                                                        0, 0, Height / 2 - Fatness, Height - Fatness, Math.PI + AngleOffset, 3 * Math.PI / 2);

            Ellipse2D LeftLower = F.CreateEllipse(X, Y + Fatness / 2 - Height,
                                                  0, 0, Height / 2 - Fatness, Height - Fatness, 3 * Math.PI / 2, Math.PI / 2);
            Ellipse2D RightLower = F.CreateEllipse(X, Y + Fatness / 2 - Height,
                                                   0, 0, Height / 2, Height, 3 * Math.PI / 2, Math.PI / 2);

            LeftUpper.EndPoint       = LeftLower.EndPoint;
            RightUpperLower.EndPoint = RightLower.EndPoint;

            Circle2D UpperCircle = F.CreateCircle(X, (Y + Height * 2) - Fatness, Fatness / 2, -Math.PI / 2, Math.PI / 2);

            UpperCircle.EndPoint   = LeftUpper.StartPoint;
            UpperCircle.StartPoint = RightUpperUpper.StartPoint;

            Circle2D LowerCircle = F.CreateCircle(X, (Y - Height * 2) + Fatness, Fatness / 2, Math.PI / 2, -Math.PI / 2);

            LowerCircle.StartPoint = LeftLower.StartPoint;
            LowerCircle.EndPoint   = RightLower.StartPoint;

            Point2D BarLowerStart = RightUpperLower.StartPoint;
            Line2D  BarLower      = F.CreateLine(BarLowerStart.GetPos().X, BarLowerStart.GetPos().Y,
                                                 BarLowerStart.GetPos().X + Height / 2, BarLowerStart.GetPos().Y);

            BarLower.StartPoint = BarLowerStart;

            Point2D BarUpperStart = RightUpperUpper.EndPoint;
            Line2D  BarUpper      = F.CreateLine(BarUpperStart.GetPos().X, BarUpperStart.GetPos().Y,
                                                 BarUpperStart.GetPos().X + Height / 2, BarUpperStart.GetPos().Y);

            BarUpper.StartPoint = BarUpperStart;

            double   UpperX    = BarUpper.EndPoint.GetPos().X;
            double   UpperY    = BarUpper.EndPoint.GetPos().Y;
            double   LowerY    = BarLower.EndPoint.GetPos().Y;
            double   R         = (UpperY - LowerY) / 2;
            Circle2D BarCircle = F.CreateCircle(UpperX, LowerY + R, R, -Math.PI / 2, Math.PI / 2);

            BarCircle.EndPoint   = BarUpper.EndPoint;
            BarCircle.StartPoint = BarLower.EndPoint;
        }
Beispiel #3
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;
        }
Beispiel #4
0
        public void ErzeugeProfil(Double r)
        {
            // Skizze umbenennen
            hsp_catiaProfil.set_Name("Grundfläche Schaft");

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


            // erst die Punkte
            Point2D catPoint2D1 = catFactory2D1.CreatePoint(0, 0);


            // dann den Kreis
            Circle2D catCircle2D_1 = catFactory2D1.CreateCircle(0, 0, r, 0, 0);

            catCircle2D_1.CenterPoint = catPoint2D1;



            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();
        }
Beispiel #5
0
        private Sketch Gewindeskizze(Schraube arr)
        {
            // Referenzen für Skizze festlegen
            OriginElements catoriginElements = part_Schraube.OriginElements;
            Reference      RefPlanezx        = (Reference)catoriginElements.PlaneZX;

            //Neue Skizze erstellen
            Sketch Skizze_gewinde = sketches_Schraube.Add(RefPlanezx);

            part_Schraube.InWorkObject = Skizze_gewinde;
            Skizze_gewinde.set_Name("Gewinde");

            //Koordinaten Für gewindeSkizze berechnen
            double zInnen = 0.5 * arr.kerndurchmesser + arr.gewinderundung - Math.Sin((30 * Math.PI) / 180) * arr.gewinderundung;
            double xInnen = Math.Cos((30 * Math.PI) / 180) * arr.gewinderundung;

            double zAußen = 0.5 * arr.durchmesser;
            double xAußen = 2 * 0.1875 * arr.gewindesteigung;

            double zRadius = 0.5 * (arr.kerndurchmesser + arr.gewinderundung);
            double xRadius = 0;

            // Geometrie zeichnen
            Factory2D catfactory2D2 = Skizze_gewinde.OpenEdition();

            Point2D geweindepunkt1 = catfactory2D2.CreatePoint(zInnen, -xInnen);
            Point2D geweindepunkt2 = catfactory2D2.CreatePoint(zInnen, xInnen);

            Point2D geweindepunkt3 = catfactory2D2.CreatePoint(zAußen, xAußen);
            Point2D geweindepunkt4 = catfactory2D2.CreatePoint(zAußen, -xAußen);

            Point2D geweindepunkt5 = catfactory2D2.CreatePoint(zRadius, xRadius);

            Line2D linieOben = catfactory2D2.CreateLine(zInnen, xInnen, zAußen, xAußen);

            linieOben.StartPoint = geweindepunkt2;
            linieOben.EndPoint   = geweindepunkt3;

            Line2D linieAußen = catfactory2D2.CreateLine(zAußen, xAußen, zAußen, -xAußen);

            linieAußen.StartPoint = geweindepunkt3;
            linieAußen.EndPoint   = geweindepunkt4;

            Line2D linieUnten = catfactory2D2.CreateLine(zAußen, -xAußen, zInnen, -xInnen);

            linieUnten.StartPoint = geweindepunkt4;
            linieUnten.EndPoint   = geweindepunkt1;

            Circle2D gewindeRundung = catfactory2D2.CreateCircle(zRadius, xRadius, arr.gewinderundung, 0, 0);

            gewindeRundung.CenterPoint = geweindepunkt5;
            gewindeRundung.EndPoint    = geweindepunkt1;
            gewindeRundung.StartPoint  = geweindepunkt2;

            Skizze_gewinde.CloseEdition();

            return(Skizze_gewinde);
        }
Beispiel #6
0
        public void Kreis_hohl_DrawSketch(double KreisDurchmesser, double Wandstaerke)
        {
            double d  = KreisDurchmesser;
            double t  = Wandstaerke;
            double di = (d / 2) - t;

            CATIA_Kreis_hohl_2D.set_Name("Kreis-Hohlprofil");

            Factory2D Kreis_hohl_Factory = CATIA_Kreis_hohl_2D.OpenEdition();

            // Definition der Kreise
            Circle2D OuterCircle = Kreis_hohl_Factory.CreateCircle(0, 0, (d / 2), 0, 0);
            Circle2D InnerCircle = Kreis_hohl_Factory.CreateCircle(0, 0, di, 0, 0);

            CATIA_Kreis_hohl_2D.CloseEdition();

            CATIA_Kreis_hohl_Part.Part.Update();
        }
        public void ErzeugeProfil(int z, double b, double m, double p, double c, double df, double hf, double h, double ha, double da)
        {
            //                                                Punkte
            //Nullpunkte
            double x0     = 0;
            double y0     = 0;
            double radius = 20;

            //Startpunkte
            double StartPkt_Fußkreis_x  = x0;
            double StartPkt_Fußkreis_y  = df / 2;
            double StartPkt_Kopfkreis_x = x0;
            double StartPkt_Kopfkreis_y = da / 2;
            //Endpunkte
            double EndPkt_Kopfkreis_x = p / 2;
            double EndPkt_Kopfkreis_y = da / 2;
            double EndPkt_Fußkreis_x  = p / 2;
            double EndPkt_Fußkreis_y  = df / 2;
            //Winkelpunkt
            double Alpha           = z / 2 * Math.PI;
            double EndPkt_Radius_x = Math.Sin(90 * Math.PI / 180 - Alpha) * df / 2;
            double EndPkt_Radius_y = Math.Cos(90 * Math.PI / 180 - Alpha) * df / 2;



            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();

            Point2D catP2D_MPkt_Radius = catFactory2D1.CreatePoint(x0, y0);

            Point2D catP2D_StartPkt_Fußkreis  = catFactory2D1.CreatePoint(StartPkt_Fußkreis_x, StartPkt_Fußkreis_y);
            Point2D catP2D_StartPkt_Kopfkreis = catFactory2D1.CreatePoint(StartPkt_Kopfkreis_x, StartPkt_Kopfkreis_y);
            Point2D catP2D_EndPkt_Kopfkreis   = catFactory2D1.CreatePoint(EndPkt_Kopfkreis_x, EndPkt_Kopfkreis_y);
            Point2D catP2D_EndPkt_Fußkreis    = catFactory2D1.CreatePoint(EndPkt_Fußkreis_x, EndPkt_Fußkreis_y);
            Point2D catP2D_EndPkt_Radius      = catFactory2D1.CreatePoint(EndPkt_Radius_x, EndPkt_Radius_y);


            //                                               Linien

            Line2D catLine2D1 = catFactory2D1.CreateLine(StartPkt_Fußkreis_x, StartPkt_Fußkreis_y, StartPkt_Kopfkreis_x, StartPkt_Kopfkreis_y);
            Line2D catLine2D2 = catFactory2D1.CreateLine(StartPkt_Kopfkreis_x, StartPkt_Kopfkreis_y, EndPkt_Kopfkreis_x, EndPkt_Kopfkreis_y);
            Line2D catLine2D3 = catFactory2D1.CreateLine(EndPkt_Kopfkreis_x, EndPkt_Kopfkreis_y, EndPkt_Fußkreis_x, EndPkt_Fußkreis_y);
            //  Line2D catLine2D4 = catFactory2D1.CreateLine(EndPkt_Fußkreis_x, EndPkt_Fußkreis_y,EndPkt_Radius_x, EndPkt_Radius_y);

            Circle2D catC2D_Fußkreis = catFactory2D1.CreateCircle(catP2D_MPkt_Radius, radius);

            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();
        }
Beispiel #8
0
        public void Kreis_DrawSketch(double KreisDurchmesser)
        {
            double d = KreisDurchmesser;

            CATIA_Kreis2D.set_Name("Kreisprofil");

            Factory2D KreisFactory = CATIA_Kreis2D.OpenEdition();

            // Definition des Kreises
            Circle2D KreisSketch = KreisFactory.CreateCircle(0, 0, (d / 2), 0, 0);

            CATIA_Kreis2D.CloseEdition();

            CATIA_KreisPart.Part.Update();
        }
Beispiel #9
0
        public void setMittelpunkt(double r)
        {
            // Skizze umbenennen
            hsp_catiaProfil.set_Name("Kreis");

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

            // Kreis erzeugen
            // erst die Punkte


            Circle2D circle2D = catFactory2D1.CreateCircle(0, 0, r, 0, 0);

            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();
        }
Beispiel #10
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();
        }
Beispiel #11
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();
        }
Beispiel #12
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();
        }
        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();
        }
Beispiel #14
0
        // Separate Skizzenerzeugung für de Helix
        public Sketch makeGewindeSkizze(object[] ParameterListe)
        {
            // Listen Werte wieder in richtige Datentypen umwandeln
            int    Kopf              = Convert.ToInt32(ParameterListe[0]);
            double Durchmesser       = Convert.ToDouble(ParameterListe[1]);
            double Gewindelänge      = Convert.ToDouble(ParameterListe[2]);
            double Schaftlänge       = Convert.ToDouble(ParameterListe[3]);
            double Steigung          = Convert.ToDouble(ParameterListe[4]);
            int    Gewindeart        = Convert.ToInt32(ParameterListe[5]);
            double Schlüsselweite    = Convert.ToDouble(ParameterListe[6]);
            double Kopfhöhe          = Convert.ToDouble(ParameterListe[7]);
            double Kopfdurchmesser   = Convert.ToDouble(ParameterListe[8]);
            string Schraubenrichtung = Convert.ToString(ParameterListe[9]);

            double Gesamtlänge = Gewindelänge + Schaftlänge + Kopfhöhe;
            Double P           = Steigung;
            Double Ri          = Durchmesser / 2;

            OriginElements catOriginElements = hsp_catiaPart.Part.OriginElements;

            //Reference catReference3 = (Reference)catOriginElements.PlaneXY;

            hsp_catiaPart.Part.InWorkObject = hsp_catiaProfil_Gewinde;
            hsp_catiaProfil_Gewinde.set_Name("Gewinde");

            double V_oben_links = Gesamtlänge - (((((Math.Sqrt(3) / 2) * P) / 6) + 0.6134 * P) * Math.Tan((30 * Math.PI) / 180));
            double H_oben_links = Ri;

            double V_oben_rechts = Gesamtlänge + (((((Math.Sqrt(3) / 2) * P) / 6) + 0.6134 * P) * Math.Tan((30 * Math.PI) / 180));
            double H_oben_rechts = Ri;

            double V_unten_links = Gesamtlänge - ((0.1443 * P) * Math.Sin((60 * Math.PI) / 180));
            double H_unten_links = Ri - (0.6134 * P - 0.1443 * P) - Math.Sqrt(Math.Pow((0.1443 * P), 2) - Math.Pow((0.1443 * P) * Math.Sin((60 * Math.PI) / 180), 2));

            double V_unten_rechts = Gesamtlänge + (0.1443 * P) * Math.Sin((60 * Math.PI) / 180);
            double H_unten_rechts = Ri - (0.6134 * P - 0.1443 * P) - Math.Sqrt(Math.Pow((0.1443 * P), 2) - Math.Pow((0.1443 * P) * Math.Sin((60 * Math.PI) / 180), 2));

            double V_Mittelpunkt = Gesamtlänge;
            double H_Mittelpunkt = Ri - ((0.6134 * P) - 0.1443 * P);

            Factory2D catFactory2D2 = hsp_catiaProfil_Gewinde.OpenEdition();

            Point2D Oben_links   = catFactory2D2.CreatePoint(H_oben_links, V_oben_links);
            Point2D Oben_rechts  = catFactory2D2.CreatePoint(H_oben_rechts, V_oben_rechts);
            Point2D Unten_links  = catFactory2D2.CreatePoint(H_unten_links, V_unten_links);
            Point2D Unten_rechts = catFactory2D2.CreatePoint(H_unten_rechts, V_unten_rechts);
            Point2D Mittelpunkt  = catFactory2D2.CreatePoint(H_Mittelpunkt, V_Mittelpunkt);

            Line2D Oben = catFactory2D2.CreateLine(H_oben_links, V_oben_links, H_oben_rechts, V_oben_rechts);

            Oben.StartPoint = Oben_links;
            Oben.EndPoint   = Oben_rechts;

            Line2D Rechts = catFactory2D2.CreateLine(H_oben_rechts, V_oben_rechts, H_unten_rechts, V_unten_rechts);

            Rechts.StartPoint = Oben_rechts;
            Rechts.EndPoint   = Unten_rechts;

            Circle2D Verrundung = catFactory2D2.CreateCircle(H_Mittelpunkt, V_Mittelpunkt, 0.1443 * P, 0, 0);

            Verrundung.CenterPoint = Mittelpunkt;
            Verrundung.StartPoint  = Unten_rechts;
            Verrundung.EndPoint    = Unten_links;

            Line2D Links = catFactory2D2.CreateLine(H_oben_links, V_oben_links, H_unten_links, V_unten_links);

            Links.StartPoint = Unten_links;
            Links.EndPoint   = Oben_links;

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

            return(hsp_catiaProfil_Gewinde);
        }
Beispiel #15
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();
        }
Beispiel #16
0
        public void ErzeugeProfil(int z, double b, double m, double p, double c, double df, double hf, double h, double ha, double da)
        {
            //Punkte

            //Nullpunkte (koordinatenursprung)

            double x0 = 0;
            double y0 = 0;



            //HilfsWinkel aus dem Skript

            double alpha         = 20;
            double beta          = 90 / z;
            double betarad       = Math.PI * beta / 180;
            double gamma         = 90 - (alpha - beta);
            double gammarad      = Math.PI * gamma / 180;
            double totalangle    = 360.0 / z;
            double totalanglerad = Math.PI * totalangle / 180;

            // Radien aus dem Skript

            double teilekreisradius  = (m * z) / 2;
            double hilfskreisradius  = 0.94 * teilekreisradius;
            double fußkreisradius    = teilekreisradius - (1.25 * m);
            double kopfkreisradius   = teilekreisradius + m;
            double verrundungsradius = 0.35 * m;

            //Mittelpunkt für Teilstück aus dem Evolventenkreis

            double mittelpunkt_evolventenkreis_x = hilfskreisradius * Math.Cos(gammarad);
            double mittelpunkt_evolventenkreis_y = hilfskreisradius * Math.Sin(gammarad);


            // Schnittpunkte Teilstück Evolventenkreis mit Teilkreisradius
            double schnittpunkt_evolventenkreis_x = -teilekreisradius *Math.Sin(betarad);

            double schnittpunkt_evolventenkreis_y = teilekreisradius * Math.Cos(betarad);

            //Radius für Teilstück Evolventenkreis
            double evolventenkreis_r = Math.Sqrt(Math.Pow((mittelpunkt_evolventenkreis_x - schnittpunkt_evolventenkreis_x), 2) + Math.Pow((mittelpunkt_evolventenkreis_y - schnittpunkt_evolventenkreis_y), 2));


            //Schnittpunkte Evolventenkreis und Kopfkreisradius
            double schnittpunkt_evolventenkopfkreis_x = schnittpunkt_x_Achse(x0, y0, kopfkreisradius, mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r);
            double schnittpunkt_evolventenkopfkreis_y = schnittpunkt_y_Achse(x0, y0, kopfkreisradius, mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r);

            //Mittelpunkt Radius Verrunduung
            double mittelpunktverrundung_x = schnittpunkt_x_Achse(x0, y0, fußkreisradius + verrundungsradius, mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r + verrundungsradius);
            double mittelpunktverrundung_y = schnittpunkt_y_Achse(x0, y0, fußkreisradius + verrundungsradius, mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r + verrundungsradius);

            //Schnittpunkte Teilstück Evolventenkreis und Radius Verrundungungsradius     NEU
            double schnittpunktevolventenverrundung_x = schnittpunkt_x_Achse(mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r, mittelpunktverrundung_x, mittelpunktverrundung_y, verrundungsradius);
            double schnittpunktevolventenverrundung_y = schnittpunkt_y_Achse(mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r, mittelpunktverrundung_x, mittelpunktverrundung_y, verrundungsradius);

            //SchnittPunkt Fußkreis & Verrundungs Radius
            double schnittpunkt_verrundungsradius_x = schnittpunkt_x_Achse(x0, y0, fußkreisradius, mittelpunktverrundung_x, mittelpunktverrundung_y, verrundungsradius);
            double schnittpunkt_verrundungsradius_y = schnittpunkt_y_Achse(x0, y0, fußkreisradius, mittelpunktverrundung_x, mittelpunktverrundung_y, verrundungsradius);


            //StartPunkt Fußkreis Radius
            double phi = totalanglerad - Math.Atan(Math.Abs(schnittpunkt_verrundungsradius_x) / Math.Abs(schnittpunkt_verrundungsradius_y));

            double startpunktfußkreis_x = -fußkreisradius *Math.Sin(phi);

            double startpunktfußkreis_y = fußkreisradius * Math.Cos(phi);



            // öffne das Programm
            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();


            //Punkte

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

            //Fußkreis Start links
            Point2D catP2D_startpunktfußkreis = catFactory2D1.CreatePoint(startpunktfußkreis_x, startpunktfußkreis_y);

            //Verrundung unten links
            Point2D catP2D_schnittpunktfußkreisradius1 = catFactory2D1.CreatePoint(schnittpunkt_verrundungsradius_x, schnittpunkt_verrundungsradius_y);

            //Verrundung unten rechts
            Point2D catP2D_schnittpunktfußkreisradius2 = catFactory2D1.CreatePoint(-schnittpunkt_verrundungsradius_x, schnittpunkt_verrundungsradius_y);

            // außen rechts
            Point2D catP2D_mittelpunktevolventenkreis1 = catFactory2D1.CreatePoint(mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y);

            //außen links
            Point2D catP2D_mittelpunktevolventenkreis2 = catFactory2D1.CreatePoint(-mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y);

            //Evolvente links
            Point2D catP2D_schnittpunktevolventenkreis1 = catFactory2D1.CreatePoint(schnittpunkt_evolventenkopfkreis_x, schnittpunkt_evolventenkopfkreis_y);

            //Evolvente rechts
            Point2D catP2D_schnittpunktevolventenkreis2 = catFactory2D1.CreatePoint(-schnittpunkt_evolventenkopfkreis_x, schnittpunkt_evolventenkopfkreis_y);

            //Verrundung Mittelpunkt links
            Point2D catP2D_mittelpunktverrundung1 = catFactory2D1.CreatePoint(mittelpunktverrundung_x, mittelpunktverrundung_y);

            //Verrundung Mittelpunkt rechts
            Point2D catP2D_mittelpunktverrundung2 = catFactory2D1.CreatePoint(-mittelpunktverrundung_x, mittelpunktverrundung_y);

            // Verrundung oben links
            Point2D catP2D_schnittpunktevolventenverrundung1 = catFactory2D1.CreatePoint(schnittpunktevolventenverrundung_x, schnittpunktevolventenverrundung_y);

            //Verrundung oben rechts
            Point2D catP2D_schnittpunktevolventenverrundung2 = catFactory2D1.CreatePoint(-schnittpunktevolventenverrundung_x, schnittpunktevolventenverrundung_y);



            //Kreise

            //Fußkreis links
            Circle2D catC2D_Frußkreis = catFactory2D1.CreateCircle(x0, y0, fußkreisradius, 0, 0);

            catC2D_Frußkreis.CenterPoint = catP2D_Ursprung;
            catC2D_Frußkreis.StartPoint  = catP2D_schnittpunktfußkreisradius1;
            catC2D_Frußkreis.EndPoint    = catP2D_startpunktfußkreis;

            //Kopfkreis
            Circle2D catC2D_Kopfkreis = catFactory2D1.CreateCircle(x0, y0, kopfkreisradius, 0, 0);

            catC2D_Kopfkreis.CenterPoint = catP2D_Ursprung;
            catC2D_Kopfkreis.StartPoint  = catP2D_schnittpunktevolventenkreis2;
            catC2D_Kopfkreis.EndPoint    = catP2D_schnittpunktevolventenkreis1;

            //Evolvente links
            Circle2D catC2D_EvolventenKreis1 = catFactory2D1.CreateCircle(mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r, 0, 0);

            catC2D_EvolventenKreis1.CenterPoint = catP2D_mittelpunktevolventenkreis1;
            catC2D_EvolventenKreis1.StartPoint  = catP2D_schnittpunktevolventenkreis1;
            catC2D_EvolventenKreis1.EndPoint    = catP2D_schnittpunktevolventenverrundung1;

            //Evolvente rechts
            Circle2D catC2D_Evolventenkreis2 = catFactory2D1.CreateCircle(-mittelpunkt_evolventenkreis_x, mittelpunkt_evolventenkreis_y, evolventenkreis_r, 0, 0);

            catC2D_Evolventenkreis2.CenterPoint = catP2D_mittelpunktevolventenkreis2;
            catC2D_Evolventenkreis2.StartPoint  = catP2D_schnittpunktevolventenverrundung2;
            catC2D_Evolventenkreis2.EndPoint    = catP2D_schnittpunktevolventenkreis2;

            //Verrundung links
            Circle2D catC2D_VerrundungsKreis1 = catFactory2D1.CreateCircle(mittelpunktverrundung_x, mittelpunktverrundung_y, verrundungsradius, 0, 0);

            catC2D_VerrundungsKreis1.CenterPoint = catP2D_mittelpunktverrundung1;
            catC2D_VerrundungsKreis1.StartPoint  = catP2D_schnittpunktfußkreisradius1;
            catC2D_VerrundungsKreis1.EndPoint    = catP2D_schnittpunktevolventenverrundung1;

            //Verrundung rechts
            Circle2D catC2D_VerrundungsKreis2 = catFactory2D1.CreateCircle(-mittelpunktverrundung_x, mittelpunktverrundung_y, verrundungsradius, 0, 0);

            catC2D_VerrundungsKreis2.CenterPoint = catP2D_mittelpunktverrundung2;
            catC2D_VerrundungsKreis2.StartPoint  = catP2D_schnittpunktevolventenverrundung2;
            catC2D_VerrundungsKreis2.EndPoint    = catP2D_schnittpunktfußkreisradius2;


            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();
        }
Beispiel #17
0
        //Innenverzahntes Stirnrad
        public void ErzeugeProfilInnen(Data dat)
        {
            //KOORDINATEN ANLEGEN
            //Nullpunkt
            double x0 = 0;
            double y0 = 0;

            //Radien und Winkel umgestellt
            double Teilkreisradius = dat.getTeilkreisdurchmesser() / 2;
            //Angenährt
            double Hilfskreisradius  = Teilkreisradius * 1.12;
            double Kopfkreisradius   = Teilkreisradius - (1.25 * dat.getModul());
            double Fußkreisradius    = Teilkreisradius + dat.getModul();
            double Verrundungsradius = 0.35 * dat.getModul();

            double Alpha         = 20;
            double Beta          = 90 / dat.getZähnezahl();
            double Betarad       = Math.PI * Beta / 180;
            double Gamma         = 90 - (Alpha - Beta);
            double Gammarad      = Math.PI * Gamma / 180;
            double Totalangel    = 360.0 / dat.getZähnezahl();
            double Totalangelrad = Math.PI * Totalangel / 180;

            //Schnittpunkte und Koordinaten
            //Evolventenkreis Center Koordinaten
            double xMittelpunktaufEvol_links = Hilfskreisradius * Math.Cos(Gammarad);
            double yMittelpunktaufEvol_links = Hilfskreisradius * Math.Sin(Gammarad);

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

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

            //Evolvente Radius
            double EvolventenkreisRadius = Math.Sqrt(Math.Pow((xMittelpunktaufEvol_links - xPunktAufEvolvente), 2) + Math.Pow((yMittelpunktaufEvol_links - yPunktAufEvolvente), 2));

            //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);

            //Center 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);

            //Schnittpunkt 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);

            //Schnittpunkt 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);

            //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);



            //Geometrisches Set auswählen und umbennen
            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");



            //ERSTELLE SKIZZE FÜR SCHEIBE
            Sketches       sketchesBohrung   = catHybridBody1.HybridSketches;
            OriginElements catoriginelements = hsp_catiaPart.Part.OriginElements;
            Reference      refmxPlaneX       = (Reference)catoriginelements.PlaneYZ;

            hsp_catiaProfil = sketchesBohrung.Add(refmxPlaneX);

            ErzeugeAchsensystem();

            hsp_catiaPart.Part.Update();


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

            //Kreis
            Circle2D Scheibe = catfactory2D2.CreateClosedCircle(x0, y0, dat.getAußenradius());

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

            //Update
            hsp_catiaPart.Part.Update();

            //Erzeuge Block
            ShapeFactory shapeFactoryScheibe = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;

            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;
            Pad Block = shapeFactoryScheibe.AddNewPad(hsp_catiaProfil, dat.getBreite());

            hsp_catiaPart.Part.Update();



            //Zahnradskizze erstellen

            //Skizze umbenennen und öffnen
            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();

            //Update
            hsp_catiaPart.Part.Update();

            //Umbennen und öffnen
            hsp_catiaProfil.set_Name("Innenverzahntes Stirnrad");
            Factory2D catfactory2D1 = hsp_catiaProfil.OpenEdition();

            //Punkte in Skizze einzeichnen
            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, yMittelpunktaufEvol_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 einzeichnen
            Circle2D KreisFrußkreis = catfactory2D1.CreateCircle(x0, y0, Fußkreisradius, 0, Math.PI * 2);

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

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

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

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

            KreisEvolventenkreisLinks.CenterPoint = pointMittelpunktevolventeLinks;
            KreisEvolventenkreisLinks.EndPoint    = pointEvolventenKopfkreisLinks;
            KreisEvolventenkreisLinks.StartPoint  = 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 = pointMittelpunktevolventeRechts;
            KreisEvolventenkreisRechts.EndPoint    = pointVerrundungEvolventeRechts;
            KreisEvolventenkreisRechts.StartPoint  = pointEvolventenKopfkreisRechts;

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

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


            //Schließen
            hsp_catiaProfil.CloseEdition();

            //Updaten
            hsp_catiaPart.Part.Update();



            //ERSTELLE KREISMUSTER
            HybridShapeFactory hybridShapeFactory1 = (HybridShapeFactory)hsp_catiaPart.Part.HybridShapeFactory;
            ShapeFactory       shapeFactory1       = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;

            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 / dat.getZähnezahl());
            AngularRepartition angularRepartition2 = kreismuster.AngularRepartition;
            IntParam           intParam1           = angularRepartition2.InstancesCount;

            intParam1.Value = Convert.ToInt32(dat.getZähnezahl()) + 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);


            //Update
            hsp_catiaPart.Part.Update();

            //Tasche
            ErzeugeTasche(dat, refVerbindung, shapeFactory1);
            hsp_catiaProfil = catSketches1.Parent as MECMOD.Sketch;
            hsp_catiaPart.Part.Update();
        }
        public void ErzeugeProfil(Data dat)
        {
            //Nullpunkt
            double x0 = 0;
            double y0 = 0;

            //Hilfsgrößen von Wilkos PDF
            double teilkreisradius   = dat.getTeilkreisdurchmesser() / 2;
            double hilfskreisradius  = teilkreisradius * 0.94;
            double fußkreisradius    = teilkreisradius - (1.25 * dat.getModul());
            double kopfkreisradius   = teilkreisradius + dat.getModul();
            double verrundungsradius = 0.35 * dat.getModul();

            double alpha         = 20;
            double beta          = 90 / dat.getZähnezahl();
            double betarad       = Math.PI * beta / 180;
            double gamma         = 90 - (alpha - beta);
            double gammarad      = Math.PI * gamma / 180;
            double totalangle    = 360.0 / dat.getZähnezahl();
            double totalanglerad = Math.PI * totalangle / 180;

            //Punkte
            //LinkerEvolKreis Mittelp. Koordinaten
            double mittelpunktEvol_x = hilfskreisradius * Math.Cos(gammarad);
            double mittelpunktEvol_y = hilfskreisradius * Math.Sin(gammarad);

            // Schnittpkt. auf Evolvente und Teilkreisradius
            double punktEvol_x = -teilkreisradius *Math.Sin(betarad);

            double punktEvol_y = teilkreisradius * Math.Cos(betarad);

            //Evolventenkreis Radius
            double EvolventenkreisRadius = Math.Sqrt(Math.Pow((mittelpunktEvol_x - punktEvol_x), 2) + Math.Pow((mittelpunktEvol_y - punktEvol_y), 2));

            //Koordinaten Schnittpunkt Kopfkreis und Evolventenkreis
            double evolventenKopfk_x = Schnittpunkt_X(x0, y0, kopfkreisradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius);
            double evolventenKopfk_y = Schnittpunkt_Y(x0, y0, kopfkreisradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius);

            //Mittelpunktkoordinaten Verrundung
            double mittelpunktVer_x = Schnittpunkt_X(x0, y0, fußkreisradius + verrundungsradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius + verrundungsradius);
            double mittelpunktVer_y = Schnittpunkt_Y(x0, y0, fußkreisradius + verrundungsradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius + verrundungsradius);

            //Schnittpubktkoordinaten Verrundung - Evolventenkreis
            double evolventenVer_x = Schnittpunkt_X(mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);
            double evolventenVer_y = Schnittpunkt_Y(mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);

            //Schnittpunktkoordinaten Verrundung - Fußkreis
            double fußkreisVer_x = Schnittpunkt_X(x0, y0, fußkreisradius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);
            double fußkreisVer_y = Schnittpunkt_Y(x0, y0, fußkreisradius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);

            //Koordinaten Anfangspunkt Fußkreis
            double hilfswinkel        = totalanglerad - Math.Atan(Math.Abs(fußkreisVer_x) / Math.Abs(fußkreisVer_y));
            double anfangspunktFußk_x = -fußkreisradius *Math.Sin(hilfswinkel);

            double anfangspunktFußk_y = fußkreisradius * Math.Cos(hilfswinkel);

            //Skizze umbenennen und öffnen
            hsp_catiaProfil.set_Name("Außenverzahntes Stirnrad");
            Factory2D catfactory2D1 = hsp_catiaProfil.OpenEdition();

            //Nun die Punkte in die Skizze
            Point2D point_Ursprung             = catfactory2D1.CreatePoint(x0, y0);
            Point2D pointAnfangFußkreis        = catfactory2D1.CreatePoint(anfangspunktFußk_x, anfangspunktFußk_y);
            Point2D pointFußkreisVer_l         = catfactory2D1.CreatePoint(fußkreisVer_x, fußkreisVer_y);
            Point2D pointFußkreisVer_r         = catfactory2D1.CreatePoint(-fußkreisVer_x, fußkreisVer_y);
            Point2D pointMittelpunktVer_l      = catfactory2D1.CreatePoint(mittelpunktVer_x, mittelpunktVer_y);
            Point2D pointMittelpunktVer_r      = catfactory2D1.CreatePoint(-mittelpunktVer_x, mittelpunktVer_y);
            Point2D pointVerrundungEvol_l      = catfactory2D1.CreatePoint(evolventenVer_x, evolventenVer_y);
            Point2D pointVerrundungEvol_r      = catfactory2D1.CreatePoint(-evolventenVer_x, evolventenVer_y);
            Point2D pointMittelpunktevol_l     = catfactory2D1.CreatePoint(mittelpunktEvol_x, mittelpunktEvol_y);
            Point2D pointMittelpunktevol_r     = catfactory2D1.CreatePoint(-mittelpunktEvol_x, mittelpunktEvol_y);
            Point2D pointEvolventenKopfkreis_l = catfactory2D1.CreatePoint(evolventenKopfk_x, evolventenKopfk_y);
            Point2D pointEvolventenKopfkreis_r = catfactory2D1.CreatePoint(-evolventenKopfk_x, evolventenKopfk_y);

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

            kreisFußkreis.CenterPoint = point_Ursprung;
            kreisFußkreis.StartPoint  = pointFußkreisVer_l;
            kreisFußkreis.EndPoint    = pointAnfangFußkreis;

            Circle2D kreisVerrundung_l = catfactory2D1.CreateCircle(mittelpunktVer_x, mittelpunktVer_y, verrundungsradius, 0, Math.PI * 2);

            kreisVerrundung_l.CenterPoint = pointMittelpunktVer_l;
            kreisVerrundung_l.StartPoint  = pointFußkreisVer_l;
            kreisVerrundung_l.EndPoint    = pointVerrundungEvol_l;

            Circle2D kreisEvolventenkreis_l = catfactory2D1.CreateCircle(mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, 0, Math.PI * 2);

            kreisEvolventenkreis_l.CenterPoint = pointMittelpunktevol_l;
            kreisEvolventenkreis_l.StartPoint  = pointEvolventenKopfkreis_l;
            kreisEvolventenkreis_l.EndPoint    = pointVerrundungEvol_l;

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

            kreisKopfkreis.CenterPoint = point_Ursprung;
            kreisKopfkreis.StartPoint  = pointEvolventenKopfkreis_r;
            kreisKopfkreis.EndPoint    = pointEvolventenKopfkreis_l;

            Circle2D kreisEvolventenkreis_r = catfactory2D1.CreateCircle(-mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, 0, Math.PI * 2);

            kreisEvolventenkreis_r.CenterPoint = pointMittelpunktevol_r;
            kreisEvolventenkreis_r.StartPoint  = pointVerrundungEvol_r;
            kreisEvolventenkreis_r.EndPoint    = pointEvolventenKopfkreis_r;

            Circle2D kreisVerrundung_r = catfactory2D1.CreateCircle(-mittelpunktVer_x, mittelpunktVer_y, verrundungsradius, 0, Math.PI * 2);

            kreisVerrundung_r.CenterPoint = pointMittelpunktVer_r;
            kreisVerrundung_r.StartPoint  = pointVerrundungEvol_r;
            kreisVerrundung_r.EndPoint    = pointFußkreisVer_r;



            hsp_catiaProfil.CloseEdition();

            hsp_catiaPart.Part.Update();
        }
Beispiel #19
0
        //Außenverzahntes Stirnrad
        public void ErzeugeProfilAußen(Data dat)
        {
            //ERZEUGE SKIZZE
            //Geometrisches Set auswählen und umbennen

            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");
            Sketches       catSketches1      = catHybridBody1.HybridSketches;
            OriginElements catOriginElements = hsp_catiaPart.Part.OriginElements;
            Reference      catReference1     = (Reference)catOriginElements.PlaneYZ;

            hsp_catiaProfil = catSketches1.Add(catReference1);

            //Erstelle Achsensystem

            ErzeugeAchsensystem();

            //Update
            hsp_catiaPart.Part.Update();



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

            //Radien und Winkel
            double teilkreisradius   = dat.getTeilkreisdurchmesser() / 2;
            double hilfskreisradius  = teilkreisradius * 0.94;
            double fußkreisradius    = teilkreisradius - (1.25 * dat.getModul());
            double kopfkreisradius   = teilkreisradius + dat.getModul();
            double verrundungsradius = 0.35 * dat.getModul();

            double alpha         = 20;
            double beta          = 90 / dat.getZähnezahl();
            double betarad       = Math.PI * beta / 180;
            double gamma         = 90 - (alpha - beta);
            double gammarad      = Math.PI * gamma / 180;
            double totalangle    = 360.0 / dat.getZähnezahl();
            double totalanglerad = Math.PI * totalangle / 180;

            //Schnittpunkte und Koordinaten
            //Evolventenkreis Center Koordinaten
            double mittelpunktEvol_x = hilfskreisradius * Math.Cos(gammarad);
            double mittelpunktEvol_y = hilfskreisradius * Math.Sin(gammarad);

            //Schnittpkt. der Evolvente und dem Teilkreisradius
            double punktEvol_x = -teilkreisradius *Math.Sin(betarad);

            double punktEvol_y = teilkreisradius * Math.Cos(betarad);

            //Evolvente Radius
            double EvolventenkreisRadius = Math.Sqrt(Math.Pow((mittelpunktEvol_x - punktEvol_x), 2) + Math.Pow((mittelpunktEvol_y - punktEvol_y), 2));

            //Schnittpunkt Kopfkreis und Evolventenkreis
            double evolventenKopfk_x = Schnittpunkt_X(x0, y0, kopfkreisradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius);
            double evolventenKopfk_y = Schnittpunkt_Y(x0, y0, kopfkreisradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius);

            //Center Verrundung
            double mittelpunktVer_x = Schnittpunkt_X(x0, y0, fußkreisradius + verrundungsradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius + verrundungsradius);
            double mittelpunktVer_y = Schnittpunkt_Y(x0, y0, fußkreisradius + verrundungsradius, mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius + verrundungsradius);

            //Schnittpunkt Verrundung Evolventenkreis
            double evolventenVer_x = Schnittpunkt_X(mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);
            double evolventenVer_y = Schnittpunkt_Y(mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);

            //Schnittpunkt Verrundung Fußkreis
            double fußkreisVer_x = Schnittpunkt_X(x0, y0, fußkreisradius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);
            double fußkreisVer_y = Schnittpunkt_Y(x0, y0, fußkreisradius, mittelpunktVer_x, mittelpunktVer_y, verrundungsradius);

            //Anfangspunkt Fußkreis
            double hilfswinkel        = totalanglerad - Math.Atan(Math.Abs(fußkreisVer_x) / Math.Abs(fußkreisVer_y));
            double anfangspunktFußk_x = -fußkreisradius *Math.Sin(hilfswinkel);

            double anfangspunktFußk_y = fußkreisradius * Math.Cos(hilfswinkel);

            //Skizze umbenennen und öffnen
            hsp_catiaProfil.set_Name("Außenverzahntes Stirnrad");
            Factory2D catfactory2D1 = hsp_catiaProfil.OpenEdition();

            //Punkte in Skizze einzeichnen
            Point2D point_Ursprung             = catfactory2D1.CreatePoint(x0, y0);
            Point2D pointAnfangFußkreis        = catfactory2D1.CreatePoint(anfangspunktFußk_x, anfangspunktFußk_y);
            Point2D pointFußkreisVer_l         = catfactory2D1.CreatePoint(fußkreisVer_x, fußkreisVer_y);
            Point2D pointFußkreisVer_r         = catfactory2D1.CreatePoint(-fußkreisVer_x, fußkreisVer_y);
            Point2D pointMittelpunktVer_l      = catfactory2D1.CreatePoint(mittelpunktVer_x, mittelpunktVer_y);
            Point2D pointMittelpunktVer_r      = catfactory2D1.CreatePoint(-mittelpunktVer_x, mittelpunktVer_y);
            Point2D pointVerrundungEvol_l      = catfactory2D1.CreatePoint(evolventenVer_x, evolventenVer_y);
            Point2D pointVerrundungEvol_r      = catfactory2D1.CreatePoint(-evolventenVer_x, evolventenVer_y);
            Point2D pointMittelpunktevol_l     = catfactory2D1.CreatePoint(mittelpunktEvol_x, mittelpunktEvol_y);
            Point2D pointMittelpunktevol_r     = catfactory2D1.CreatePoint(-mittelpunktEvol_x, mittelpunktEvol_y);
            Point2D pointEvolventenKopfkreis_l = catfactory2D1.CreatePoint(evolventenKopfk_x, evolventenKopfk_y);
            Point2D pointEvolventenKopfkreis_r = catfactory2D1.CreatePoint(-evolventenKopfk_x, evolventenKopfk_y);

            //Kreise in Skizze einzeichnen
            Circle2D kreisFußkreis = catfactory2D1.CreateCircle(x0, y0, fußkreisradius, 0, Math.PI * 2);

            kreisFußkreis.CenterPoint = point_Ursprung;
            kreisFußkreis.StartPoint  = pointFußkreisVer_l;
            kreisFußkreis.EndPoint    = pointAnfangFußkreis;

            Circle2D kreisVerrundung_l = catfactory2D1.CreateCircle(mittelpunktVer_x, mittelpunktVer_y, verrundungsradius, 0, Math.PI * 2);

            kreisVerrundung_l.CenterPoint = pointMittelpunktVer_l;
            kreisVerrundung_l.StartPoint  = pointFußkreisVer_l;
            kreisVerrundung_l.EndPoint    = pointVerrundungEvol_l;

            Circle2D kreisEvolventenkreis_l = catfactory2D1.CreateCircle(mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, 0, Math.PI * 2);

            kreisEvolventenkreis_l.CenterPoint = pointMittelpunktevol_l;
            kreisEvolventenkreis_l.StartPoint  = pointEvolventenKopfkreis_l;
            kreisEvolventenkreis_l.EndPoint    = pointVerrundungEvol_l;

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

            kreisKopfkreis.CenterPoint = point_Ursprung;
            kreisKopfkreis.StartPoint  = pointEvolventenKopfkreis_r;
            kreisKopfkreis.EndPoint    = pointEvolventenKopfkreis_l;

            Circle2D kreisEvolventenkreis_r = catfactory2D1.CreateCircle(-mittelpunktEvol_x, mittelpunktEvol_y, EvolventenkreisRadius, 0, Math.PI * 2);

            kreisEvolventenkreis_r.CenterPoint = pointMittelpunktevol_r;
            kreisEvolventenkreis_r.StartPoint  = pointVerrundungEvol_r;
            kreisEvolventenkreis_r.EndPoint    = pointEvolventenKopfkreis_r;

            Circle2D kreisVerrundung_r = catfactory2D1.CreateCircle(-mittelpunktVer_x, mittelpunktVer_y, verrundungsradius, 0, Math.PI * 2);

            kreisVerrundung_r.CenterPoint = pointMittelpunktVer_r;
            kreisVerrundung_r.StartPoint  = pointVerrundungEvol_r;
            kreisVerrundung_r.EndPoint    = pointFußkreisVer_r;


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

            //Update
            hsp_catiaPart.Part.Update();



            //ERSTELLE KREISMUSTER
            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 / dat.getZähnezahl());
            AngularRepartition angularRepartition2 = kreismuster.AngularRepartition;
            IntParam           intParam1           = angularRepartition2.InstancesCount;

            intParam1.Value = Convert.ToInt32(dat.getZähnezahl()) + 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);

            //Update
            hsp_catiaPart.Part.Update();


            //ERSTELLE BLOCK
            ErzeugeBlock(refVerbindung, shapeFactory1, dat);


            if (dat.Bohrungsauswahl == 1)
            {
                //Skizze
                Sketches       sketchesBohrung   = catHybridBody1.HybridSketches;
                OriginElements catoriginelements = hsp_catiaPart.Part.OriginElements;
                Reference      refmxPlaneX       = (Reference)catoriginelements.PlaneYZ;
                hsp_catiaProfil = catSketches1.Add(refmxPlaneX);

                //Achsensystem
                ErzeugeAchsensystem();

                //Update
                hsp_catiaPart.Part.Update();

                //Skizze Umbennen
                hsp_catiaProfil.set_Name("Bohrung");

                //Öffnen
                Factory2D catfactory2D2 = hsp_catiaProfil.OpenEdition();

                //Kreis
                Circle2D KreisFürBohrungsskizze = catfactory2D2.CreateClosedCircle(x0, y0, dat.getBohrung());

                //Schließen
                hsp_catiaProfil.CloseEdition();

                //Update
                hsp_catiaPart.Part.Update();

                //Tasche
                hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;
                Pocket Tasche = shapeFactory1.AddNewPocket(hsp_catiaProfil, dat.getBreite());
                hsp_catiaPart.Part.Update();
            }
            if (dat.Bohrungsauswahl == 2)
            {
                //Schnittpunkte und Koordinaten
                //LH Schnittpunkt Passfederhöhe mit Bohrung
                double x_AnfangkreisZuPassfeder = -dat.getPassfederbreite() / 2;
                double y_AnfangkreisZuPassfeder = Math.Sqrt(Math.Pow(dat.getBohrung(), 2) - Math.Pow((dat.getPassfederbreite() / 2), 2));

                //LH Schnittpunkt Breite und Höhe
                double x_Passfederecke = -dat.getPassfederbreite() / 2;
                double y_Passfederecke = dat.getPassfederhöhe();

                //Skizze
                Sketches       sketchesBohrung   = catHybridBody1.HybridSketches;
                OriginElements catoriginelements = hsp_catiaPart.Part.OriginElements;
                Reference      refmxPlaneX       = (Reference)catoriginelements.PlaneYZ;
                hsp_catiaProfil = catSketches1.Add(refmxPlaneX);

                //Achsensystem
                ErzeugeAchsensystem();

                //Update
                hsp_catiaPart.Part.Update();

                //Umbennen und öffnen
                hsp_catiaProfil.set_Name("Bohrung mit Passfedernut");
                Factory2D catfactory2D2 = hsp_catiaProfil.OpenEdition();



                //Punkte in Skizze einzeichnen
                Point2D POINTLinksAnfangKreisZuPassfeder  = catfactory2D2.CreatePoint(x_AnfangkreisZuPassfeder, y_AnfangkreisZuPassfeder);
                Point2D POINTLinksPassfederEcke           = catfactory2D2.CreatePoint(x_Passfederecke, y_Passfederecke);
                Point2D POINTRechtsPassfederEcke          = catfactory2D2.CreatePoint(-x_Passfederecke, y_Passfederecke);
                Point2D POINTRechtsAnfangKreisZuPassfeder = catfactory2D2.CreatePoint(-x_AnfangkreisZuPassfeder, y_AnfangkreisZuPassfeder);

                //Linien einzeichnen
                Line2D PassfederKanteLinks = catfactory2D2.CreateLine(x_AnfangkreisZuPassfeder, y_AnfangkreisZuPassfeder, x_Passfederecke, y_Passfederecke);
                PassfederKanteLinks.StartPoint = POINTLinksAnfangKreisZuPassfeder;
                PassfederKanteLinks.EndPoint   = POINTLinksPassfederEcke;

                Line2D PassfederHöhenkante = catfactory2D2.CreateLine(x_Passfederecke, y_Passfederecke, -x_Passfederecke, y_Passfederecke);
                PassfederHöhenkante.StartPoint = POINTLinksPassfederEcke;
                PassfederHöhenkante.EndPoint   = POINTRechtsPassfederEcke;

                Line2D PassfederKanteRechts = catfactory2D2.CreateLine(-x_Passfederecke, y_Passfederecke, -x_AnfangkreisZuPassfeder, y_AnfangkreisZuPassfeder);
                PassfederKanteRechts.StartPoint = POINTRechtsPassfederEcke;
                PassfederKanteRechts.EndPoint   = POINTRechtsAnfangKreisZuPassfeder;

                Circle2D KreisFürPassfeder = catfactory2D2.CreateCircle(x0, y0, dat.getBohrung(), 0, Math.PI * 2);
                KreisFürPassfeder.CenterPoint = point_Ursprung;
                KreisFürPassfeder.EndPoint    = POINTRechtsAnfangKreisZuPassfeder;
                KreisFürPassfeder.StartPoint  = POINTLinksAnfangKreisZuPassfeder;

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


                //Update
                hsp_catiaPart.Part.Update();

                //Tasche
                hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;
                Pocket Tasche = shapeFactory1.AddNewPocket(hsp_catiaProfil, dat.getBreite());
                hsp_catiaPart.Part.Update();
            }
        }
        public void Rechteck_hohl_DrawSketch(double Rechteck_hohl_Breite, double Rechteck_hohl_Hoehe, double Wandstaerke)
        {
            double b = Rechteck_hohl_Breite;
            double h = Rechteck_hohl_Hoehe;
            double t = Wandstaerke;
            double bi = b - 2 * t;
            double hi = h - 2 * t;
            double ra, ri;

            // Berechnung der Eckenradien nach DIN EN 10219-2:2006 für Hohlprofile
            if (t <= 6)
            {
                ra = 1.6 * t;
            }
            else if (t <= 10)
            {
                ra = 2 * t;
            }
            else if (t > 10)
            {
                ra = 2.4 * t;
            }
            else
            {
                ra = 2.4 * t;
            }

            ri = ra - t;

            CATIA_Rechteck_hohl_2D.set_Name("Rechteck-Hohlprofil");

            Factory2D Rechteck_hohl_Factory = CATIA_Rechteck_hohl_2D.OpenEdition();

            // Definition der Radienmittelpunkte
            Point2D Mittelpunkt1            = Rechteck_hohl_Factory.CreatePoint(ra, ra);
            Point2D Mittelpunkt2            = Rechteck_hohl_Factory.CreatePoint((b - ra), ra);
            Point2D Mittelpunkt3            = Rechteck_hohl_Factory.CreatePoint((b - ra), (h - ra));
            Point2D Mittelpunkt4            = Rechteck_hohl_Factory.CreatePoint(ra, (h - ra));

            // Definition des äußeren Rechtecks
            Point2D Konturpunkt1 = Rechteck_hohl_Factory.CreatePoint(ra, 0);
            Point2D Konturpunkt2 = Rechteck_hohl_Factory.CreatePoint((b - ra), 0);
            Point2D Konturpunkt3 = Rechteck_hohl_Factory.CreatePoint(b, ra);
            Point2D Konturpunkt4 = Rechteck_hohl_Factory.CreatePoint(b, (h - ra));
            Point2D Konturpunkt5 = Rechteck_hohl_Factory.CreatePoint((b - ra), h);
            Point2D Konturpunkt6 = Rechteck_hohl_Factory.CreatePoint(ra, h);
            Point2D Konturpunkt7 = Rechteck_hohl_Factory.CreatePoint(0, (h - ra));
            Point2D Konturpunkt8 = Rechteck_hohl_Factory.CreatePoint(0, ra);

            Line2D Linie12 = Rechteck_hohl_Factory.CreateLine(ra, 0, (b - ra), 0);

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

            Line2D Linie34 = Rechteck_hohl_Factory.CreateLine(b, ra, b, (h - ra));

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

            Line2D Linie56 = Rechteck_hohl_Factory.CreateLine((b - ra), h, ra, h);

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

            Line2D Linie78 = Rechteck_hohl_Factory.CreateLine(0, (h - ra), 0, ra);

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

            Circle2D Eckenverrundung81 = Rechteck_hohl_Factory.CreateCircle(ra, ra, ra, 0, 0);

            Eckenverrundung81.CenterPoint = Mittelpunkt1;
            Eckenverrundung81.StartPoint  = Konturpunkt8;
            Eckenverrundung81.EndPoint    = Konturpunkt1;

            Circle2D Eckenverrundung23 = Rechteck_hohl_Factory.CreateCircle(0, 0, ra, 0, 0);

            Eckenverrundung23.CenterPoint = Mittelpunkt2;
            Eckenverrundung23.StartPoint  = Konturpunkt2;
            Eckenverrundung23.EndPoint    = Konturpunkt3;

            Circle2D Eckenverrundung45 = Rechteck_hohl_Factory.CreateCircle(0, 0, ra, 0, 0);

            Eckenverrundung45.CenterPoint = Mittelpunkt3;
            Eckenverrundung45.StartPoint  = Konturpunkt4;
            Eckenverrundung45.EndPoint    = Konturpunkt5;

            Circle2D Eckenverrundung67 = Rechteck_hohl_Factory.CreateCircle(0, 0, ra, 0, 0);

            Eckenverrundung67.CenterPoint = Mittelpunkt4;
            Eckenverrundung67.StartPoint  = Konturpunkt6;
            Eckenverrundung67.EndPoint    = Konturpunkt7;

            // Definition des inneren Rechtecks
            Point2D Konturpunkt_i1 = Rechteck_hohl_Factory.CreatePoint(ra, t);
            Point2D Konturpunkt_i2 = Rechteck_hohl_Factory.CreatePoint((b - ra), t);
            Point2D Konturpunkt_i3 = Rechteck_hohl_Factory.CreatePoint((b - t), ra);
            Point2D Konturpunkt_i4 = Rechteck_hohl_Factory.CreatePoint((b - t), (h - ra));
            Point2D Konturpunkt_i5 = Rechteck_hohl_Factory.CreatePoint((b - ra), (h - t));
            Point2D Konturpunkt_i6 = Rechteck_hohl_Factory.CreatePoint(ra, (h - t));
            Point2D Konturpunkt_i7 = Rechteck_hohl_Factory.CreatePoint(t, (h - ra));
            Point2D Konturpunkt_i8 = Rechteck_hohl_Factory.CreatePoint(t, ra);

            Line2D Linie_i12 = Rechteck_hohl_Factory.CreateLine(ra, t, (b - ra), t);

            Linie_i12.StartPoint = Konturpunkt_i1;
            Linie_i12.EndPoint   = Konturpunkt_i2;

            Line2D Linie_i34 = Rechteck_hohl_Factory.CreateLine((b - t), ra, (b - t), (h - ra));

            Linie_i34.StartPoint = Konturpunkt_i3;
            Linie_i34.EndPoint   = Konturpunkt_i4;

            Line2D Linie_i56 = Rechteck_hohl_Factory.CreateLine((b - ra), (h - t), ra, (h - t));

            Linie_i56.StartPoint = Konturpunkt_i5;
            Linie_i56.EndPoint   = Konturpunkt_i6;

            Line2D Linie_i78 = Rechteck_hohl_Factory.CreateLine(t, (h - ra), t, ra);

            Linie_i78.StartPoint = Konturpunkt_i7;
            Linie_i78.EndPoint   = Konturpunkt_i8;

            Circle2D Eckenverrundung_i81 = Rechteck_hohl_Factory.CreateCircle(ra, ra, ri, 0, 0);

            Eckenverrundung_i81.CenterPoint = Mittelpunkt1;
            Eckenverrundung_i81.StartPoint  = Konturpunkt_i8;
            Eckenverrundung_i81.EndPoint    = Konturpunkt_i1;

            Circle2D Eckenverrundung_i23 = Rechteck_hohl_Factory.CreateCircle((b - ra), ra, ri, 0, 0);

            Eckenverrundung_i23.CenterPoint = Mittelpunkt2;
            Eckenverrundung_i23.StartPoint  = Konturpunkt_i2;
            Eckenverrundung_i23.EndPoint    = Konturpunkt_i3;

            Circle2D Eckenverrundung_i45 = Rechteck_hohl_Factory.CreateCircle((b - ra), (h - ra), ri, 0, 0);

            Eckenverrundung_i45.CenterPoint = Mittelpunkt3;
            Eckenverrundung_i45.StartPoint  = Konturpunkt_i4;
            Eckenverrundung_i45.EndPoint    = Konturpunkt_i5;

            Circle2D Eckenverrundung_i67 = Rechteck_hohl_Factory.CreateCircle(ra, (h - ra), ri, 0, 0);

            Eckenverrundung_i67.CenterPoint = Mittelpunkt4;
            Eckenverrundung_i67.StartPoint  = Konturpunkt_i6;
            Eckenverrundung_i67.EndPoint    = Konturpunkt_i7;


            CATIA_Rechteck_hohl_2D.CloseEdition();

            CATIA_Rechteck_hohl_Part.Part.Update();
        }
Beispiel #21
0
        //Funktion ErzeugeVierkantrohr (mitRadien)
        public void ErzeugeVierkantrohr(Double r_ah, Double r_ab, Double z)
        {
            hsp_catiaProfil.set_Name("VierkantRohr");
            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();

            Point2D catPoint2D1 = catFactory2D1.CreatePoint(z, z);

            Point2D catPoint2D5  = catFactory2D1.CreatePoint(0, z);
            Point2D catPoint2D12 = catFactory2D1.CreatePoint(z, 0);

            Circle2D catCircle2D1 = catFactory2D1.CreateCircle(z, z, z, 0, 0);

            catCircle2D1.CenterPoint = catPoint2D1;
            catCircle2D1.StartPoint  = catPoint2D5;
            catCircle2D1.EndPoint    = catPoint2D12;

            Point2D catPoint2D6 = catFactory2D1.CreatePoint(0, r_ah - z);

            Line2D catLine2D1 = catFactory2D1.CreateLine(0, z, 0, r_ah - z);

            catLine2D1.StartPoint = catPoint2D5;
            catLine2D1.EndPoint   = catPoint2D6;

            Point2D catPoint2D2 = catFactory2D1.CreatePoint(z, r_ah - z);
            Point2D catPoint2D7 = catFactory2D1.CreatePoint(z, r_ah);

            Circle2D catCircle2D2 = catFactory2D1.CreateCircle(z, r_ah - z, z, 0, 0);

            catCircle2D2.CenterPoint = catPoint2D2;
            catCircle2D2.StartPoint  = catPoint2D7;
            catCircle2D2.EndPoint    = catPoint2D6;

            Point2D catPoint2D8 = catFactory2D1.CreatePoint(r_ab - z, r_ah);

            Line2D catLine2D2 = catFactory2D1.CreateLine(z, r_ah, r_ab - z, r_ah);

            catLine2D2.StartPoint = catPoint2D7;
            catLine2D2.EndPoint   = catPoint2D8;

            Point2D catPoint2D3 = catFactory2D1.CreatePoint(r_ab - z, r_ah - z);
            Point2D catPoint2D9 = catFactory2D1.CreatePoint(r_ab, r_ah - z);

            Circle2D catCircle2D3 = catFactory2D1.CreateCircle(r_ab - z, r_ah - z, z, 0, 0);

            catCircle2D3.CenterPoint = catPoint2D3;
            catCircle2D3.StartPoint  = catPoint2D9;
            catCircle2D3.EndPoint    = catPoint2D8;

            Point2D catPoint2D10 = catFactory2D1.CreatePoint(r_ab, z);

            Line2D catLine2D3 = catFactory2D1.CreateLine(r_ab, r_ah - z, r_ab, z);

            catLine2D3.StartPoint = catPoint2D9;
            catLine2D3.EndPoint   = catPoint2D10;

            Point2D catPoint2D4  = catFactory2D1.CreatePoint(r_ab - z, z);
            Point2D catPoint2D11 = catFactory2D1.CreatePoint(r_ab - z, 0);

            Circle2D catCircle2D4 = catFactory2D1.CreateCircle(r_ab - z, z, z, z, z);

            catCircle2D4.CenterPoint = catPoint2D4;
            catCircle2D4.StartPoint  = catPoint2D11;
            catCircle2D4.EndPoint    = catPoint2D10;

            Line2D catLine2D4 = catFactory2D1.CreateLine(r_ab - z, 0, z, 0);

            catLine2D4.StartPoint = catPoint2D11;
            catLine2D4.EndPoint   = catPoint2D12;

            Point2D catPoint2D13 = catFactory2D1.CreatePoint(z / 2, z);
            Point2D catPoint2D20 = catFactory2D1.CreatePoint(z, z / 2);

            Circle2D catCircle2D5 = catFactory2D1.CreateCircle(z, z, z / 2, z / 2, z / 2);

            catCircle2D5.CenterPoint = catPoint2D1;
            catCircle2D5.StartPoint  = catPoint2D13;
            catCircle2D5.EndPoint    = catPoint2D20;

            Point2D catPoint2D14 = catFactory2D1.CreatePoint(z / 2, r_ah - z);

            Line2D catLine2D5 = catFactory2D1.CreateLine(z / 2, z, z / 2, r_ah - z);

            catLine2D5.StartPoint = catPoint2D13;
            catLine2D5.EndPoint   = catPoint2D14;

            Point2D catPoint2D15 = catFactory2D1.CreatePoint(z, r_ah - z / 2);

            Circle2D catCircle2D6 = catFactory2D1.CreateCircle(z, r_ah - z, z / 2, z / 2, z / 2);

            catCircle2D6.CenterPoint = catPoint2D2;
            catCircle2D6.StartPoint  = catPoint2D15;
            catCircle2D6.EndPoint    = catPoint2D14;

            Point2D catPoint2D16 = catFactory2D1.CreatePoint(r_ab - z, r_ah - z / 2);

            Line2D catLine2D6 = catFactory2D1.CreateLine(z, r_ah - z / 2, r_ab - z, r_ah - z / 2);

            catLine2D6.StartPoint = catPoint2D16;
            catLine2D6.EndPoint   = catPoint2D15;

            Point2D catPoint2D17 = catFactory2D1.CreatePoint(r_ab - z / 2, r_ah - z);

            Circle2D catCircle2D7 = catFactory2D1.CreateCircle(r_ab - z, r_ah - z, z / 2, z / 2, z / 2);

            catCircle2D7.CenterPoint = catPoint2D3;
            catCircle2D7.StartPoint  = catPoint2D17;
            catCircle2D7.EndPoint    = catPoint2D16;

            Point2D catPoint2D18 = catFactory2D1.CreatePoint(r_ab - z / 2, z);

            Line2D catLine2D7 = catFactory2D1.CreateLine(r_ab - z / 2, r_ah - z, r_ab - z / 2, z);

            catLine2D7.StartPoint = catPoint2D17;
            catLine2D7.EndPoint   = catPoint2D18;

            Point2D catPoint2D19 = catFactory2D1.CreatePoint(r_ab - z, z / 2);

            Circle2D catCircle2D8 = catFactory2D1.CreateCircle(r_ab - z, z, z / 2, z / 2, z / 2);

            catCircle2D8.CenterPoint = catPoint2D4;
            catCircle2D8.StartPoint  = catPoint2D19;
            catCircle2D8.EndPoint    = catPoint2D18;

            Line2D catLine2D8 = catFactory2D1.CreateLine(r_ab - z, z / 2, z, z / 2);

            catLine2D8.StartPoint = catPoint2D19;
            catLine2D8.EndPoint   = catPoint2D20;

            hsp_catiaProfil.CloseEdition();
            hsp_catiaPart.Part.Update();
        }
Beispiel #22
0
        private Sketch makeGewindeSkizze(Schraube s)
        {
            Double P  = s.metrischeGewindegroesse.steigung;
            Double Ri = s.metrischeGewindegroesse.bezeichnung / 2;


            OriginElements catOriginElements = hsp_catiaPart.Part.OriginElements;
            Reference      RefmyPlaneZX      = (Reference)catOriginElements.PlaneZX;

            Sketches catSketchesGewinde = catHybridBody1.HybridSketches;
            Sketch   myGewinde          = catSketchesGewinde.Add(RefmyPlaneZX);

            hsp_catiaPart.Part.InWorkObject = myGewinde;
            myGewinde.set_Name("Gewinde");

            double V_oben_links = -(((((Math.Sqrt(3) / 2) * P) / 6) + 0.6134 * P) * Math.Tan((30 * Math.PI) / 180) - s.schaftLaenge.schaftlaenge);
            double H_oben_links = Ri;

            double V_oben_rechts = (((((Math.Sqrt(3) / 2) * P) / 6) + 0.6134 * P) * Math.Tan((30 * Math.PI) / 180) + s.schaftLaenge.schaftlaenge);
            double H_oben_rechts = Ri;

            double V_unten_links = -((0.1443 * P) * Math.Sin((60 * Math.PI) / 180) - s.schaftLaenge.schaftlaenge);
            double H_unten_links = Ri - (0.6134 * P - 0.1443 * P) - Math.Sqrt(Math.Pow((0.1443 * P), 2) - Math.Pow((0.1443 * P) * Math.Sin((60 * Math.PI) / 180), 2));

            double V_unten_rechts = (0.1443 * P) * Math.Sin((60 * Math.PI) / 180) + s.schaftLaenge.schaftlaenge;
            double H_unten_rechts = Ri - (0.6134 * P - 0.1443 * P) - Math.Sqrt(Math.Pow((0.1443 * P), 2) - Math.Pow((0.1443 * P) * Math.Sin((60 * Math.PI) / 180), 2));

            double V_Mittelpunkt = s.schaftLaenge.schaftlaenge;
            double H_Mittelpunkt = Ri - ((0.6134 * P) - 0.1443 * P);

            Factory2D catFactory2D2 = myGewinde.OpenEdition();

            Point2D Oben_links   = catFactory2D2.CreatePoint(H_oben_links, V_oben_links);
            Point2D Oben_rechts  = catFactory2D2.CreatePoint(H_oben_rechts, V_oben_rechts);
            Point2D Unten_links  = catFactory2D2.CreatePoint(H_unten_links, V_unten_links);
            Point2D Unten_rechts = catFactory2D2.CreatePoint(H_unten_rechts, V_unten_rechts);
            Point2D Mittelpunkt  = catFactory2D2.CreatePoint(H_Mittelpunkt, V_Mittelpunkt);

            Line2D Oben = catFactory2D2.CreateLine(H_oben_links, V_oben_links, H_oben_rechts, V_oben_rechts);

            Oben.StartPoint = Oben_links;
            Oben.EndPoint   = Oben_rechts;

            Line2D Rechts = catFactory2D2.CreateLine(H_oben_rechts, V_oben_rechts, H_unten_rechts, V_unten_rechts);

            Rechts.StartPoint = Oben_rechts;
            Rechts.EndPoint   = Unten_rechts;

            Circle2D Verrundung = catFactory2D2.CreateCircle(H_Mittelpunkt, V_Mittelpunkt, 0.1443 * P, 0, 0);

            Verrundung.CenterPoint = Mittelpunkt;
            Verrundung.StartPoint  = Unten_rechts;
            Verrundung.EndPoint    = Unten_links;

            Line2D Links = catFactory2D2.CreateLine(H_oben_links, V_oben_links, H_unten_links, V_unten_links);

            Links.StartPoint = Unten_links;
            Links.EndPoint   = Oben_links;

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

            return(myGewinde);
        }
Beispiel #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();
        }
Beispiel #24
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();
        }
Beispiel #25
0
        public void ZylinderkopfInnensechskant(MetrischeGewindegroesse m)
        {
            #region SKizze bauen
            // 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();
            hsp_catiaProfil.set_Name("Zylinderkopf mit Innensechskannt");
            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();

            Factory2D catFactory2D1 = hsp_catiaProfil.OpenEdition();

            // erst die Punkte
            Point2D catPoint2D1 = catFactory2D1.CreatePoint(0, 0);

            // dann den Kreis
            Circle2D catCircle2D_1 = catFactory2D1.CreateCircle(0, 0, m.kopfdurchmesser / 2, 0, 0);
            catCircle2D_1.CenterPoint = catPoint2D1;

            // Skizzierer verlassen
            hsp_catiaProfil.CloseEdition();

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

            #region Pad
            // Hauptkoerper in Bearbeitung definieren
            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;

            // Block(Schaft) erzeugen
            ShapeFactory catShapeFactory1 = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;
            KopfPad = catShapeFactory1.AddNewPad(hsp_catiaProfil, -m.mutterhoehe);

            // Block umbenennen
            KopfPad.set_Name("Kopf");

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

            #region Offsetebene
            Reference RefmyPlaneYZ = (Reference)catOriginElements.PlaneYZ;
            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part;
            HybridShapeFactory     hybridShapeFactory1 = (HybridShapeFactory)hsp_catiaPart.Part.HybridShapeFactory;
            HybridShapePlaneOffset OffsetEbene         = hybridShapeFactory1.AddNewPlaneOffset(RefmyPlaneYZ, m.mutterhoehe, true);
            OffsetEbene.set_Name("OffsetEbene");
            Reference    RefOffsetEbene = hsp_catiaPart.Part.CreateReferenceFromObject(OffsetEbene);
            HybridBodies hybridBodies1  = hsp_catiaPart.Part.HybridBodies;
            HybridBody   hybridBody1    = hybridBodies1.Item("Profile");
            hybridBody1.AppendHybridShape(OffsetEbene);


            hsp_catiaPart.Part.Update();
            Sketches catSketches2    = catHybridBody1.HybridSketches;
            Sketch   SkizzeaufOffset = catSketches2.Add(RefOffsetEbene);
            hsp_catiaPart.Part.InWorkObject = SkizzeaufOffset;
            SkizzeaufOffset.set_Name("OffsetSkizze");

            // Achsensystem in Skizze erstellen
            ErzeugeAchsensystem();
            // Skizzierer verlassen
            SkizzeaufOffset.CloseEdition();
            // Part aktualisieren
            hsp_catiaPart.Part.Update();
            #endregion

            #region Innensechskannt
            Factory2D catFactory2D2 = SkizzeaufOffset.OpenEdition();

            // Sechskant erzeugen
            double tan30 = Math.Sqrt(3) / 3;
            double cos30 = Math.Sqrt(3) / 2;
            double mSW   = m.innensechskant / 2;

            // erst die Punkte
            Point2D catPoint2D2 = catFactory2D2.CreatePoint(mSW, tan30 * mSW);
            Point2D catPoint2D3 = catFactory2D2.CreatePoint(mSW, -(tan30 * mSW));
            Point2D catPoint2D4 = catFactory2D2.CreatePoint(0, -(mSW / cos30));
            Point2D catPoint2D5 = catFactory2D2.CreatePoint(-mSW, -(tan30 * mSW));
            Point2D catPoint2D6 = catFactory2D2.CreatePoint(-mSW, tan30 * mSW);
            Point2D catPoint2D7 = catFactory2D2.CreatePoint(0, mSW / cos30);

            // dann die Linien
            Line2D catLine2D1 = catFactory2D2.CreateLine(mSW, tan30 * mSW, mSW, -(tan30 * mSW));
            catLine2D1.StartPoint = catPoint2D2;
            catLine2D1.EndPoint   = catPoint2D3;

            Line2D catLine2D2 = catFactory2D2.CreateLine(mSW, -(tan30 * mSW), 0, -(mSW / cos30));
            catLine2D2.StartPoint = catPoint2D3;
            catLine2D2.EndPoint   = catPoint2D4;

            Line2D catLine2D3 = catFactory2D2.CreateLine(0, -(mSW / cos30), -mSW, -(tan30 * mSW));
            catLine2D3.StartPoint = catPoint2D4;
            catLine2D3.EndPoint   = catPoint2D5;

            Line2D catLine2D4 = catFactory2D2.CreateLine(-mSW, -(tan30 * mSW), -mSW, (tan30 * mSW));
            catLine2D4.StartPoint = catPoint2D5;
            catLine2D4.EndPoint   = catPoint2D6;

            Line2D catLine2D5 = catFactory2D2.CreateLine(-mSW, (tan30 * mSW), 0, mSW / cos30);
            catLine2D5.StartPoint = catPoint2D6;
            catLine2D5.EndPoint   = catPoint2D7;

            Line2D catLine2D6 = catFactory2D2.CreateLine(0, mSW / cos30, mSW, tan30 * mSW);
            catLine2D6.StartPoint = catPoint2D7;
            catLine2D6.EndPoint   = catPoint2D2;

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

            #region Verrundung
            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;

            ShapeFactory catshapeFactoryRadius = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;

            Reference reference1 = hsp_catiaPart.Part.CreateReferenceFromBRepName(  //Hier scheint der Fehler drin zu stecken, er erkennt nicht die richtige kante--wenn nicht die Kante, sondern die Fläche ausgewählt wird, scheint der Fehler behpoben zu sein
                "RSur:(Face:(Brp:(Pad.2;2);None:();Cf11:());WithTemporaryBody;WithoutBuildError;WithSelectingFeatureSupport;MFBRepVersion_CXR15)", KopfPad);
            // "REdge:(Edge:(Face:(Brp:(Pad.1;0:(Brp:(Sketch.1;1)));None:();Cf11:());Face:(Brp:(Pad.1;2);None:();Cf11:());None:(Limits1:();Limits2:());Cf11:());WithTemporaryBody;WithoutBuildError;WithSelectingFeatureSupport;MFBRepVersion_CXR15)", SchaftPad);
            RadiusKopf = catshapeFactoryRadius.AddNewEdgeFilletWithConstantRadius(reference1, CatFilletEdgePropagation.catTangencyFilletEdgePropagation, m.fase);


            RadiusKopf.set_Name("Radius");
            hsp_catiaPart.Part.Update();
            #endregion

            #region Tasche Innensechskannt
            // Hauptkoerper in Bearbeitung definieren
            hsp_catiaPart.Part.InWorkObject = hsp_catiaPart.Part.MainBody;

            // Tasche erzeugen erzeugen
            ShapeFactory catShapeFactory2 = (ShapeFactory)hsp_catiaPart.Part.ShapeFactory;

            SchlitzPocket = catShapeFactory2.AddNewPocket(SkizzeaufOffset, -m.innensktiefe);

            // Block umbenennen
            SchlitzPocket.set_Name("Innensechskant");

            // Part aktualisieren
            hsp_catiaPart.Part.Update();
            #endregion
        }
Beispiel #26
0
        static void Logo(Factory2D F, float X, float Y, float Height, float Fatness)
        {
            const double AngleOffset = 0.09;

            Ellipse2D LeftUpper = F.CreateEllipse(X, Y - Fatness / 2 + Height,
                0, 0, Height / 2, Height, -3 * Math.PI / 2, -Math.PI / 2);

            Ellipse2D RightUpperUpper = F.CreateEllipse(X, Y - Fatness / 2 + Height,
                0, 0, Height / 2 - Fatness, Height - Fatness, Math.PI / 2, Math.PI - AngleOffset);

            Ellipse2D RightUpperLower = F.CreateEllipse(X, Y - Fatness / 2 + Height,
                0, 0, Height / 2 - Fatness, Height - Fatness, Math.PI + AngleOffset, 3 * Math.PI / 2);

            Ellipse2D LeftLower = F.CreateEllipse(X, Y + Fatness / 2 - Height,
                0, 0, Height / 2 - Fatness, Height - Fatness, 3 * Math.PI / 2, Math.PI / 2);
            Ellipse2D RightLower = F.CreateEllipse(X, Y + Fatness / 2 - Height,
                0, 0, Height / 2, Height, 3 * Math.PI / 2, Math.PI / 2);

            LeftUpper.EndPoint = LeftLower.EndPoint;
            RightUpperLower.EndPoint = RightLower.EndPoint;

            Circle2D UpperCircle = F.CreateCircle(X, (Y + Height * 2) - Fatness, Fatness / 2, -Math.PI / 2, Math.PI / 2);
            UpperCircle.EndPoint = LeftUpper.StartPoint;
            UpperCircle.StartPoint = RightUpperUpper.StartPoint;

            Circle2D LowerCircle = F.CreateCircle(X, (Y - Height * 2) + Fatness, Fatness / 2, Math.PI / 2, -Math.PI / 2);
            LowerCircle.StartPoint = LeftLower.StartPoint;
            LowerCircle.EndPoint = RightLower.StartPoint;

            Point2D BarLowerStart = RightUpperLower.StartPoint;
            Line2D BarLower = F.CreateLine(BarLowerStart.GetPos().X, BarLowerStart.GetPos().Y,
                BarLowerStart.GetPos().X + Height / 2, BarLowerStart.GetPos().Y);
            BarLower.StartPoint = BarLowerStart;

            Point2D BarUpperStart = RightUpperUpper.EndPoint;
            Line2D BarUpper = F.CreateLine(BarUpperStart.GetPos().X, BarUpperStart.GetPos().Y,
                BarUpperStart.GetPos().X + Height / 2, BarUpperStart.GetPos().Y);
            BarUpper.StartPoint = BarUpperStart;

            double UpperX = BarUpper.EndPoint.GetPos().X;
            double UpperY = BarUpper.EndPoint.GetPos().Y;
            double LowerY = BarLower.EndPoint.GetPos().Y;
            double R = (UpperY - LowerY) / 2;
            Circle2D BarCircle = F.CreateCircle(UpperX, LowerY + R, R, -Math.PI / 2, Math.PI / 2);
            BarCircle.EndPoint = BarUpper.EndPoint;
            BarCircle.StartPoint = BarLower.EndPoint;
        }