(gile)

@Fraid Il me semble que les points (6.6 11.2) et (8.0 0.9) devraient être dans le denier groupe...

Super ! Ça joue. @Luna Super, ça fonctionne, il y a peut-être moyen d'optimiser, de rendre plus générique, de grouper par X et Y... mais ne te presse pas trop de donner des réponses pour ne pas décourager les autres. @Fraid Ça semble un bon début, mais il manque des points dans la liste renvoyée. À tous, il y a encore plein de réponses possible, en cherchant l'optimisation, la concision, la lisibilité, la généricité, ...

quel rendu ? quel txt ? On a une collection de points (en VBA j'imagine que c'est un tableau de variants de type tableau de 2 ou 3 Doubles). On passe ce tableau à une fonction (Function en VBA) qui groupe les points par coordonnée X à 10 unités près et retourne les groupes dans le type de collection que tu veux (en VBA, j'imagine un tableau déchiqueté -un tableau de tableaux de points, à moins qu'il esxiste des structures de données plus adaptées).

Si tu groupes (2.4 -4.9) avec (-6.6 4.7), ce qui est envisageable, tu décales les groupes et (4.8 0.7) ne pourra plus être dans le même groupe que (2.4 4.9). Tout dépend de l'algorithme de groupage...

Salut, Un nouveau challenge (tout langage accepté). L'objectif est de définir une fonction pour grouper les points (coordonnées) d'une liste en fonction de leur coordonnée X avec une tolérance de 10 unités. La fonction devra prendre comme argument une liste de points 2d (x y) ou 3d (x y z) et renvoyer les points groupés sous la forme que permet le langage utilisé (en LISP ce sera forcément une liste de sous-listes, avec d'autre langages, ça peut-être une autre structure de données : un tableau déchiqueté, un dictionnaire, ...). Exemple, avec la liste suivante en entrée : (setq pts '((14.4 4.7) (4.8 0.7) (8.0 0.9) (9.3 4.7) (-14.3 14.3) (-6.3 14.2) (-13.6 7.5) (-1.9 -3.2) (2.4 -4.9) (6.6 11.2) (-6.6 4.7) ) ) on devrait obtenir 3 groupes : ((-6.6 4.7) (-13.6 7.5) (-6.3 14.2) (-14.3 14.3)) ((2.4 -4.9) (-1.9 -3.2) (4.8 0.7)) ((6.6 11.2) (9.3 4.7) (8.0 0.9) (14.4 4.7)) On pourra ensuite pousser un peu plus loin pour rendre la fonction plus générique en passant la tolérance en argument, puis en groupant par X et Y.

Ça m'est venu à l'esprit quand j'ai revu ce code que j'avais écris il y a quelques années et je me souviens avoir eu quelques difficultés à comprendre ces "paramètres" puis quelques satisfactions quand j'ai réussi à démêler l'histoire. Je voulais juste essayer de faire partager ça à d'autres et puis je trouve intéressant d'approfondir nos connaissance de l'ellipse qui, si elle est la courbe la plus simple après ce cercle, n'en reste pas moins pleine de secrets pour moi. Sinon, d'un point de vue général, l'intérêt de ces challenges (au départ venus de TheSwamp et qu'on pratiquait assidument il y a quelques années avec feu Patrick_35, ElpanovEvengiy, ...) sont surtout un moyen de faire travailler nos méninges pour confronter différents algorithmes, différentes façon de coder sans forcément avoir un intérêt pratique ou professionnel. Par exemple celui-ci qui consistait à implémenter différents algorithmes de tri est d'un intérêt pratique tout relatif puisque AutoLISP fournit vl-sort, mais a toutefois généré un vrai engouement.

Dans la liste pour entmake : 10 . centre de l'ellipse 11 . vecteur du centre à l'extrémité du grand axe (c'est lui qui sert de base à la mesure des angles) 40 . ratio (dans l'intervalle ]0-1] 41 . paramètre de départ (angle mesuré depuis le vecteur (11) en sens anti-horaire) 41 . paramètre de fin (angle mesuré depuis le vecteur (11) en sens anti-horaire)

Bravo ! La fonction inverse avec des simplifications. On peut encore simplifier un petit peu le ratio entre le petit et le grand axe est une propriété de l'ellipse stockée avec le code DXF 40 dans la liste de données DXF ou qui s'appelle RadiusRatio dans les environnements COM et NET. J'avais essayé de donner une piste dans le premier message avec l'image qui montre les tangentes de l'angle et du paramètre dont le ratio est le même que celui de l'ellipse. On peut donc faire, en passant le ename de l'ellipse en argument : (defun paramToAngle (el p) (atan (* (cdr (assoc 40 (entget el))) (sin p)) (cos p)) ) (defun angleToParam (el a) (atan (sin a) (* (cdr (assoc 40 (entget el))) (cos a))) ) ou, depuis AutoCAD 2012 : (defun paramToAngle (el p) (atan (* (getpropertyvalue el "RadiusRatio") (sin p)) (cos p)) ) (defun angleToParam (el a) (atan (sin a) (* (getpropertyvalue el "RadiusRatio") (cos a))) ) ou, en passant le vla-object : (defun paramToAngle (el p) (atan (* (vla-get-RadiusRatio el) (sin p)) (cos p)) ) (defun angleToParam (el a) (atan (sin a) (* (vla-get-RadiusRatio el) (cos a))) )

Personnellement je préfère lire des caractères foncés sur fond clair (noir sur blanc), et plusieurs études semblent montrer que c'est le cas pour la majorité des gens (on parle bien de lecture). La mode des caractères clairs sur fond sombre vient des programmeurs (nostalgie de la console ?). J'ai essayé les thèmes sombres sur les logiciels que j'utilise le plus comme Visual Studio, ou Notepad++ et qui proposent ces thèmes sombre depuis longtemps (toujours ?). Je n'ai jamais ressenti de différence au niveau de la fatigue oculaire avec ces thèmes, par contre je n'en ai trouvé aucun qui ne ressemble pas à un feu d'artifice avec la coloration syntaxique, et ça, ça ne facilite pas toujours la lecture du code. Un fond sombre se justifie certainement quand on est dans l'obscurité, mais je ne vais pas fermer les volets pour venir sur CADxp. Donc, si chacun peut choisir le thème, c'est parfait ; sinon, je préfèrerais que ça reste clair.

Moi, ce qui me fait le plus mal aux yeux, c'est l'abondance de fautes d'orthographe...

Je viens de comprendre. Honte sur moi, c'est une coquille, il fallait lire : "une ellipse de 100 unités de grand axe pour 60 unités de petit axe". C'est corrigé. Ça ne t'a pas empêché de donner la bonne réponse, encore bravo. @Fraid Non ça ne fonctionne pas. Ne t'embêtes pas avec la façon dont a été sélectionnée l'ellipse ou des angles en degrés. Ce type de fonction est destinée à des développeurs et peut prendre comme argument directement un ename ou un vla-object (en LISP) et un angle en radians.

Bravo @Olivier Eckmann ! Le code fonctionne. Il pourrait juste être simplifié. Reste la fonction inverse (mais maintenant, c'est plus facile). Oui, il faut que le grand axe soit plus grand que le petit (autrement dit, que le ratio petit rayon / grand rayon soit inférieur ou égal à 1) pour que cette fonction paramétrique qui sert à calculer l'ellipse puisse fonctionner. Avec la commande ELLIPSE, si on donne une seconde valeur plus grande que la première, c'est la seconde qui est prise comme grand axe.

Dans l'équation paramètrique telle que donnée dans l'aide d'AutoCAD : p(param) = c + a * cos(param) + b * sin(param) p est le point de l'ellipse correspondant au "paramètre" param c est le centre de l'ellipse a est le vecteur de c à l'extrémité du grand axe b est le vecteur de c à l'extrémité du petit axe L'angle au point p est l'angle entre le vecteur a et le vecteur cp.

c est le centre de l'ellipse. On peut voir aussi le paragraphe Image d'un cercle par une affinité sur la page Ellipse (Mathématique de wikipédia). Dans la dernière phrase du chapitre le terme "anomalie excentrique" correspond au "paramètre" de l'ellipse.

Le rapport entre "angle" et "paramètre" est lié aux données de l'ellipse, notamment les grand et petit rayons ou le ratio entre ces rayons (RadiusRatio ou groupe DXF 40), c'est pour ça que la forme est bien : (AngleToParam ellipse angle) et (ParamToAngle ellipse param). Pour tout point p d'une ellipse de centre c, de grand rayon a et de petit rayon b : - on appelle "angle" l'angle entre le grand axe et le segment de c à p - on appelle "paramètre" la valeur angulaire qui permet de définir les coordonnées du point p à l'aide de l'équation vectorielle paramétrique suivante p(param) = c + a * cos(param) + b * sin(param) autrement dit : p est égal à c plus le vecteur de coordonnées X = a * cos(param), Y = b * sin(param)

@Fraid Ça ne serait pas un challenge. Il ne s'agit pas forcément des paramètres ou angle de départ ou de fin, mais de convertir en angle n'importe quel paramètre de l'ellipse ou inversement.

Ou encore, en partant d'un problème pratique. Je veux créer un arc elliptique entre 30° (pi/6rd) et 300° (10*pi/6rd) et je veux le faire avec entmake. Or la liste de données DXF à passer à entmake utilise les paramètres de l'ellipse (codes de groupe 41 et 42). J'ai donc besoin d'une fonction (angleToParam) pour convertir ces angles en paramètres. C'est cette fonction qu'il s'agit de définir. Inversement, je veux connaitre les angles de départ et de fin d'un arc elliptique d'après ses données DXF (obtenues avec entget) qui contiennent, entre autres, les paramètres (groupes 41 et 42). J'ai donc besoin d'une fonction (paramToAngle) pour convertir ces paramètres en angles. C'est cette fonction qu'il s'agit de définir. Il s'agit avant tout d'un problème de géométrie qu'on implémente ensuite dans un langage de programmation.

Non, l'idée de ces challenges est plutôt de juste fournir une fonction qui fait seulement les calculs pour répondre au problème posé. Ici, en LISP par exemple, ça serait une fonction 'paramToAngle' qui prend en arguments le ename (ou vla-object) d'un ellipse et un nombre représentant le paramètre de l'ellipse pour lequel on cherche l'angle et qui renvoie l'angle correspondant à ce paramètre : (defun paramToAngle (ellipse, param) ...) Pour tester, outre les exemples que j'ai donné, on peut utiliser la fonction dans une commande de test : (defun c:test (/ ellipse startParam endParam startAngle endAngle) (setq ellipse (car (entsel "\nSélectionnez un arc elliptique: "))) (setq dxf (entget ellipse)) (setq startParam (cdr (assoc 41 dxf))) ; paramètre de départ (setq startAngle (paramToAngle ellipse startParam)) ; appel de la fonction paramToAngle (setq endParam (cdr (assoc 42 dxf))) ; paramètre de fin (setq endAngle (paramToAngle ellipse endParam)) ; appel de la fonction paramToAngle (prompt (strcat "\nAngle de départ : " (angtos startAngle) "\tAngle de fin : " (angtos endAngle) ) ) (princ) ) Idem pour la fonction inverse : angleToParam.

Salut, Je vais essayer de lancer un petit challenge de géométrie. Dans AutoCAD, pour dessiner un arc elliptique, on peut spécifier les angles de départ et de fin, mais il existe aussi une option 'Paramètres'. Extrait de l'aide : En programmation d'AutoCAD, on retrouve cette notion de paramètre pour tous les objets curviligne (vlax-curve-getParamAtPoint en LISP ou Curve.GetParamAtPoint avec.NET). On a coutume de dire qu'un petit dessin vaut mieux qu'un long discours : Le challenge, donc, serait de définir deux fonctions (peu importe le langage) : - AngleToParam : qui prend comme arguments une ellipse et un angle et qui renvoie le paramètre correspondant - ParamToAngle : qui prend comme arguments une ellipse et un paramètre et qui renvoie l'angle correspondant Exemples avec une ellipse de 10 100 unités de grand axe pour 60 unités de petit axe : - AngleToParam d'un angle de 30° doit retourner un paramètre de 43.90° - ParamToAngle d'un paramètre de 30° doit retourner un angle de 19.11° - AngleToParam d'un angle de 230° doit retourner un paramètre de 243.28° - ParamToAngle d'un paramètre de 230° doit retourner un angle de 215.57° Les exemples sont donnés en degrés, mais pour plus de simplicité et de cohérence avec les fonction natives fonctions utiliseront les radians.

Salut, Si tu as une version pleine, tu trouveras sur cette page un un fichier LISP nommé Special_Selections.lsp dans lequel sont définies plusieurs commandes de sélections filtrées dont SSD qui permet de filtrer en fonction des propriétés dynamiques du premier bloc sélectionné.

La routine LISP ne gère pas le style ou la hauteur de texte, elle utilise les paramètres courant des textes (TEXTSTYLE, TEXTSIZE).

Salut, Tu peux essayer ce LISP (commande : REMPLCALQUE). ;;; GetLayer (gile) 03/11/07 ;;; Retourne le nom du calque entré ou choisi par l'utilisateur ;;; dans une liste déroulante de la boite de dialogue ou en sélectionnant ;;; un objet à l'écran. ;;; Argument : le titre (string) ou nil (défaut : "Choisir un calque") (defun getlayer (titre / lay lst tmp file what_next dcl_id nom) (while (setq lay (tblnext "LAYER" (not lay))) (setq lst (cons (cdr (assoc 2 lay)) lst)) ) (setq lst (acad_strlsort lst) tmp (vl-filename-mktemp "Tmp.dcl") file (open tmp "w") ) (write-line (strcat "getlayer:dialog{label=" (cond (titre (vl-prin1-to-string titre)) ("\"Choisir un calque\"") ) ";initial_focus=\"tp\"; :boxed_column{:row{ :column{:text{label=\"Sélectionner un objet\";alignment=left;}} :column{:button{label=\">>\";key=\"obj\";alignment=right;fixed_width=true;} spacer;}} :edit_box{key=\"tp\";edit_width=25;allow_accept=true;} :popup_list{key=\"lay\";edit_width=25;} spacer;}ok_cancel;}" ) file ) (close file) (setq dcl_id (load_dialog tmp)) (setq what_next 2) (while (>= what_next 2) (if (not (new_dialog "getlayer" dcl_id)) (exit) ) (start_list "lay") (mapcar 'add_list lst) (end_list) (or nom (setq nom (vlax-ldata-get "getLayer" "n")) (setq nom (vlax-ldata-put "getLayer" "n" "0")) ) (if (member nom lst) (set_tile "lay" (itoa (- (length lst) (length (member nom lst)))) ) (set_tile "lay" "0") ) (set_tile "tp" nom) (action_tile "obj" "(done_dialog 3)") (action_tile "tp" "(setq nom $value)") (action_tile "lay" (strcat "(if (or (= $reason 1) (= $reason 4))" "(progn" "(setq nom (nth (atoi $value) lst))" "(set_tile \"tp\" (nth (atoi $value) lst))" "(mode_tile \"tp\" 2)))" ) ) (action_tile "accept" (strcat "(if (tblsearch \"LAYER\" nom)" "(progn (done_dialog 1)" "(vlax-ldata-put \"getLayer\" \"n\" nom))" "(progn" "(alert (strcat \"Le calque \" nom \" est introuvable.\"))" "(setq nom nil) (set_tile \"tp\" (vlax-ldata-get \"getLayer\" \"n\"))" "(mode_tile \"tp\" 2)))" ) ) (setq what_next (start_dialog)) (cond ((= what_next 3) (if (setq nom (car (entsel))) (setq nom (cdr (assoc 8 (entget nom)))) (setq nom nil) ) ) ((= what_next 0) (setq nom nil) ) ) ) (unload_dialog dcl_id) (vl-file-delete tmp) nom ) (vl-load-com) (or *acad* (setq *acad* (vlax-get-acad-object))) (or *acdoc* (setq *acdoc* (vla-get-ActiveDocument *acad*))) (or *blocks* (setq *blocks* (vla-get-Blocks *acdoc*))) ;; REMPLCALQUE ;; Remplace l'ancien calque par le nouveau pour tous les objets du dessin. (defun c:REMPLCALQUE (/ *error* old new) (defun *error* (msg) (and msg (/= msg "Fonction annulée") (prompt (strcat "\nErreur: " msg)) ) (vla-EndUndoMark *acdoc*) (princ) ) (if (and (setq old (getLayer "Ancien calque")) (setq new (getLayer "Nouveau calque")) (/= old new) ) (progn (vla-StartUndoMark *acdoc*) (vlax-for b *blocks* (vlax-for o b (if (= (vla-get-Layer o) old) (vla-put-layer o new) ) ) ) (vla-regen *acdoc* acActiveViewport) (*error* nil) ) ) )

Je ne suis pas sûr du tout que le code ci-dessus corresponde à ce que tu cherches à faire parce que l'extrait de code que tu as posté n'est pas compréhensible. Tu crée une liste de chaîne en lisant le fichier : LstCalqLine du type : ("Murs" "7" "Continu" "035" "O" "Murs perimetriques et de refends"). Puis tu n'utilises plus jamais LstCalqLine mais d'autres variables dont on ne sait rien : PosLst et LstCalq. Par ailleurs, chaque ligne n'a pas le même nombre de champ, certaines ont un "O" entre l'épaisseur de ligne et la description d'autre n'ont rien. Globalement, il manque à tout ça un ingrédient indispensable à toute tentative de programmation : la rigueur.

Encore une fois, NON, .NET n'est pas plus abordable, bien au contraire et ne supporte certainement pas la "bidouille".

Je n'ai jamais dit qu'on n'y arrivait pas. J'ai juste dit que ce n'était pas possible avec une macro-commande. (vl-load-com) (or *acad* (setq *acad* (vlax-get-acad-object))) (or *acdoc* (setq *acdoc* (vla-get-ActiveDocument *acad*))) (or *util* (setq *util* (vla-get-Utility *acdoc*))) (defun c:areafield (/ obj pt) (if (and (setq obj (car (entsel))) (setq obj (vlax-ename->vla-object obj)) (vlax-property-available-p obj 'area) (setq pt (getpoint "\nPoint d'insertion: ")) ) (vla-addText (if (= (getvar 'cvport) 1) (vla-get-PaperSpace *acdoc*) (vla-get-ModelSpace *acdoc*) ) (strcat "%<\\AcObjProp.16.2 Object(%<\\_ObjId " (vla-GetObjectIdString *util* obj :vlax-false) ">%).Area \\f \"%lu2%zs8%ct8[0.0001]\">%" ) (vlax-3d-point (trans pt 1 0)) (getvar 'textsize) ) ) (princ) )