Entmake hatch

Pirlouit · le 10 avril 2020

Bonjour,

il s'agit de mon 1er post sur ce forum, espérant en respecter le protocole.

Voici donc ma 1ère question :

je souhaite créer des hachures avec la fonction lisp "ENTMAKE". Cependant, en souhaitant m'inspirer de la définition d'une hachure existante, je m'aperçois que celle-ci est très longue ...

Quelqu'un peut-il m'indiquer quels sont les éléments indispensables dans la définition ?

Ci-dessous un essai qui ne fonctionne pas ("ent" étant l'entité à hachurer) :

(entmake (list '(0 . "HATCH")
       '(5 . "289")
       '(100 . "AcDbEntity")
       '(67 . 0)
       '(410 . "Model")
       '(8 . "0")
       '(100 . "AcDbHatch")
       '(2 . "ANSI36")
       '(41 . 0.1)
       (cons 330 ent)))

Luna · le 10 avril 2020

Salut,

Je n'ai jamais utiliser entmake pour les hachures, donc je risque de dire des bêtises, mais je pense que les codes DXF 10 (correspondant à la liste des points sont nécessaires.

Tu peux essayer de voir ce post (en anglais) car il pourrait t'aider : https://forums.autodesk.com/t5/visual-lisp-autolisp-and-general/entmake-hatch-with-base-point-or-object-polyline-entity-name/td-p/8696712

Bisous,

Luna

GEGEMATIC · le 10 avril 2020

Salut,

finalement je me dis que beaucoup parmi vous ne doivent pas connaitre la STD LIB, une librairie lisp pré active X,

projet abandonné en 2001, mais plein de bonne choses.

Réalisé dans une université, ce n'était pas du travail d'amateur, et Gille doit bien connaitre la plupart des contributeurs de l'époque ...

perso, je ne l'utilise plus, car la chaine de dépendance est un peu lourde, mais on a des mines de solutions pour tout,

lorsque l'on est coincé.

il y a une module entmake.lsp, où tu trouvera:

STD-ENTMAKE-HATCH

ce qui te permetra de savoir ce qu'il faut a minima.

j'ai vu qu'ils précisaient "non associative", ça ne m'étonne pas, mais je pense qu'il doit y acvoir moyen de faire un entmake associatif.

pour cela il faut analyser un hachure associative, et voir comment la référence aux objet ce fait.

le lien pour STD LIB: stdlib.zip

Un lien pour handle explorer, qui pourra t'aider dans tes recherche sur la structuration des hachures associatives:

Handle explorer

a+

gégé

GEGEMATIC · le 10 avril 2020

@Luna:

tu promets en programmation, bravo, ça remet un peu d'énergie,

et je pense que Gille va se sentir moins seul...

Fraid · le 10 avril 2020

Bonjour,

Pour connaitre le contenu DXF d'une entité,

un grand classic

(defun c:get nil
 (initget "entité sous-entité")
 (mapcar 'print (entget (car
                           (if (= (getkword "\n[Entité/Sous-entité]< e >: ")
                                  "sous-entité")
                             (nentsel)
                             (entsel)
                           )
                         )
                 )
 )
 (textscr)
 (princ)
)

Pirlouit · le 10 avril 2020

Quel retour rapide !

Luna,

merci pour ce lien, il semble lister l'intégralité des codes liés aux hachures, mais sans identifier ceux indispensables. Enfin je crois, car mon niveau en anglais laisse à désirer !!

Gegematic,

je ne connaissais effectivement pas la STD LIB qui est une vraie mine d'or. Bizarre que je n'en ai pas entendu parler avant !? Depuis le temps que je parcours les sites et forums liés au lisp. Je pense pouvoir m'en sortir avec STD-ENTMAKE-HATCH, si c'est le cas je posterai une solution qui fonctionne au cas cela serve à quelqu'un. Et dans tous les cas la STD LIB deviendra une de mes références, à l'instar du guide de Giles "Introduction à Autolisp" qui commence à être bien usé, à force de le feuilleter ...

Merci de votre contribution rapide (et de qualité) à tous les 2.

PS : joyeuses Pâques !

Pirlouit · le 10 avril 2020

Bonjour Fraid,

en fait je souhaite connaitre uniquement les éléments de définition indispensables, afin de ne pas avoir à indiquer les 49 retournés par ENTGET.

Bonjour,

Pour connaitre le contenu DXF d'une entité,

un grand classic

(defun c:get nil
 (initget "entité sous-entité")
 (mapcar 'print (entget (car
                           (if (= (getkword "\n[Entité/Sous-entité]< e >: ")
                                  "sous-entité")
                             (nentsel)
                             (entsel)
                           )
                         )
                 )
 )
 (textscr)
 (princ)
)

Fraid · le 10 avril 2020

tu peux le faire de manière empirique,

en commençant avec toutes les entrées,

et en supprimant les entrées une à une et voir ce que cela donne

car cela dépend comment son configurées tes hachures par défaut.

(gile) · le 10 avril 2020

Salut,

Vouloir faire une hachure avec entmake, c'est mettre la barre très haut, CF les données DXF plus les données de contour et les données de motif.

Si tu ne veux absolument pas utiliser (command ...) (ce que je ferais probablement si j'avais à le faire en LISP) et que tu vises pas AutoCAD MAC tu peux utiliser (vla-AddHatch ...) qui est beaucoup plus simple d'utilisation.

Sinon, la STB LIB, un projet de Reini Urban, est très certainement la plus grosse mine de joyaux AutoLISP. Le projet s'est malheureusement heurté aux limites du LISP quand il s'agit de faire et surtout de maintenir une bibliothèque "universelle", collaborative et interdépendante (surtout à une époque où des outils comme GitHub n'existait pas).

Luna · le 10 avril 2020

Salut !

@Luna:
tu promets en programmation, bravo, ça remet un peu d'énergie,
et je pense que Gille va se sentir moins seul...

Merci GEGEMATIC :3 mais je manque cruellement d'expérience dans le domaine de la programmation malheureusement...

j'ai vu qu'ils précisaient "non associative", ça ne m'étonne pas, mais je pense qu'il doit y acvoir moyen de faire un entmake associatif.
pour cela il faut analyser un hachure associative, et voir comment la référence aux objet ce fait.

Pour avoir déjà fait quelques recherches à ce sujet, une hachure associative se différencie d'une non associative via le code DXF 97 (0 si non associative, 1 sinon) ainsi que l'existence du code DXF 330 qui pointe vers l'objet associé (qui vient en plus du code DXF 330 pointant vers le "BLOCK_RECORD") et donc il faut également un code DXF 330 pointant vers l'objet hachure dans la liste de l'objet associé (ce qui est complexe, car cette référence-ci est indiquée de la manière suivante :

(entget (car (entsel)))
-> (... (102 . "{ACAD_REACTORS") (330 . <Hatchentityname>) (102 . "}") ...)

Donc quelque peu complexe à gérer via entmake car cela requiert de modifier également les entités existantes, si tenté que ça fonctionne --")

Voili voilou :)

Ensuite pour ce qui est des codes obligatoires, de manière générale on aura toujours les codes DXF 0, 10 (et/ou 11 selon le type d'objet), 100 (référence plus précise du type d'objet) et à ceux-là s'ajouteront certains codes associés au type d'objet lui-même

Bisous,

Luna

(gile) · le 10 avril 2020

J'ai fait quelques tests, pour une hachure toute simple (SOLID) dans une polyligne rectangulaire (pl) de (0,0) à (80,50) les codes DXF minimums semblent être :

(entmake
 (list
   '(0 . "HATCH")
   '(100 . "AcDbEntity")
   '(100 . "AcDbHatch")
   '(10 0.0 0.0 0.0)
   '(210 0.0 0.0 1.0)
   '(2 . "SOLID")
   '(70 . 1)
   '(71 . 1)
   '(91 . 1)
   '(92 . 1)
   ;; données du contour
   '(93 . 4)
   '(72 . 1)
   '(10 0.0 0.0 0.0)
   '(11 80.0 0.0 0.0)
   '(72 . 1)
   '(10 80.0 0.0 0.0)
   '(11 80.0 50.0 0.0)
   '(72 . 1)
   '(10 80.0 50.0 0.0)
   '(11 0.0 50.0 0.0)
   '(72 . 1)
   '(10 0.0 50.0 0.0)
   '(11 0.0 0.0 0.0)
   '(97 . 1)
   (cons 330 pl)
   ;; données du motif
   '(75 . 1)
   '(76 . 1)
   '(98 . 1)
   '(10 0.0 0.0 0.0)
 )
)

pour une hachure ANSI31, c'est un petit peu plus compliqué:

(entmake
 (list
   (0 . "HATCH")
   (100 . "AcDbEntity")
   (100 . "AcDbHatch")
   '(10 0.0 0.0 0.0)
   '(210 0.0 0.0 1.0)
   '(2 . "ANSI31")
   '(70 . 0)
   '(71 . 1)
   '(91 . 1)
   '(92 . 1)
   ;; données du contour
   '(93 . 4)
   '(72 . 1)
   '(10 0.0 0.0 0.0)
   '(11 80.0 0.0 0.0)
   '(72 . 1)
   '(10 80.0 0.0 0.0)
   '(11 80.0 50.0 0.0)
   '(72 . 1)
   '(10 80.0 50.0 0.0)
   '(11 0.0 50.0 0.0)
   '(72 . 1)
   '(10 0.0 50.0 0.0)
   '(11 0.0 0.0 0.0)
   '(97 . 1)
   (cons 330 pl)
   ;; données du motif
   '(75 . 1)
   '(76 . 1)
   '(52 . 0.0)
   '(41 . 1.0)
   '(77 . 0)
   '(78 . 1)
   '(53 . 0.785398)
   '(43 . 0.0)
   '(44 . 0.0)
   '(45 . -2.24506)
   '(46 . 2.24506)
   '(79 . 0)
   '(98 . 1)
   '(10 0.0 0.0 0.0)
 )
)

Il va sans dire que pour des contours moins basiques ou des gradiants, les choses se compliquent rapidement (sans parler d'ilots ou autres joyeusetés).

bonuscad · le 10 avril 2020

Bonsoir,

En lisp j'ai eu l'occasion d'utiliser une fonction d' Elpanov Evgeniy (qui, fut un temps fréquentait un peu le forum)

J'avais repris sa fonction dans ce sujet

Je te la re-présente sous une forme plus légère

(defun entmakex-hatch (l a n s lay)
;; By ElpanovEvgeniy
;; version 0.2
;; 2012.07.11
;; mailto: elpanov@gmail.com
;; web:	elpanov.com
;; Arguments
;; L - list point
;; A - angle hatch
;; N - name pattern
;; S - scale
;; lay - layer
;; return - hatch ename
 (entmakex
(apply 'append
 	(list
   	(list '(0 . "HATCH") '(100 . "AcDbEntity") '(410 . "Model") '(100 . "AcDbHatch")
     	'(10 0.0 0.0 0.0) '(210 0.0 0.0 1.0)
     	(cons 2 n)
     	(cons 8 lay)
     	(if (= n "SOLID")
       	'(70 . 1)
       	'(70 . 0)
     	) ;_  if
     	'(71 . 0)
     	(cons 91 (length l))
   	) ;_  list
   	(apply 'append
     	(mapcar
       	'(lambda (a)
         	(apply 'append
           	(list
             	(list '(92 . 7) '(72 . 1) '(73 . 1) (cons 93 (/ (length a) 2)))
             	a
             	'((97 . 0))
           	) ;_  list
         	) ;_  apply
       	) ;_  lambda
       	l
     	) ;_  mapcar
   	) ;_  apply
   	(list
     	'(75 . 0) '(76 . 1) (cons 52 a) (cons 41 s) '(77 . 0) '(78 . 1) (cons 53 a)
     	'(43 . 0.) '(44 . 0.) '(45 . 1.) '(46 . 1.) '(79 . 0) '(47 . 1.) '(98 . 2)
     	'(10 0. 0. 0.0) '(10 0. 0. 0.0) '(451 . 0) '(460 . 0.0) '(461 . 0.0) '(452 . 1)
     	'(462 . 1.0) '(453 . 2) '(463 . 0.0) '(463 . 1.0) '(470 . "LINEAR")
   	) ;_  list
 	) ;_  list
) ;_  apply
 ) ;_  entmakex
)
(defun createhatchlist (e)
 (if e
(vl-remove-if-not '(lambda (x) (member (car x) '(10 42))) (entget e))
 )
)
(defun c:hatch_poly (/ jspl nbe tmp hList)
 (setq jspl (ssget '((0 . "LWPOLYLINE"))))
 (cond
(jspl
 	(repeat (setq nbe (sslength jspl))
   	(if (setq tmp (CreateHatchList (ssname jspl (setq nbe (1- nbe)))))
     	(setq hList (cons tmp hList))
   	)
 	)
 	(entmakex-hatch (reverse hList) 0.0 "_SOLID" 1.0 (getvar "CLAYER"))
)
 )
 (prin1)
)

La commande hatch_poly vas te permettre de hachurer la sélection (une ou plusieurs) de LWPOLYLINE.

Ces polylignes peuvent aussi comporter des arcs, si une polyligne est incluse dans une autre cela fera une hachure avec ilôts.La ligne (entmakex-hatch (reverse hList) 0.0 "_SOLID" 1.0 (getvar "CLAYER")) peut être personnaliser avec les arguments qui te conviennent...

Pirlouit · le 15 avril 2020

Je rejoins Gile sur la complexité de passer par Entmake pour créer des hachures (j'avais sous estimé la tâche). J'avais également de mon côté testé par élimination les codes DXF indispensables. Il s'avère que peu sont facultatifs.

J'ai fini par m'en sortir car mon cas est simple : hachures d'une polyligne fermée composée uniquement de lignes (pas d'arcs ou d'autres formes exotiques). Et pourtant mon code ressemble déjà à une usine à gaz ! En effet, il ne suffit pas d'indiquer l'entité à hachurer (code 330), mais également tous les segments qui la compose (code 72, 10 et 11 pour une polyligne "simple").

Je me garderai bien de partir sur cette voie pour un cas plus complexe. J'ai pris note que d'autres solutions existent :

1) (command "_hatch" ...)

Tout se résume en une seule ligne!

2) Vla-AddHatch

Malheureusement, je ne maitrise pas encore les vl, vla, vlax et leur syntaxe. Je me contente de copier "bêtement" des lignes de code qui en contiennent. Déjà que quelques subtilités du lisp basique m'échappe encore ...

3) En passant par Entmake

Ou comment faire compliqué lorsque des solutions plus simples existent !

Merci Bonuscad pour la version de ElpanovEvgeniy qui fonctionne à merveille. Je connaissais déjà son code "triangulate" qui est assez impressionnant (même s'il manque la gestion des limites extérieures et celle des "cassures" de terrain pour créer des MNT parfaits), ce sera certainement l'objet d'un post ultérieur.

En conclusion, pour celles et ceux qui veulent absolument passer par Entmake, préférer la solution préconisée par Bonuscad. Pour éviter de finir avec cela (mon usine à gaz, qui divise un arc, trace une polyligne, la hachure, indique sa surface) :

(defun c:Div_arc (/ os ent1 nbdiv defpoly1 defpoly2a defpoly2b defpoly2c defpoly2 defpoly3 a)
 (setq os (getvar "osmode"))					;récupère le(s) type(s) d'accroche objet
 (setvar "osmode" 0)						;désactive les accroches objets
 (setvar "pdmode" 35)						;défini un style de point
 (setvar "pdsize" -2)						;défini une taille point par rapport à l'écran

 (setq ent (entlast))						;récupère la dernière entité créée
 (setq ent1 (car (entsel "\n ==> Sélectionnez un arc de cercle : ")))
 (setq nbdiv (getint "\n ==> Nombre de division pour l'arc : "))
 (setq ent1def (entget ent1))					;récupère la définition de l'arc
 (setq cent (cdr (assoc 10 ent1def)))				;récupère les coordonnées du centre
 (setq ray (cdr (assoc 40 ent1def)))				;récupère le rayon de l'arc
 (setq ang1 (cdr (assoc 50 ent1def)))				;récupère l'angle 1
 (setq ang2 (cdr (assoc 51 ent1def)))				;récupère l'angle 2
 ;Calcul coordonnées points départ et arrivée de l'arc
 (setq x1 (* ray (cos ang1)))
 (setq y1 (* ray (sin ang1)))
 (setq x2 (* ray (cos ang2)))
 (setq y2 (* ray (sin ang2)))
 (setq x1scg (+ x1 (nth 0 cent)))
 (setq y1scg (+ y1 (nth 1 cent)))
 (setq x2scg (+ x2 (nth 0 cent)))
 (setq y2scg (+ y2 (nth 1 cent)))
 ;-----------------------------------
 (setq lstdiv nil def1 nil def2 nil)

 (setq defpoly1 (list '(70 . 1) (cons 90 (+ nbdiv 1)) '(100 . "AcDbPolyline") '(62 . 1) '(100 . "AcDbEntity") '(0 . "lwpolyline")))
 (setq defpoly1 (cons (list 10 x1scg y1scg) defpoly1))		;ajoute les coordonnées du point de départ de l'arc
 
 (command "_divide" ent1 nbdiv)		;divise l'arc
 
 (repeat (- nbdiv 1)
   (setq ent (entnext ent))
   (setq ptent (assoc 10 (entget ent)))	;récupère les coordonnées du point
   (setq defpoly1 (cons ptent defpoly1))	;ajoute les coordonnées à la liste
 );end repeat
 (setq defpoly1 (cons (list 10 x2scg y2scg) defpoly1))		;ajoute les coordonnées du point d'arrivée de l'arc
 (setq defpoly1 (reverse defpoly1))
 (entmake defpoly1)				;trace la polyligne
 (setq ent2 (entlast))				;récupère le nom de la polyligne
 ;-----------------------------
 (command "_area" "o" (entlast))		
 (setq aire (getvar "area"))			;récupère l'aire de la polyligne
 ;-------------------------------------------
 ;-> Récupération définition contour hachures
 ;-------------------------------------------
 (setq lst-pts (mapcar 'cdr (vl-remove-if-not ' (lambda (x) (= (car x) 10)) (entget (entlast)) ) ) ) 	;récupère les coordonnées d'extrémités de la polyligne
 (setq cpt1 0)
 (setq defpoly2a '(72 . 1))
 (setq ptfinal1a (list 11 (car (nth 0 lst-pts)) (cadr (nth 0 lst-pts))))	; coordonnées x du dernier point
 (setq ptfinal1b (list 10 (car (last lst-pts)) (cadr (last lst-pts))))		; coordonnées y du dernier point
 (setq defpoly4 (list defpoly2a ptfinal1b ptfinal1a))				; dernier segment de polyligne
 (repeat nbdiv
   ;(cons '(72 . 1) defpoly2)
   (setq defpoly2b (list 10 (car (nth cpt1 lst-pts)) (cadr (nth cpt1 lst-pts)) ))	;construit une liste du type (10 256.36 584.752)
   (setq defpoly2c (list 11 (car (nth (+ 1 cpt1) lst-pts)) (cadr (nth (+ 1 cpt1) lst-pts)) ))
   (setq defpoly2 (list defpoly2a defpoly2b defpoly2c))
   (setq defpoly3 (append defpoly3 defpoly2))
   (setq cpt1 (+ cpt1 1))
 )
 (setq defpoly3 (append defpoly3 defpoly4))		; contour complet hachures
 ;-----------
 ;-> Hachures
 ;-----------
 ;Début de définition
 (setq lst1 (list '(0 . "HATCH")		; Type d'entité
       	   ;'(5 . "209")		; <FACULTATIF> Maintien (handle) 
           '(100 . "AcDbEntity")
           '(67 . 0)			; 0 => espace papier, 1 => espace objet
           ;'(410 . "Model")		; <FACULTATIF> Nom de la présentation ou "Model"
           ;'(8 . "0")			; <FACULTATIF> Nom du calque
           ;'(62 . 94)			; <FACULTATIF> Couleur hachures
           '(100 . "AcDbHatch")
           '(10 0 0 0)			; Elevation ?
           '(210 0 0 1)			; Direction d'extrusion
           '(2 . "ANSI36")		; Motif de hachures
           '(70 . 0)			; Solid Fill Flag : 0 => Pattern Fill, 1 => Solid Fill
           '(71 . 1)			; Associativity Flag : 0 => Non-associative, 1 => Associative
           '(91 . 1)			; Number of body loops
           '(92 . 1)			; ??
           (cons 93 (+ nbdiv 1))	; Nb de sommets ou de côtés ??
      )
 )
 ;Fin de définition
 (setq lst2 (list '(97 . 1)
           (cons 330 ent2)
           '(75 . 0)			; Hatch Style : 0 => Normal "Odd Parity", 1 => Hatch Outermost Area only, 2 => Hatch Entire Area, "Holes" included
           '(76 . 1)			; Hatch Pattern Type : 0 => User-Defined, 1 => Predefined, 2 => Custom
           '(52 . 0.0)			; Angle hachures en radians
           '(41 . 10.0)			; Echelle hachures
           '(77 . 0)
           '(78 . 1)
           '(53 . 0.0)
           '(43 . 0.0)
           '(44 . 0.0)
           '(45 . -2.24506)
           '(46 . 2.24506)
           '(79 . 0)
           '(98 . 1)			; Nombre de point de départ
           '(10 0.0 0.0 0.0)		; Point de départ
     )
 )
 (setq defhach (append lst1 defpoly3 lst2))	; début définition + contour hachures + fin définition
 (entmake defhach)
 
 
 ;-----------------------------
 (setq pt_txt (list (+ (/ (+ x1scg x2scg) 2) (/ ray 10)) (/ (+ y1scg y2scg) 2)))	;point d'insertion du texte
 (entmake (list '(0 . "TEXT")			;insertion du texte relatif à l'aire
	 '(62 . 1)
	 (cons 10 pt_txt)
	 (cons 40 (/ ray 15))
	 (cons 1 (strcat "Section : " (rtos aire)))
	 (cons 50 (+ (/ (+ ang1 ang2) 2) pi))
	 '(72 . 0)
	 '(73 . 0)))
 

 (setvar "osmode" os)
);_end defun

Et merci à Gile, Luna, Fraid et Bonuscad de votre aide pour ma 1ère question sur ce forum.

@+

lecrabe · le 15 avril 2020

Hello

Remarque / Question de votre dévoué Décapode "nul ou presque" en Lisp :

Je trouve que les Hachures "ressemblent" aux MPolygons ?!

LA SANTE (Stay Safe), Bye, lecrabe "triste"

Automne 2020, la retraite

GEGEMATIC · le 16 avril 2020

salut,

Remarque / Question de votre dévoué Décapode "nul ou presque" en Lisp :
Je trouve que les Hachures "ressemblent" aux MPolygons ?!

C'est vrai, mais je suis pas sur qu'un Mpolygon puisse avoir des contours arc, spline ?

ça doit être surtout ça la différence.

parce que sinon, les 2 on en commun de pouvoir être composés d'ilots multiples.

a+, Gégé

Connexion

Entmake hatch

Messages recommandés

Pirlouit

Luna

GEGEMATIC

GEGEMATIC

Fraid

Pirlouit

Pirlouit

Fraid

(gile)

Luna

(gile)

bonuscad

Pirlouit

lecrabe

GEGEMATIC

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante