(gile)

Bonne année à tout le monde.

Une autre solution serait de mettre systématique une espace avant une parenthèse fermante (ce qui est une faute en typographie ).

Salut, Quand tu postes de code, utilise la balise 'Code' (<>) ça évite ce genre de déboires (CF ici)

(test 😎) (test 8)

Avec la suggestion de @Luna : *LOSANGE,Ligne-losanges ----<>----<>----<>---- A,25.4,-3.5921,[BOX,ltypeshp.shx,x=-1.796,y=-1.796,s=2.54,r=45],-3.5921

Il faut toujours essayer/tester... Le type AcDbAttributeReference dérive (on dit aussi hérite) du type AcDbText donc toutes les propriétés des objets texte se retrouvent dans les objets attributs.

Non, la question n'est pas que ce soit mon truc ou pas. La question c'est que AutoLISP est en grande partie basé sur le DXF et que c'est le moyen le plus facile d'accéder aux données DXF des objets AutoCAD (le seul autre à ma connaissance, c'est ObjectARX C++ et là, c'est loin d'être facile).

Bravo !

Attention à ce que tu lis, je n'ai jamais parlé de fichier .lin. Les types de ligne dit "complexes" sont ceux qui utilisent des chaînes de caractère ou des formes. Les chaînes de caractères comme les formes utilisent des styles de texte. Le groupe (ou les groupes) 340 pointe vers le style de texte utilisé. Ce style de texte est celui du style utilisé par les éléments de type chaîne de caractères (STANDARD) il contient le nom du fichier des polices où sont définies les formes (ltypeshp.shx). Encore une fois, c'est en LISP qu'il est le plus facile d'accéder à ces informations. (entget (cdr (assoc 340 (entget (tblobjname "LTYPE" "EAU_CHAUDE"))))) (entget (cdr (assoc 340 (entget (tblobjname "LTYPE" "RAILS"))))) Tout ça est décrit en détail dans le manuel d'utilisation DXF > section TABLES > LTYPE et STYLE.

Essaye comme ça: (command "_ucs" "_world" "_-pointcloudattach" "C:\\monnuage.rcs" "_non" '(0 0 0) 1 0 "_ucs" "_previous")

Si le type de ligne complexe existe dans la table des types de ligne du dessin, alors le style de texte qu'il utilise est forcément aussi présent dans la table des styles de texte. Peut importe que le dessin soit vierge ou non, il s'agit là d'objets non graphiques.

Et avec cette expression il est en 0,0,0 du SCG ?

peux tu être plus explicite. Tu parles du point d'insertion et/ou de la rotation ?

Pour les types de ligne simples, le groupe 72 donne le code ASCII de l'alignement a priori toujours 65 pour : A les groupes 49 successifs donnent les longueurs de tiret de point (0) ou d'espace (négatifs) Pour les types de ligne complexes, en plus des éléments ci-dessus, le groupe 74 indique le type d'élément (forme ou texte) le groupe 340 est un pointeur vers le style de texte le groupe 46 indique l'echelle le groupe 50 indique la rotation le groupe 44 indique le décalage en X le groupe 45 indique le décalage en Y le groupe 9 la chaîne de caractère (si 74 contient le code binaire 2) De plus, les types de ligne complexes peuvent avoir des éléments imbriqués. Pour décortiquer les listes DXF, le plus simple reste le LISP (désolé...). en faisant : (entget (tblobjname "LTYPE" "AXES")) tu obtiens la liste DXF du type de ligne AXES sous forme de liste de paires pointées et tu peux la décortiquer en la comparant à la définition du type de ligne. ;; *AXES,Centre ____ _ ____ _ ____ _ ____ _ ____ _ ____ ;; A, 31.75, -6.35, 6.35, -6.35 (2 . "AXES") (70 . 0) (3 . "Centre ____ _ ____ _ ____ _ ____ _ ____ _ ____") (72 . 65) ; A (73 . 4) (40 . 50.8) (49 . 31.75) ; 31.75 (74 . 0) (49 . -6.35) ; -6.35 (74 . 0) (49 . 6.35) ; 6.35 (74 . 0) (49 . -6.35) ; -6.35 (74 . 0) idem pour RAILS : (entget (tblobjname "LTYPE" "RAILS")) ;; *RAILS,Rails -|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|- ;; A,3.81,[TRACK1,ltypeshp.shx,s=6.35],3.81 (2 . "RAILS") (70 . 0) (3 . "Rails -|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-") (72 . 65) ; A (73 . 2) (40 . 7.62) (49 . 3.81) ; 3.81 (74 . 4) ; indique une forme (75 . 130) (340 . <Nom d 'entité: 1b50829a820>) ; pointeur vers le style de texte (ltypeshp.shx) (46 . 6.35) ; s=6.35 (50 . 0.0) (44 . 0.0) (45 . 0.0) (49 . 3.81) ; 3.81 (74 . 0) ou EAU_CHAUDE : (entget (tblobjname "LTYPE" "EAU_CHAUDE")) ;; *EAU_CHAUDE,Eau chaude ---- HW ---- HW ---- HW ---- ;; A,12.7,-5.08,["HW",STANDARD,S=2.54,U=0.0,X=-2.54,Y=-1.27],-5.08 (2 . "EAU_CHAUDE") (70 . 0) (3 . "Eau chaude ---- HW ---- HW ---- HW ----") (72 . 65) ; A (73 . 3) (40 . 22.86) (49 . 12.7) ; 12.7 (74 . 0) (49 . -5.08) ; -5.08 (74 . 10) ; indique une chaîne de caractères (75 . 0) (340 . <Nom d 'entité: 1b508297910>) ; pointeur ver le style de texte (STANDARD) (46 . 2.54) ; S=2.54 (50 . 0.0) ; U=0.0 (44 . -2.54) ; X=-2.54 (45 . -1.27) ; Y=-1.27 (9 . "HW") ; "HW" (49 . -5.08) ; -5.08 (74 . 0)

Essaye comme ça, en remplaçant : "C:\\Nuages\\Nuage.rcp" par le vrai chemin de ton ficher (avec des doubles barres obliques inverses (\\) comme séparateurs) et, si besoin l'échelle (1) et la rotation (0). (command "_.pointcloudattach" "C:\\Nuages\\Nuage.rcp" "_non" (trans '(0 0 0) 0 1) 1 0)

Salut, Première chose, les arguments passés à la fonction command ne sont pas forcément des chaînes de caractères, on peut passer directement des nombres entiers ou réels, des listes de nombre ou n'importe quelle expression qui renvoie un type valide. Dans ton cas, tu pourrais remplacer "0,0,0" par une liste LISP représentant un point : '(0 0 0). La fonction command fonctionne toujours en coordonnées SCU courant, donc si tu veux insérer ton nuage à l'origine du SCG, il faut que tu transforme le point '(0 0 0) du SCG en coordonnées SCU avec la fonction trans : (trans '(0 0 0) 0 1). Donc tu remplaces : "0,0,0" par : (trans '(0 0 0) 0 1).

Ça exploite la minime imprécision dans la valeur de PI/2 (nombre à virgule flottante à double précision). Théoriquement le cosinus de PI/2 est égal à 0 et la tangente de PI/2 est l'infini, mais avec la façon dont sont encodés les nombres réels le cosinus de PI/2 est approximé à 6.12323e-17 (0.0000000000000000612323) et la tangente de PI/2 (soit 1.0 / cos(PI/2)) à 1.63312e+16 (16331239353195370.0). C'est cette valeur qu j'ai choisi pour exprimer l'infini. Nota : cette imprécision n'est pas propre au LISP, on peut la voir en F# par exemple en évaluant : trigones Angle (pi / 2.) ou trigones Sinus 1. dans la fenêtre de Try F#.

@nazemrap Poste ton code Ruby, c'est toujours intéressant de voir les langues étrangères qu'on ne connait pas.

C'est là qu'on aurait aimé avoir une fonction let: (defun compute (a) (let '((sinus (sin a)) (cosinus (cos a))) '(let '((secante (/ 1. cosinus)) (cosecante (/ 1. sinus))) '(let '((tangente (* sinus secante)) (cotangente (* cosinus cosecante))) '(list a sinus cosinus secante cosecante tangente cotangente) ) ) ) )

Une version qui prend aussi en compte les angles 0 et PI/2. Pour exprimer une valeur infinie, on utilise celle renvoyée pour la tangente de PI/2. Cette version traite chaque cas indépendamment pour éviter de recalculer la valeur entrée. (setq *infini* (/ 1. (cos (/ pi 2.)))) (defun trigones (alpha sinus cosinus secante cosecante tangente cotangente) (cond (alpha (cond ((= alpha 0.) (list alpha 0. 1. 1. *infini* 0. *infini*)) ((= alpha (/ pi 2.)) (list alpha 1. 0. *infini* 1. *infini* 0.)) ((< 0. alpha (/ pi 2.)) (setq sinus (sin alpha) cosinus (cos alpha) secante (/ 1. cosinus) cosecante (/ 1. sinus) tangente (* sinus secante) cotangente (* cosinus cosecante) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) (sinus (cond ((= sinus 0.) (list 0. sinus 1. 1. *infini* 0. *infini*) ) ((= sinus 1.) (list (/ pi 2.) sinus 0. *infini* 1. *infini* 0.) ) ((< 0 sinus 1) (setq cosinus (sqrt (- 1. (* sinus sinus))) secante (/ 1. cosinus) cosecante (/ 1. sinus) tangente (* sinus secante) cotangente (* cosinus cosecante) alpha (atan tangente) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) (cosinus (cond ((= cosinus 0.) (list (/ pi 2.) 1. cosinus *infini* 1. *infini* 0.) ) ((= cosinus 1.) (list 0. 0. cosinus 1. *infini* 0. *infini*) ) ((< 0 cosinus 1) (setq sinus (sqrt (- 1. (* cosinus cosinus))) secante (/ 1. cosinus) cosecante (/ 1. sinus) tangente (* sinus secante) cotangente (* cosinus cosecante) alpha (atan tangente) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) (secante (cond ((<= 1. secante) (setq cosinus (/ 1. secante) sinus (sqrt (- 1. (* cosinus cosinus))) cosecante (/ 1. sinus) tangente (* sinus secante) cotangente (* cosinus cosecante) alpha (atan tangente) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) (cosecante (cond ((<= 1. cosecante) (setq sinus (/ 1. cosecante) cosinus (sqrt (- 1. (* sinus sinus))) secante (/ 1. cosinus) tangente (* sinus secante) cotangente (* cosinus cosecante) alpha (atan tangente) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) (tangente (cond ((= tangente 0.) (list 0. 0. 1. 1. *infini* tangente *infini*) ) ((< 0. tangente) (setq alpha (atan tangente) sinus (sin alpha) cosinus (cos alpha) secante (/ 1. cosinus) cosecante (/ 1. sinus) cotangente (* cosinus cosecante) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) (cotangente (cond ((= 0. cotangente) (list (/ pi 2.) 1. 0. *infini* 1. *infini* 0.) ) ((< 0. cotangente) (setq alpha (atan (/ 1. cotangente)) sinus (sin alpha) cosinus (cos alpha) secante (/ 1. cosinus) cosecante (/ 1. sinus) tangente (* sinus secante) ) (list alpha sinus cosinus secante cosecante tangente cotangente) ) ) ) ) )

Ma réponse en LISP pour un angle strictement compris entre 0 et PI/2 utilise la trigonométrie (plutôt que Thales/Pythagore). (defun trigones (alpha sinus cosinus secante cosecante tangente cotangente / asin acos compute) (defun asin (x) (atan x (sqrt (- 1 (* x x))))) (defun acos (x) (atan (sqrt (- 1. (* x x))) x)) (defun compute (a) (list a (setq sinus (sin a)) (setq cosinus (cos a)) (setq secante (/ 1. cosinus)) (setq cosecante (/ 1. sinus)) (* sinus secante) (* cosinus cosecante) ) ) (cond ((and alpha (< 0. alpha (/ pi 2.))) (compute alpha) ) ((and sinus (< 0. sinus 1.)) (compute (asin sinus)) ) ((and cosinus (< 0. cosinus 1.)) (compute (acos cosinus)) ) ((and secante (< 1. secante)) (compute (acos (/ 1. secante))) ) ((and cosecante (< 1. cosecante)) (compute (asin (/ 1. cosecante))) ) ((and tangente (< 0. tangente)) (compute (atan tangente)) ) ((and cotangente (< 0. cotangente)) (compute (atan (/ 1. cotangente))) ) ) )

F#, en plus d'être mieux équipé que AutoLISP en fonctions mathématiques, de gérer les notions d'infini (Infinity) et de valeurs non valides (comme un sinus supérieur à 1) avec NaN (Not a Number), fournit, avec les unions discriminées, un élégant moyen de spécifier le type de valeur passée en argument. Résultat, un code concis et robuste...

Un exemple testable en F#.

Petite précision doit-on considérer que l'angle est strictement compris entre 0 et PI/2 ? Ou doit on aussi traiter les angles 0 et PI/2 (ainsi que les autres paramètres correspondant) ?

Salut, Je suis toujours ravi de pouvoir participer à un nouveau challenge. J'ai bien une réponse, mais je vais attendre un peu que d'autres répondent.