Une question sur les polylignes

[coyotte]

Bonjour à tous,

 

je vous expose mon soucis.

 

Pour mon boulot j'ai récupéré un grand nombre synoptiques. Tous ces plans sont réalisés en polylignes pour ce qui est de tous les réseaux (Il s'agit de plans de clim et de plomberie).

 

On me demande de réaliser toutes les coupures sur les réseaux qui se croisent. Je vous laissent imaginer la quantité de coupures que cela représente.

 

J'aurais voulu savoir si en .NET il était possible de sélectionner deux polylignes composées de plusoeurs segments et à partir de leur intersection couper l'une des deux d'une distance équivalente de chaque coté.

 

Merci d'avance de vos réponses.

[(gile)]

Salut,

 

Un truc dans ce genre ?

 

        [CommandMethod("brk")]
       public void Break()
       {
           Document doc = AcAp.DocumentManager.MdiActiveDocument;
           Database db = doc.Database;
           Editor ed = doc.Editor;

           // saisie de la première polyligne
           PromptEntityOptions peo = new PromptEntityOptions("\nSélectionnez la première polyligne: ");
           peo.SetRejectMessage("Object non valide.");
           peo.AddAllowedClass(typeof(Polyline), true);
           PromptEntityResult per = ed.GetEntity(peo);
           if (per.Status != PromptStatus.OK) return;
           ObjectId plId1 = per.ObjectId;

           // saisie de la seconde polyligne
           peo.Message = "\nSélectionnez la seconde polyligne: ";
           per = ed.GetEntity(peo);
           if (per.Status != PromptStatus.OK) return;
           ObjectId plId2 = per.ObjectId;

           // saisie de la distance de coupure
           PromptDistanceOptions pdo = new PromptDistanceOptions("\nDistance de coupure: ");
           pdo.AllowNegative = false;
           pdo.AllowZero = false;
           PromptDoubleResult pdr = ed.GetDistance(pdo);
           if (pdr.Status != PromptStatus.OK)
               return;
           double dist = pdr.Value;

           using (Transaction tr = db.TransactionManager.StartTransaction())
           {
               BlockTableRecord btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);
               Polyline pl1 = (Polyline)tr.GetObject(plId1, OpenMode.ForWrite);
               Polyline pl2 = (Polyline)tr.GetObject(plId2, OpenMode.ForRead);
               Point3dCollection pts = new Point3dCollection();
               pl1.IntersectWith(pl2, Intersect.OnBothOperands, pts, 0, 0);
               if (pts.Count == 0)
                   return;
               foreach (Point3d pt in pts)
               {
                   Polyline[] plines = null;
                   if (pl1.GetDistAtPoint(pt) > dist)
                   {
                       Point3d p1 = pl1.GetPointAtDist(pl1.GetDistAtPoint(pt) - dist);
                       plines = BreakAtPoint(pl1, p1);
                       btr.AppendEntity(plines[0]);
                       tr.AddNewlyCreatedDBObject(plines[0], true);
                       pl1.Erase();
                       pl1 = plines[1];
                   }
                   if (pl1.GetDistanceAtParameter(pl1.EndParam) > pl1.GetDistAtPoint(pt) + dist)
                   {
                       plines = BreakAtPoint(pl1, pl1.GetPointAtDist(pl1.GetDistAtPoint(pt) + dist));
                       btr.AppendEntity(plines[1]);
                       tr.AddNewlyCreatedDBObject(plines[1], true);
                       pl1 = plines[1];
                       plines[0].Dispose();
                   }
                   else
                   {
                       pl1.Dispose();
                   }
               }
               tr.Commit();
           }
       }

       public Polyline[] BreakAtPoint(Polyline pline, Point3d brkPt)
       {
           brkPt = pline.GetClosestPointTo(brkPt, false);

           // le point spécifié est sur le point de départ de la polyligne
           if (brkPt.IsEqualTo(pline.StartPoint))
               return new Polyline[2] { null, (Polyline)pline.Clone() };

           // le point spécifié est sur le point de fin de la polyligne
           if (brkPt.IsEqualTo(pline.EndPoint))
               return new Polyline[2] { (Polyline)pline.Clone(), null };

           double param = pline.GetParameterAtPoint(brkPt);
           int index = (int)param;
           int num = pline.NumberOfVertices;
           Polyline pl1 = (Polyline)pline.Clone();
           if (pline.Closed)
           {
               pl1.AddVertexAt(
                   pline.NumberOfVertices,
                   pline.GetPoint2dAt(0),
                   pline.GetStartWidthAt(num - 1),
                   pline.GetEndWidthAt(num - 1),
                   pline.GetBulgeAt(num - 1));
               pl1.Closed = false;
           }
           Polyline pl2 = (Polyline)pl1.Clone();

           // le point spécifié est sur un sommet de la polyligne
           if (Math.Round(param, 6) == index)
           {
               for (int i = pl1.NumberOfVertices - 1; i > index; i--)
               {
                   pl1.RemoveVertexAt(i);
               }
               for (int i = 0; i < index; i++)
               {
                   pl2.RemoveVertexAt(0);
               }
               return new Polyline[2] { pl1, pl2 };
           }

           // le point spécifié est sur un segment
           Point2d pt = brkPt.Convert2d(new Plane(Point3d.Origin, pline.Normal));
           for (int i = pl1.NumberOfVertices - 1; i > index + 1; i--)
           {
               pl1.RemoveVertexAt(i);
           }
           pl1.SetPointAt(index + 1, pt);
           for (int i = 0; i < index; i++)
           {
               pl2.RemoveVertexAt(0);
           }
           pl2.SetPointAt(0, pt);
           if (pline.GetBulgeAt(index) != 0.0)
           {
               double bulge = pline.GetBulgeAt(index);
               pl1.SetBulgeAt(index, MultiplyBulge(bulge, param - index));
               pl2.SetBulgeAt(0, MultiplyBulge(bulge, index + 1 - param));
           }
           return new Polyline[2] { pl1, pl2 };
       }

       public double MultiplyBulge(double bulge, double factor)
       {
           return Math.Tan(Math.Atan(bulge) * factor);
       }

[coyotte]

Merci Gile,

 

tu viens de me sauver d'un boulot de fou.

 

La routine fonctionne à la perfection.

[lecrabe]

Hello Gilles et Coyotte

 

SVP serait il possible de disposer de cette routine sous forme d'une DLL a chager avec NETLOAD

et a lancer sans doute avec la commande clavier : BRK

 

J'aimerais bien "jouer" avec ...

 

Merci d'avance, le crabe

[(gile)]

Voilà, BreakAtIntersection.zip contient 2 DLLs : BreakAtIntersection_18.dll pour les versions 2010-2012 et BreakAtIntersection_19 pour 2013.

[Patrick_35]

Voilà, BreakAtIntersection.zip contient 2 DLLs : BreakAtIntersection_18.dll pour les versions 2010-2012 et BreakAtIntersection_19 pour 2013.

Salut (gile)

 

Je croyais que les dll étaient compatibles pour toutes les versions ?

 

@+

[(gile)]

C'était (presque) vrai jusqu'à la version 2013.

Avec la version 2013, acad.exe a été séparé en deux fichers : acad.exe et accore.dll ce qui a pour effet de rompre (pour la première fois) la compatibilité binaire pour les applications .NET.

Pour plus de détails, voir l'article de Serge Camiré.

[lecrabe]

Hello

 

Deja qu'en C++ et ARX, on devait avoir de multiples versions : 32 et 64 bits normal

mais en plus avec MAP 2010 et MAP 2011 par exemple, les ARX sont eux meme differents

Donc 4 versions de developpement ARX pour MAP 2010 et 2011

 

et ca continue doucement avec 2012 et 2013 !!!

 

 

Donc on esperait que avec le DOTNET en ciblant un niveau donne : v2 (depuis la 2007) ou v3 (depuis la 2009 je crois !?) ou v4 (depuis la 2013) ou etc

on pouvait etre plus ou moins tranquille, eh bien NON !

 

OUI c chiant !!

 

lecrabe

[(gile)]

La compatibilité reste quand même meilleure avec .NET (si on n'utilise pas les bibliothèques COM) qu'avec ObjectARX/C++.

À de très rares exceptions (quelques APIs ont changé en 2010), les routines écrites pour A2007 fonctionnent pour toutes les versions jusqu'à 2012 et quelle que soit la plateforme cible (32 ou 64 bits).

Le "big split" de la version 2013 est une modification majeure dans le noyau d'AutoCAD, on peut espérer que ce type de changement ne se produira pas trop souvent.

[Patrick_35]

C'était (presque) vrai jusqu'à la version 2013.

Avec la version 2013, acad.exe a été séparé en deux fichers : acad.exe et accore.dll ce qui a pour effet de rompre (pour la première fois) la compatibilité binaire pour les applications .NET.

Pour plus de détails, voir l'article de Serge Camiré.

Mouais, et moi qui commençais à me tâter pour goûter au .Net, ma motivation vient de descendre d'un seul coup de plusieurs étages.

De plus, d'après l'article de serge, le lisp risque d'être concerné dans un futur proche.

Du boulot en perspective ;)

 

Merci (gile)

 

@+

[(gile)]

Mouais, et moi qui commençais à me tâter pour goûter au .Net, ma motivation vient de descendre d'un seul coup de plusieurs étages.

 

Il ne faut pas se décourager pour si peu, ce n'est rien à côté de ce qui t'attends si tu te lances dans .NET. ;)

 

Sérieusement, j'ai été aussi passablement désappointé en apprenant ça.

Mais somme toute, la migration ne demande, dans la plupart des cas que de modifier les bibliothèques référencées et cibler le Framework 4.0 (si ce n'était déjà le cas).

Il est même assez facile de partager les mêmes fichiers source pour deux projets référençant des bibliothèques différentes.

Tout dépend donc de la quantité de projets à migrer en fonction de leur destination, j'en ai bien publié quelques uns sur ce site (et ailleurs) mais je ne suis pas sûr qu'ils soient beaucoup utilisés, j'attendrais donc qu'on m'en fasse la demande pour migrer ces projets.

 

En ce qui te concerne et au vu de ton bagage en programmation, tu devrais assez assez vite te débrouiller avec Visual Studio et .NET. Je te conseillerais de faire ton apprentissage avec le SDK de la version d'AutoCAD que tu utilises (ou une version antérieure) et de ne te préoccuper de migration qu'au moment où tu passera sur 2013 (ou plus).

 

Je précise que ce problème de compatibilité ne concerne que les applications .NET pour AutoCAD. Windows semble plus respectueux de la "philosophie" concernant la compatibilité de .NET qui évolue en ajoutant des fonctionnalités à chaque nouvelle version de Framework sans altérer le fonctionnement de celles existant précédemment.

[Patrick_35]

Il ne faut pas se décourager pour si peu, ce n'est rien à côté de ce qui t'attends si tu te lances dans .NET. ;)

Merci pour les encouragements :(rires forts):

Plus sérieusement, avec quels outils gratuits conseil-tu pour commencer ?

[(gile)]

Plus sérieusement, avec quels outils gratuits conseil-tu pour commencer ?

 

Voir ce sujet et celui-là.