private void GetInfoExtrusion()
{
if (Surface.IsSwept())
{
Double[] Param = Surface.GetExtrusionsurfParams();
Direction = new gVecteur(Param[0], Param[1], Param[2]);
Curve C = Surface.GetProfileCurve();
C = C.GetBaseCurve();
Double StartParam = 0, EndParam = 0;
Boolean IsClosed = false, IsPeriodic = false;
if (C.GetEndParams(out StartParam, out EndParam, out IsClosed, out IsPeriodic))
{
Double[] Eval = C.Evaluate(StartParam);
Origine = new gPoint(Eval[0], Eval[1], Eval[2]);
}
var UV = (Double[])SwFace.GetUVBounds();
Boolean Reverse = SwFace.FaceInSurfaceSense();
var ev1 = (Double[])Surface.Evaluate((UV[0] + UV[1]) * 0.5, (UV[2] + UV[3]) * 0.5, 0, 0);
if (Reverse)
{
ev1[3] = -ev1[3];
ev1[4] = -ev1[4];
ev1[5] = -ev1[5];
}
Normale = new gVecteur(ev1[3], ev1[4], ev1[5]);
}
}
private eOrientation Orientation(gPoint p1, gVecteur v1, gPoint p2, gVecteur v2)
{
if (p1.Distance(p2) < 1E-10)
{
return(eOrientation.MemeOrigine);
}
gVecteur Vtmp = new gVecteur(p1, p2);
if ((v1.Vectoriel(Vtmp).Norme < 1E-10) && (v2.Vectoriel(Vtmp).Norme < 1E-10))
{
return(eOrientation.Colineaire);
}
gVecteur Vn1 = (new gVecteur(p1, p2)).Vectoriel(v1);
gVecteur Vn2 = (new gVecteur(p2, p1)).Vectoriel(v2);
gVecteur Vn = Vn1.Vectoriel(Vn2);
if (Vn.Norme < 1E-10)
{
return(eOrientation.Coplanaire);
}
return(eOrientation.Indefini);
}
private Double AngleCubeDeVisualisation(View vue, Sketch esquisse)
{
MathUtility SwMath = App.Sw.GetMathUtility();
List <gPoint> LstPt = new List <gPoint>();
foreach (SketchPoint s in esquisse.GetSketchPoints2())
{
MathPoint point = SwMath.CreatePoint(new Double[3] {
s.X, s.Y, s.Z
});
MathTransform SketchXform = esquisse.ModelToSketchTransform;
SketchXform = SketchXform.Inverse();
point = point.MultiplyTransform(SketchXform);
MathTransform ViewXform = vue.ModelToViewTransform;
point = point.MultiplyTransform(ViewXform);
gPoint swViewStartPt = new gPoint(point);
LstPt.Add(swViewStartPt);
}
// On recherche le point le point le plus à droite puis le plus haut
LstPt.Sort(new gPointComparer(ListSortDirection.Descending, p => p.X));
LstPt.Sort(new gPointComparer(ListSortDirection.Descending, p => p.Y));
// On le supprime
LstPt.RemoveAt(0);
// On recherche le point le point le plus à gauche puis le plus bas
LstPt.Sort(new gPointComparer(ListSortDirection.Ascending, p => p.X));
LstPt.Sort(new gPointComparer(ListSortDirection.Ascending, p => p.Y));
// C'est le point de rotation
gPoint pt1 = LstPt[0];
// On recherche le plus loin
gPoint pt2;
Double d1 = pt1.Distance(LstPt[1]);
Double d2 = pt1.Distance(LstPt[2]);
if (d1 > d2)
{
pt2 = LstPt[1];
}
// En cas d'égalité, on renvoi le point le plus à gauche
else if (d1 == d2)
{
pt2 = (LstPt[1].X < LstPt[2].X) ? LstPt[1] : LstPt[2];
}
else
{
pt2 = LstPt[2];
}
gVecteur v = new gVecteur(pt1, pt2);
return(Math.Atan2(v.Y, v.X));
}
private void Run(Face2 dessus, Face2 devant, Component2 contreMarche, Feature esquisse)
{
if ((dessus == null) || (devant == null))
{
this.LogMethode(new String[] { "Une reference à un objet a été perdue dessus | devant :", dessus.IsRefToString(), "|", devant.IsRefToString() });
return;
}
try
{
Edge E_Face = dessus.eListeDesArretesCommunes(devant)[0];
List <Edge> ListeArrete = dessus.eListeDesArretesContigues(E_Face);
// On assigne les cotes de façon arbitraire pour eviter une assignation suplémentaire
Edge E_Gauche = ListeArrete[0];
Edge E_Droit = ListeArrete[1];
// Création des segements
gSegment S1 = new gSegment(E_Gauche);
gSegment Sf = new gSegment(E_Face);
// Orientation des segements
S1.OrienterDe(Sf);
Sf.OrienterVers(S1);
gVecteur Normal = new gVecteur((Double[])dessus.Normal);
// Verification du sens de rotation et modification des cotes si nécessaire
if (Sf.Vecteur.RotationTrigo(S1.Vecteur, Normal))
{
E_Gauche = ListeArrete[1];
E_Droit = ListeArrete[0];
}
gSegment F = new gSegment(E_Face);
gSegment G = new gSegment(E_Gauche);
gSegment D = new gSegment(E_Droit);
G.OrienterDe(F);
D.OrienterDe(F);
F.OrienterDe(G);
Double gAg1 = G.Vecteur.Angle(F.Vecteur);
Double gAg2 = D.Vecteur.Angle(F.Vecteur.Inverse());
Double gLg1 = new gPoint(0, 0, 0).Distance(F.Start);
Double gLg2 = new gPoint(0, 0, 0).Distance(F.End);
Double gLc1 = G.Lg;
Double gLc2 = D.Lg;
Configurer(contreMarche, gAg1, gAg2, gLg1, gLg2, gLc1, gLc2, esquisse);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
private TriangleNet.Geometry.Point Echelle(TriangleNet.Geometry.Point centre, TriangleNet.Geometry.Point point, double f)
{
gVecteur v = new gVecteur(point.X - centre.X, point.Y - centre.Y, 0);
v.Multiplier(f);
double x = centre.X + v.X;
double y = centre.Y + v.Y;
return(new TriangleNet.Geometry.Point(x, y));
}
private void GetInfoPlan()
{
Boolean Reverse = SwFace.FaceInSurfaceSense();
if (Surface.IsPlane())
{
Double[] Param = Surface.PlaneParams;
if (Reverse)
{
Param[0] = Param[0] * -1;
Param[1] = Param[1] * -1;
Param[2] = Param[2] * -1;
}
Origine = new gPoint(Param[3], Param[4], Param[5]);
Normale = new gVecteur(Param[0], Param[1], Param[2]);
}
}
private void GetInfoCylindre()
{
if (Surface.IsCylinder())
{
Double[] Param = Surface.CylinderParams;
Origine = new gPoint(Param[0], Param[1], Param[2]);
Direction = new gVecteur(Param[3], Param[4], Param[5]);
Rayon = Param[6];
var UV = (Double[])SwFace.GetUVBounds();
Boolean Reverse = SwFace.FaceInSurfaceSense();
var ev1 = (Double[])Surface.Evaluate((UV[0] + UV[1]) * 0.5, (UV[2] + UV[3]) * 0.5, 0, 0);
if (Reverse)
{
ev1[3] = -ev1[3];
ev1[4] = -ev1[4];
ev1[5] = -ev1[5];
}
Normale = new gVecteur(ev1[3], ev1[4], ev1[5]);
}
}
private void Run(Face2 dessus, Face2 devant, Feature gPlan, Feature dPlan, Component2 pltG, Component2 pltD)
{
if ((dessus == null) || (devant == null))
{
this.LogMethode(new String[] { "Une reference à un objet a été perdue" });
return;
}
try
{
Edge E_Face = dessus.eListeDesArretesCommunes(devant)[0];
List <Edge> ListeArrete = dessus.eListeDesArretesContigues(E_Face);
// On assigne les cotes de façon arbitraire pour eviter une assignation suplémentaire
Edge E_Gauche = ListeArrete[0];
Edge E_Droit = ListeArrete[1];
// Création des segements
gSegment S1 = new gSegment(E_Gauche);
gSegment Sf = new gSegment(E_Face);
// Orientation des segements
S1.OrienterDe(Sf);
Sf.OrienterVers(S1);
gVecteur Normal = new gVecteur((Double[])dessus.Normal);
// Verification du sens de rotation et modification des cotes si nécessaire
if (Sf.Vecteur.RotationTrigo(S1.Vecteur, Normal))
{
E_Gauche = ListeArrete[1];
E_Droit = ListeArrete[0];
}
List <Face2> L = null;
L = E_Gauche.eDeuxFacesAdjacentes();
L.Remove(dessus);
Face2 FaceGauche = L[0];
L = E_Droit.eDeuxFacesAdjacentes();
L.Remove(dessus);
Face2 FaceDroite = L[0];
if (pltG.IsRef())
{
if (pltG.GetConstrainedStatus() == (int)swConstrainedStatus_e.swUnderConstrained)
{
Contraindre(gPlan, FaceGauche);
}
}
if (pltD.IsRef())
{
if (pltD.GetConstrainedStatus() == (int)swConstrainedStatus_e.swUnderConstrained)
{
Contraindre(dPlan, FaceDroite);
}
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
public Boolean Decompter(Component2 cp)
{
try
{
if (!cp.IsHidden(true))
{
foreach (var corps in cp.eListeCorps())
{
foreach (var face in corps.eListeDesFaces())
{
Surface S = face.GetSurface();
if (S.IsRef() && S.IsCylinder() && (face.GetLoopCount() > 1))
{
// On regarde si c'est un trou ou un cylindre
Double[] ListeParam = (Double[])S.CylinderParams;
gPoint Centre = new gPoint(ListeParam[0], ListeParam[1], ListeParam[2]);
gVecteur Axe = new gVecteur(ListeParam[3], ListeParam[4], ListeParam[5]);
Double Diam = Math.Round(ListeParam[6] * 2.0 * 1000, 2);
Double[] FaceUV = face.GetUVBounds();
Double[] Eval = S.Evaluate(FaceUV[0], FaceUV[2], 0, 0);
// Point de départ de la normale
gPoint PointNormale = new gPoint(Eval[0], Eval[1], Eval[2]);
gVecteur Normale = new gVecteur(Eval[3], Eval[4], Eval[5]);
if (face.FaceInSurfaceSense())
{
Normale.Inverser();
}
gVecteur Vtest = new gVecteur(PointNormale, Centre);
// Si l'angle est inférieur à 90°, la normale va vers le centre
// donc c'est un trou
if (Normale.Angle(Vtest) < D90)
{
var dicDiam = new Dictionary <Component2, List <Face2> >();
if (Dic.ContainsKey(Diam))
{
dicDiam = Dic[Diam];
}
else
{
Dic.Add(Diam, dicDiam);
}
var listFace = new List <Face2>();
if (dicDiam.ContainsKey(cp))
{
listFace = dicDiam[cp];
}
else
{
dicDiam.Add(cp, listFace);
}
listFace.Add(face);
}
}
}
}
}
}
catch (Exception e) { this.LogMethode(new Object[] { e }); }
return(false);
}
