示例#1
0
                public void CalculerUsinage(ListFaceGeom faceExt)
                {
                    Dictionary <FaceGeom, List <Edge> > ListeArreteExt = new Dictionary <FaceGeom, List <Edge> >();

                    foreach (var fg in faceExt.ListeFaceGeom)
                    {
                        var le = new List <Edge>();
                        var lf = new List <Face2>(fg.ListeSwFace);
                        ListeArreteExt.Add(fg, le);

                        foreach (var f in lf)
                        {
                            le.AddRange(f.eListeDesArretes());
                        }
                    }

                    foreach (var a in ListeArretes)
                    {
                        foreach (var fg in ListeArreteExt.Keys)
                        {
                            foreach (var ab in ListeArreteExt[fg])
                            {
                                if (ab.eIsSame(a))
                                {
                                    ListeFaceDecoupe.AddIfNotExist(fg);
                                    ListeArreteDecoupe.Add(a);
                                    LgUsinage += a.eLgArrete();
                                }
                            }
                        }
                    }
                }
示例#2
0
            private void AnalyserFaces()
            {
                try
                {
                    List <FaceGeom> ListeFaceCorps = new List <FaceGeom>();

                    // Tri des faces pour retrouver celles issues de la même
                    foreach (var Face in Corps.eListeDesFaces())
                    {
                        var faceExt = new FaceGeom(Face);

                        Boolean Ajouter = true;

                        foreach (var f in ListeFaceCorps)
                        {
                            // Si elles sont identiques, la face "faceExt" est ajoutée à la liste
                            // de face de "f"
                            if (f.FaceExtIdentique(faceExt))
                            {
                                Ajouter = false;
                                break;
                            }
                        }

                        // S'il n'y avait pas de face identique, on l'ajoute.
                        if (Ajouter)
                        {
                            ListeFaceCorps.Add(faceExt);
                        }
                    }

                    List <FaceGeom> ListeFaceGeom = new List <FaceGeom>();
                    PlanSection         = RechercherFaceProfil(ListeFaceCorps, ref ListeFaceGeom);
                    ListeFaceSectionInt = TrierFacesConnectees(ListeFaceGeom);

                    // Plan de la section et infos
                    {
                        var    v = PlanSection.Normale;
                        Double X = 0, Y = 0, Z = 0;
                        Corps.GetExtremePoint(v.X, v.Y, v.Z, out X, out Y, out Z);
                        ExtremPoint1 = new gPoint(X, Y, Z);
                        v.Inverser();
                        Corps.GetExtremePoint(v.X, v.Y, v.Z, out X, out Y, out Z);
                        ExtremPoint2 = new gPoint(X, Y, Z);
                    }

                    // =================================================================================

                    // On recherche la face exterieure
                    // s'il y a plusieurs boucles de surfaces
                    if (ListeFaceSectionInt.Count > 1)
                    {
                        {
                            // Si la section n'est composé que de cylindre fermé
                            Boolean      EstUnCylindre = true;
                            ListFaceGeom Ext           = null;
                            Double       RayonMax      = 0;
                            foreach (var fg in ListeFaceSectionInt)
                            {
                                if (fg.ListeFaceGeom.Count == 1)
                                {
                                    var f = fg.ListeFaceGeom[0];

                                    if (f.Type == eTypeFace.Cylindre)
                                    {
                                        if (RayonMax < f.Rayon)
                                        {
                                            RayonMax = f.Rayon;
                                            Ext      = fg;
                                        }
                                    }
                                    else
                                    {
                                        EstUnCylindre = false;
                                        break;
                                    }
                                }
                            }

                            if (EstUnCylindre)
                            {
                                FaceSectionExt = Ext;
                                ListeFaceSectionInt.Remove(Ext);
                            }
                            else
                            {
                                FaceSectionExt = null;
                            }
                        }

                        {
                            // Methode plus longue pour determiner la face exterieur
                            if (FaceSectionExt == null)
                            {
                                // On créer un vecteur perpendiculaire à l'axe du profil
                                var vect = this.PlanSection.Normale;

                                if (vect.X == 0)
                                {
                                    vect = vect.Vectoriel(new gVecteur(1, 0, 0));
                                }
                                else
                                {
                                    vect = vect.Vectoriel(new gVecteur(0, 0, 1));
                                }

                                vect.Normaliser();

                                // On récupère le point extreme dans cette direction
                                Double X = 0, Y = 0, Z = 0;
                                Corps.GetExtremePoint(vect.X, vect.Y, vect.Z, out X, out Y, out Z);
                                var Pt = new gPoint(X, Y, Z);

                                // La liste de face la plus proche est considérée comme la peau exterieur du profil
                                Double distMin = 1E30;
                                foreach (var Ext in ListeFaceSectionInt)
                                {
                                    foreach (var fg in Ext.ListeFaceGeom)
                                    {
                                        foreach (var f in fg.ListeSwFace)
                                        {
                                            Double[] res         = f.GetClosestPointOn(Pt.X, Pt.Y, Pt.Z);
                                            var      PtOnSurface = new gPoint(res);

                                            var dist = Pt.Distance(PtOnSurface);
                                            if (dist < 1E-6)
                                            {
                                                distMin        = dist;
                                                FaceSectionExt = Ext;
                                                break;
                                            }
                                        }
                                    }
                                    if (FaceSectionExt.IsRef())
                                    {
                                        break;
                                    }
                                }

                                // On supprime la face exterieur de la liste des faces
                                ListeFaceSectionInt.Remove(FaceSectionExt);
                            }
                        }
                    }
                    else
                    {
                        FaceSectionExt = ListeFaceSectionInt[0];
                        ListeFaceSectionInt.RemoveAt(0);
                    }
                }
                catch (Exception e) { this.LogErreur(new Object[] { e }); }
            }