retour des métrés...

[x_all]

yeah!!!

 

j'ai un peu de temps de libre....c'est forcément bon signe par les temps qui courent mais ça fait pas de mal car normalement lundi j'ai un autre chantier qui arrive...

 

je reviens donc sur mon projet de métré...

 

il y a sur le forum à peu près tous les morceaux de code dont j'ai besoin, mais je voudrai rassembler tout ça dans une seule commande.

 

 

dans mon dessin de réseau, j'ai dans des calques différentes épaisseur de polylignes. de plus, il y a des lignes ou polylignes non fermées, et des polylignes fermées.

le but du jeu, c'est de faire une sélection de l'ensemble et de sortir un listing des longueurs par calque et par épaisseur pour les éléments non fermé, et à la suite un listing des surface par calque des éléments fermés.

 

je pense que je vais avoir d'autres difficultés et que je reviendrai vers vous pour demander des conseils, mais en premier lieu je bute sur un truc.

 

Comment faire pour trier ma sélection en 2 listes

 

si j'ai bien tout compris, lors d'une sélection

(setq ssa (ssget  (list '(-4 . "<OR") '(0 . "*POLYLINE") '(0 . "LINE") '(-4 . "OR>"))))

stocke dans ssa la liste de mes polyligne + ligne.

 

et

(setq ssb (ssget '((0 . "*POLYLINE") (-4 . "&") (70 . 1))))

stocke dans ssb la liste des polyligne fermée...

 

mais je ne veux sélectionner qu'une fois... et sortir de ssa les polyligne fermées...

je patine un peu là ... non?

[VDH-Bruno]

Bonjour,

 

j'ai un peu de temps de libre....

Bon dans ce cas.. On va en abuser, et te proposant 2 méthodes. :D

 

dans mon dessin de réseau, j'ai dans des calques différentes épaisseur de polylignes. de plus, il y a des lignes ou polylignes non fermées, et des polylignes fermées.

le but du jeu, c'est de faire une sélection de l'ensemble…

si j'ai bien tout compris, lors d'une sélection

(setq ssa (ssget (list '(-4 . "<OR") '(0 . "*POLYLINE") '(0 . "LINE") '(-4 . "OR>"))))

 

Un équivalent simplifié de ta sélection :

(setq ssa (ssget '((0 . "*POLYLINE,LINE"))))

 

Seulement en utilsant * tu vas sélectionner toutes les polylignes : optimisé 2D (lwpolyline), anciennes 2D (polyline) , polylignes 3D (polyline), ainsi que les maillages (polyline) pour éviter cela tu doit affiner ta sélection en utilisant les groupages logiques ("<and", "and>", "<or", "or>", "<xor", "xor>", "<not" et"not>") et les opérateurs binaires ("&" et "&=").

 

Exemple de sélection qui écarte les maillages au moyen du code 70 :

(setq ssa (ssget '((-4 . "<OR")
                  (0 . "LINE,LWPOLYLINE")
                  (-4 . "<AND")
                  (0 . "POLYLINE")
                  (-4 . "<NOT")
                  (-4 . "&")
                  (70 . 112)
                  (-4 . "NOT>")
                  (-4 . "AND>")
                  (-4 . "OR>")
                 )
         )
)

Suit ce lien : http://cadxp.com/index.php?/topic/36313-resolufonction-measure-en-vlisp/page__p__197455__fromsearch__1#entry197455

Tu trouveras une discussion récente dans qui traite d'un problème similaire..

 

 

Sinon plus simplement, on peut faire l’hypothèse que tu travaille exclusivement en 2D et avec des polylignes optimisées dans ce cas ta sélection est la suivante:

(setq ssa (ssget '((0 . "LWPOLYLINE,LINE"))))

 

 

 

le but du jeu, c'est de faire une sélection de l'ensemble et de sortir un listing des longueurs par calque et par épaisseur pour les éléments non fermé, et à la suite un listing des surface par calque des éléments fermés.

…

mais je ne veux sélectionner qu'une fois... et sortir de ssa les polyligne fermées...

 

La sélection étant supposé établie, pour la suite je te propose deux méthodes :

 

1er méthode

Parcourir ta sélection avec une boucle et la fonction ssname et de tester si l’entité et une polyligne et si elle est fermé, si oui placer l’entité dans un nouveau jeu de sélection puis la supprimer de l’ancienne sélection (qui contiendra tous les autre éléments).

 

(defun selection (/ i e e_dxf)
 ;; Sélection de départ
 (setq ssa (ssget '((0 . "LWPOLYLINE,LINE"))))
 ;; Crée un nouveau jeu de sélection
 (setq ssb nil; Supprime l'ancien pour la phase de teste
       ssb (ssadd); Crée un nouveau jeu de sélection
 )
 ;; Parcourt du jeu de sélection depuis la fin
 (repeat (setq i (sslength ssa))
   ;; Obtient le nom de l'entité à l'indice spécifié
   (setq e (ssname ssa (setq i (1- i))))
   ;; Extrait sa liste de définition dxf
   (setq e_dxf (entget e))
   ;; Teste si polyligne et si fermé (présence du bit 1 dans le code 70)
   (if (and (wcmatch (cdr (assoc 0 e_dxf)) "*POLYLINE") (= 1 (logand (cdr (assoc 70 e_dxf)) 1)))
     (progn (ssadd e ssb) ; ajoute l'entité a la sélection ssb
            (ssdel e ssa) ; supprime l'entité de la sélection ssa
     )
   )
 )
)

 

Pour tester le code comme les jeux de sélection n’ont pas été localisé dans la fonction (selection), dans la console visual lisp, tape ceci pour visualiser tes différentes sélections:

 

_$ (selection)

<Selection set: 259>

_$ (sssetfirst nil ssa)

(nil <Selection set: 259>)

_$ (sssetfirst nil ssb)

(nil <Selection set: 25b>)

_$

 

 

 

2ème méthode (la plus simple et celle que tu voulais.. ;) )

Filtrer la sélection de départ, au moyen de la sélection Précédente pour créer la nouvelle sélection puis la parcourir afin de supprimer ses éléments de la sélection précédente.

 

(defun selection (/ i)
 ;; Sélection de départ
 (setq ssa (ssget '((0 . "LWPOLYLINE,LINE"))))
 ;; Sélection les polylignes fermé de la sélection précédente
 (setq ssb (ssget "_P" '((0 . "*POLYLINE") (-4 . "&") (70 . 1))))
 ;; Parcourt du jeu de sélection
 (repeat (setq i (sslength ssb))
   ;; Supprime dans ssa l'entitées présente dans ssb
   (ssdel (ssname ssb (setq i (1- i))) ssa)
 )
)

 

Pour tester c’est comme le code précédent

 

Bon courage pour la suite.

A+

[alala]

Quelque chose dans ce genre?

(if (setq ss (ssget  '((0 . "*POLYLINE,LINE"))))
(progn
	(setq ssa (ssadd))
	(setq ssb (ssadd))
	(setq i 0)
	(repeat (sslength ss)
		(if (zerop (logand (cdr (assoc 70 (entget(ssname ss i)))) (+ 1)))
			(ssadd (ssname ss i) ssa)
			(ssadd (ssname ss i) ssb)
		)
		(setq i (1+ i))
	)
)
)

Par contre ce sera une opération très lente si il y a beaucoup d'objets.

[VDH-Bruno]

Bonjour alala,

 

Attention aux lignes, elles ne possèdent pas de code 70 donc:

_$ (logand nil 1)
; erreur: type d'argument incorrect: fixnump: nil

 

 

Et donc pour x_all une troisième méthode avec le code de alala,

(if (setq ss (ssget '((0 . "LWPOLYLINE,LINE"))))
 (progn (setq ssa (ssadd))
        (setq ssb (ssadd))
        (setq i 0)
        (repeat (sslength ss)
          (if (zerop (logand (cond ((cdr (assoc 70 (entget (ssname ss i))))) (0))  1))
            (ssadd (ssname ss i) ssa)
            (ssadd (ssname ss i) ssb)
          )
          (setq i (1+ i))
        )
 )
)

 

A+

Modifié le 29 novembre 2012 par VDH-Bruno

[alala]

Oups j'avais effectivement pas pensé à tester sur des lignes.

Pour mon code il est inspiré par la solution qui m'avait été proposé dans le sujet mis en lien ci dessus. (le logand reste bien obscure pour moi)

 

Merci beaucoup VDH-Bruno pour tout le savoir que tu m'apporte (et aux autres aussi je pense) par tes messages!

[x_all]

Ou ha houuu !!!

un grand merci à tous les deux...

 

effectivement je ne fait que de la 2d donc pas la peine de filtrer les maillages ( :P )

mais j’apprécie les explications à propos des filtres de ssget les codes DXF reste pour moi une des fonctions qui me pose le plus de pb et si en plus on les combines je perd assés vite pied...

 

je reconnais bien l’élégance du programmeur, se servir de "_P"... j'en reste ébahi...

 

je compile tout ça et je mettrai en ligne le début de ma sueur virtuelle...

 

 

 

au passage, pour les épaisseurs de polyligne, je vais faire une ''assoc'' avec la somme des longueur, le calque, et l’épaisseur de la polyligne...

 

comment récupérer cette épaisseur (le PLINEWID)

quand je dis que j'ai du mal avec les codes DXF ...

[VDH-Bruno]

au passage, pour les épaisseurs de polyligne, je vais faire une ''assoc'' avec la somme des longueur, le calque, et l’épaisseur de la polyligne...

 

comment récupérer cette épaisseur (le PLINEWID)

quand je dis que j'ai du mal avec les codes DXF ...

x_all , pour les épaisseurs des lwpolylignes, regarde l’aide du côté des codes 43, 40 & 41. Si un code 43 est définie (présent dans la liste dxf de l’entitée), c’est que son épaisseur est constante 0.0 ou plus récupérable par assoc.

Si le code 43 est absent (assoc renvoie nil) l’épaisseur est variable, là il faut interroger les codes 40 et 41 du segment voulu.

 

Pour mon code il est inspiré par la solution qui m'avait été proposé dans le sujet mis en lien ci dessus. (le logand reste bien obscure pour moi)

alala, je trouve ton code très bon, pour les lignes même sans moi tu t’en serai aperçu à l’usage, pour la petite histoire le conseil pour les opérations sur les bits je le tiens de BonusCAD, quant à l’usage de logand suit ce lien http://cadxp.com/index.php?/topic/16226-mapcar-et-consorts/

en réponse n°7 et n°14, il y a une petite explication de (gile) si cela peut aider à y voir plus clair, j’avais tenté une sur boole logior et logand que je n’ai jamais publié (trop confus), si je la retrouve j’essayerai de la finaliser mais avec les fêtes qui approche, j’ai peu de temps libre..

 

A+

[x_all]

re bonjour

 

 

j'en suis là, j'en suis au stade ou j’apprends à lire et même pour repomper ces routines existantes j'en bave des ronds de chapeaux....

 

 

 

;; métré vrd
;pour les réseaux
;fait la somme par calque et par épaisseur des polylignes + lignes non fermé
;l'épaisseur des polylignes permet des traiter les différent diamètres
;pour les surfaces
;fait la somme par calque des polylignes fermées pour les surfaces d'enrobé ect...
;
; geler tout ce qui n'est pas nécessaire et lancer ...
;;

(defun c:m-vrd (/      ssa    tota   nba    na	   surfa  obja	 lsta
	laya   l_laya epa    ssb    totb   nbb	  nb	 surfb
	objb   lstb   layb   l_layb
       )
 (vl-load-com)
 ;; sélection des elements et trie dans 2 selection sets
 (setq ssa (ssget '((0 . "LWPOLYLINE,LINE"))))
 ;; Sélection les polylignes fermé de la sélection précédente
 (setq ssb (ssget "_P" '((0 . "*POLYLINE") (-4 . "&") (70 . 1))))
 ;; Parcourt du jeu de sélection
 (repeat (setq i (sslength ssb))
   ;; Supprime dans ssa l'entitées présente dans ssb
   (ssdel (ssname ssb (setq i (1- i))) ssa)
 )
 ;; traitement des longueurs

 (progn
   (setq nba  (sslength ssa)
  na   0
  tota 0.0
   )
   (princ
     (strcat "\n\nLe dessin contient : "
      (itoa nba)
      " polylignes non fermées"
     )
   )
   (repeat nba
     (setq obja  (vlax-ename->vla-object (ssname ssa na))
    longa (vlax-curve-getDistAtParam
	    obja
	    (vlax-curve-getEndParam obja)
	  )
    tota  (+ tota longa)
    laya  (vla-get-Layer obja)
     )
     (setq na (1+ na))

     (if (setq l_laya (assoc laya lsta))
(setq
  lsta (subst (cons laya (+ longa (cdr l_laya))) l_laya lsta)
)
(setq lsta (cons (cons laya longa) lsta))
     )
   )
   (mapcar '(lambda (x)
       (princ (strcat "\nLongueur totale sur le calque "
		      (car x)
		      " : "
		      (rtos (cdr x))
	      )
       )
     )
    lsta
   )
   (princ
     (strcat "\nLongueur totale dans le dessin = " (rtos tota))
   )
   (textscr)
 )


 ;; traitement des surfaces
 (progn
   (setq nbb  (sslength ssb)
  nb   0
  totb 0.0
   )
   (princ
     (strcat "\n\nLe dessin contient : "
      (itoa nbb)
      " polylignes fermées"
     )
   )
   (repeat nbb
     (setq objb  (vlax-ename->vla-object (ssname ssb nb))
    surfb (vla-get-area objb)
    totb  (+ totb surfb)
    layb  (vla-get-Layer objb)
     )

     (setq nb (1+ nb))

     (if (setq l_layb (assoc layb lstb))
(setq
  lstb (subst (cons layb (+ surfb (cdr l_layb))) l_layb lstb)
)
(setq lstb (cons (cons layb surfb) lstb))
     )
   )
   (mapcar '(lambda (x)
       (princ (strcat "\nSURFACE totale sur le calque "
		      (car x)
		      " : "
		      (rtos (cdr x))
	      )
       )
     )
    lstb
   )
   (princ
     (strcat "\nSURFACE totale dans le dessin = " (rtos totb))
   )
   (textscr)
 )

)

 

ça marche comme je veux, mais reste à intégrer les épaisseur de polyligne au traitement des longueurs...

j'en bave car je doit apprendre le vocabulaire et la syntaxe de cette nouvelle langue et pour qq1 qui n'a jamais fait de programmation le lisp est pas des plus simple

j'ai fini par comprendre a peux près tout sauf cette partie cruciale pour la suite...

 

(if (setq l_laya (assoc laya lsta))
(setq
  lsta (subst (cons laya (+ longa (cdr l_laya))) l_laya lsta)
)
(setq lsta (cons (cons laya longa) lsta))
     )

 

je ne comprend pas comment on peu faire un test avec lsta qui n'est définie qu'après (à 'na' =0 au moins)

et les 2 setq qui suivent sont pas des plus clair non plus....

 

je vais chercher d'autres piste car je ne suis pas sur de pouvoir rajouter le traitement des épaisseurs avec cette méthode.

 

néant moins j'aimerai bien comprendre...

[alala]

Sur un If la première action est "si vrais" et la seconde "sinon".

Donc ici si l'on a un lsta déjà définit on fait le premier setq, sinon l'on le définit avec le second.

 

Vu que tu parcours tous les objets que tu sélectionne, tu pourrait faire plus simple en ne parcourant qu'une fois ta sélection via une boucle vlax-for

 

L'on pourrais écrire :

 

(defun c:m-vrd ( / ss surfb totb layb l_layb lstb longa tota laya l_laya lsta)
(vl-load-com)
 
(setq ss (ssget '((0 . "LWPOLYLINE,LINE")))) ;sélection des lignes et polylignes

(vlax-for pl (setq ss (vla-get-ActiveSelectionSet
						(vla-get-ActiveDocument
						(vlax-get-acad-object)))) ;pour chaque objet de la sélection
	(if (vlax-curve-isClosed pl) ; si fermé
		(progn ;pour les polylignes fermés
			(setq surfb (vlax-curve-getArea pl))
			(setq totb  (+ totb surfb))
			(setq layb  (vla-get-Layer pl))
			(if (setq l_layb (assoc layb lstb))
				(setq
					lstb (subst (cons layb (+ surfb (cdr l_layb))) l_layb lstb)
				)
				(setq lstb (cons (cons layb surfb) lstb))
			)
		)
		(progn ;pour les polylignes ouvertes
			(setq longa (vlax-curve-getDistAtParam
							pl
							(vlax-curve-getEndParam pl)
						 ))
			(setq tota  (+ tota longa))
			(setq laya  (vla-get-Layer pl))
			(if (setq l_laya (assoc laya lsta))
				(setq
					lsta (subst (cons laya (+ longa (cdr l_laya))) l_laya lsta)
				)
				(setq lsta (cons (cons laya longa) lsta))
			)
		)
	)
)
		
(mapcar '(lambda (x)
			   (princ (strcat "\nLongueur totale sur le calque "
							  (car x)
							  " : "
							  (rtos (cdr x))
					  )
			   )
			 )
			lsta
)
(princ
  (strcat "\nLongueur totale dans le dessin = " (rtos tota))
)

(mapcar '(lambda (x)
			   (princ (strcat "\nSURFACE totale sur le calque "
							  (car x)
							  " : "
							  (rtos (cdr x))
					  )
			   )
			 )
			lstb
)
(princ
  (strcat "\nSURFACE totale dans le dessin = " (rtos totb))
)

(princ)
(textscr)
)

 

A tester car je n'ai pas d'autocad sous la mains.

 

Pour avoir pu tester quelques codes sur des plans avec beaucoup d'objet je conseillerais de faire un minimum de parcours de sélections, c'est ce qui demande le plus de temps de traitement.

Ici tu parcours 2x toute la sélection alors qu'une seule suffit, sur nombre de plans ce n'est pas grave mais quand tu atteindra les 1000 ou 10000 objet ça le deviendra!

[x_all]

oups... les chantiers que je gère font beaucoup moins de 1000 objets...

mais je retiens l'idée.. ç vrai que je me suis contenté de rabouter 2 programmes et du coup c'est carrément pas optimisé.

 

mais toutes les bonnes choses ont une fin, le temps cette denrée si précieuse n'est plus de mon coté....

 

je garde tout ça sous le coude mais rien qu'avec ce qui est déja là je vais gagner pas mal de temps...

 

restera les épaisseurs à traiter, pour le prochain épisode....

[alala]

L'épaisseur est globale sur les polylignes ou sur chaque tronçon de polyligne?

Tu peu regarder ce que donne les propriétes de tes polylignes via Vlax-dump-object et si tu en a une qui correspond un vlax-get-property te donnera l'info pour chaque objets.

 

Dans ce cas il ne restera qu'a compter les objets ou les longueurs par epaisseur suivant ton besoin.

Tu a presque tout pour y arriver .. si tu a un peu de temps ;).

 

 

ps : en semaine prochaine j'aurai un autocad sous la main je pourrais éventuellement te faire ça en partie.

[bryce]

Bonjour,

 

Si l'épaisseur est constante, c'est (vla-get-constantwidth obj). ;)

[x_all]

oui l'épaisseur est constante pour une polyligne, en fait ça me permet dans un même calque de différencier les diamètre de canalisations... ce qui fait que les buses en 500 ont une ep de .5, celle de 300 .3 ect... sauf pour les branchements qui sont sans épaisseur...

 

je pense que quand elle sera fini, cette routine fera gagner pas mal de temps à beaucoup de monde car 99% des métrés sont à base de longueurs et de surfaces qu'on peu facilement trier dans des calques.

Jouer avec les épaisseurs de polyligne permet dans un seul calque de différencier plusieurs type d'éléments car créer un calque par type de tuyau finirai par être un peu lourd...

 

 

merci pour les "éléments de langage" .... suite au prochain creux dans mon activité débridée

[alala]

(defun c:m-vrd ( / ss surfb totb layb l_layb lstb longa tota laya l_laya ll_laya lsta epesa message)
(vl-load-com)
(setq totb 0)
(setq tota 0)
(setq message "")

(setq ss (ssget '((-4 . "<OR")
                  (0 . "LINE,LWPOLYLINE")
                  (-4 . "<AND")
                  (0 . "POLYLINE")
                  (-4 . "<NOT")
                  (-4 . "&")
                  (70 . 112)
                  (-4 . "NOT>")
                  (-4 . "AND>")
                  (-4 . "OR>")
                  )
                )
)

(if ss
	(vlax-for pl (setq ss (vla-get-ActiveSelectionSet
						(vla-get-ActiveDocument
							(vlax-get-acad-object)))) ;pour chaque objet de la sélection
		(if (vlax-curve-isClosed pl) ; si fermé
			(progn ;pour les polylignes fermés
				(setq surfb (vlax-curve-getArea pl))
				(setq totb  (+ totb surfb))
				(setq layb  (vla-get-Layer pl))
				(if (setq l_layb (assoc layb lstb))
						(setq
								lstb (subst (cons layb (+ surfb (cdr l_layb))) l_layb lstb)
						)
						(setq lstb (cons (cons layb surfb) lstb))
				)
			)
			(progn ;pour les polylignes ouvertes
				(setq longa (vlax-curve-getDistAtParam
												pl
												(vlax-curve-getEndParam pl)
										 ))
				(setq tota  (+ tota longa))
				(setq laya  (vla-get-Layer pl))
				(setq epesa (* (vla-get-constantwidth pl) 1000))
				(if (setq l_laya (assoc epesa(cdr(assoc laya lsta))))
					(setq lsta (subst (cons laya (subst (cons epesa (+ longa (cdr l_laya))) l_laya (cdr(assoc laya lsta)))) (assoc laya lsta) lsta))
					(if (setq ll_laya(assoc laya lsta))
						(setq lsta (subst (cons laya (append (list (cons epesa longa)) (cdr (assoc laya lsta)))) ll_laya lsta))
						(setq lsta (cons (cons laya (list (cons epesa longa))) lsta))
					)
				)
			)
		)
	)
)
				
(if lsta
	(mapcar
		'(lambda (x) 
				(progn
					(setq message (strcat message "\nLongueurs sur le calque "(car x)" : \n"))
					(mapcar 
						'(lambda (x)
							(setq message
								(strcat message "Diamètre " (rtos (car x)) " : "
								(rtos(cdr x))
								"m\n")
							)
						)
						(cdr x)
					)
				)
		)
		lsta
	)
	(setq message
		(strcat message "\nLongueur totale dans le plan = " (rtos tota) "m")
	)
)
(if lstb
	(mapcar '(lambda (x)
							   (setq message (strcat message "\nSURFACE totale sur le calque "
															  (car x)
															  " : "
															  (rtos (cdr x))
															  "m²"
											  )
							   )
							 )
							lstb
	)
	(setq message
		(strcat message "\nSURFACE totale dans le plan = " (rtos totb) "m²")
	)
)

(princ message)

(initget "Oui Non")
(if (= (getkword "\nEnregistrer dans un fichier ? [Oui/Non] <Non>: ") "Oui")
    (progn
	(setq fic (strcat (getvar "DWGPREFIX") (getvar "DWGNAME")))
	(setq fic (substr fic 1 (- (strlen fic) 4)))
	(setq f (open (strcat fic ".txt") "w"))
	(princ (strcat "\nOui!!! -> Ecriture du rapport " fic ".txt"))
	(princ "Métrés des réseaux du plan : \n" f)
	(princ (getvar "DWGNAME") f)
	(princ (strcat "\nRéalisé le "(substr (rtos (getvar "CDATE") 2 2 ) 7 2) "/" (substr (rtos (getvar "CDATE") 2 2 ) 5 2) "/" (substr (rtos (getvar "CDATE") 2 2 ) 1 4) "\n\n" ) f)
	(princ message f)
	(close f)
	)
)
(princ)
(textscr)
)

Ceci devrais répondre à tout cela?!

 

Avec en plus l'option de création d'un fichier texte en fin de routine.

 

Ce script est utile, mais uniquement si l'on a bien respecté les épaisseurs de polylignes.

Malheureusement je croise trop souvent des indication textuelles sur les réseaux et aucune épaisseur globale.

[x_all]

wha houuuu

 

what a surprise !!!

 

je suis de retour d'un épuisant long week end de ramassage des olives (2eme et dernier W.E. de sacrifice à une tradition familiale bien provençale ) et que vois-je ??

 

super super merci :)

ça marche super bien ... c'est vraiment LA routine pour faire mes métrés en 2x2 et même en 4x4...

 

Ce script est utile, mais uniquement si l'on a bien respecté les épaisseurs de polylignes.

Malheureusement je croise trop souvent des indication textuelles sur les réseaux et aucune épaisseur globale.

 

Je vais faire sur mon mini site une page consacrée au DCE... voir APD, qui sont les deux phases ou on à besoin de métrés...

j’écris aussi des indications de réseau en mode texte, mais on ne peux pas tout écrire et une légende précise est souvent garante de plus d'informations,... de plus avec des épaisseurs le dessin est plus lisible. Et si en plus les épaisseurs servent à faire un métré en une commande (+ un "bcnt" pour les objets il est vrai) peut être faut il s'y mettre?

 

je ne suis pas aussi rigoureux sur le ep .20=diamètre 200 ect,

en fait tout le truc est dans la lisibilité de la légende imprimée. Dans un seul calque avec un type de ligne on peu aller jusqu’à 4 diamètres différents. En épaisseur papier ça donne 0.2, 0.4, 0.8, 1.6... il faut un peu forcer les échelle de type de ligne pour que ça reste joli...les épaisseurs dépendent donc aussi de l’échelle de sortie du dessin.

Ca tombe bien, j'ai rarement plus de 4 diamètres sur un réseau.. si c'est le cas je rajoute un calque et type de ligne par exemple j'ai le calque 'EP' et le calque 'ET' pour eaux pluviale et eaux de toiture (les EP sont pratiquement le seul cas ou ça m'arrive de temps en temps)

il suffit donc dans sa légende de créer les 4 polylignes et avec la commande 'recopie les propriété' ça va super vite pour mettre en forme son réseau.

 

Mais les épaisseur me servent aussi pour les réseau FT ou j'ai une épaisseur entre chambre de tirage (5x42/45) et une entre la chambre et le particulier (2 ou 3 x 42/45). Pareil pour l'ERDF ou on a différentes section de câble

bref les épaisseurs sont vraiment utile et pour la lisibilité du dessin et pour nous faciliter la vie pour faire les métrés grâce à ta routine fabuleuse..

 

Encore merci tout plein :)

[alala]

De rien, pour ce qui est de la pertinence des épaisseurs de type de ligne, tu préche un convaincu!

Je suis même persuadé que des Xdata ou des données d'objet MAP sont impératives pour faire un métré complet avec types de canalisation en prime.

 

Pour la routine j'ai fait un bête x1000 (comme indiqué au dessus).

Tu peu modifier cette ligne pour adapter :

 

(setq epesa (* (vla-get-constantwidth pl) 1000))

Voir faire un Getreal pour changer la valeur à chaque debut de routine.

 

Pour le reste si tu a besoins de détails sur le code et son fonctionnement, n'hésite pas à demander.

[x_all]

Pour le reste si tu a besoins de détails sur le code et son fonctionnement, n'hésite pas à demander.

 

en ce jour de reprise, c'est un peu le feu, mais je risque d'abuser de ta proposition...

je me faisait des films algorithmique en ramassant les olives et je vois que tu n'a pas pris du tout la structure que je pressentais...

 

je sais que le langage induis la forme d'un programme et la pensée du programmeur... les langues vivantes, il vaux mieux les apprendre jeunes, et j'ai du mal avec lisp.

Quand j’arrive à lire, je suis souvent complètement épaté par la concision et la richesse du lisps... mais du coup, quand en plus je dois chercher chaque instruction dans l'aide... c'est pas facile de suivre la logique...Un peu comme apprécier la beauté d'un Shakespeare quand on a que de vague notion d'anglais et un vocabulaire ultra pauvre

 

je vais essayer par moi même ce sera formateur, et je reviendrai vers toi sur les trucs qui ne manqueront pas de m'avoir échapper...

[lecrabe]

Hello

 

J'ai fais une micro-modif pour ne traiter QUE les Polylignes

 

Sinon petit test sous AutoCAD MAP 2013 ... C OK

 

En fin de routine, j'ai decouvert une micro-micro-erreur :

; erreur: type d'argument incorrect: streamp nil

sur la generation du rapport alors que j'ai dis NON !

 

J'ai trouve, il faut TAPER "N" et non pas "n"

 

Encore Merci, Cette routine peut s'averer fort utile, lecrabe

[alala]

En remplacement de :

(setq ecriremessage (getkword "\n\nVoulez vous écrire un rapport? (Oui ou Non) "))

Ceci devrais fonctionner :

(while (not ecriremessage)
(setq ecriremessage (getkword "\n\nVoulez vous écrire un rapport? (Oui ou Non) "))
(princ "\nChoisir Oui ou Non!")

 

 

Et effectivement dans le cadre de la reprise de plan de provenance diverse il sera plus intéressant de choisir cette méthode de sélection de VDH-Bruno (que je remerci encore une fois au passage pour toute son aide) :

 

(setq ss (ssget '((-4 . "<OR")
                  (0 . "LINE,LWPOLYLINE")
                  (-4 . "<AND")
                  (0 . "POLYLINE")
                  (-4 . "<NOT")
                  (-4 . "&")
                  (70 . 112)
                  (-4 . "NOT>")
                  (-4 . "AND>")
                  (-4 . "OR>")
                 )
         )
)

[VDH-Bruno]

Bonjour,

 

En fin de routine, j'ai decouvert une micro-micro-erreur :

; erreur: type d'argument incorrect: streamp nil

sur la generation du rapport alors que j'ai dis NON !

 

J'ai trouve, il faut TAPER "N" et non pas "n"

Après une rapide lecture en diagonale du code, il me semble que l’erreur vienne du (close f) qui est mal positionné dans le code (en dehors du progn) et qui n’est donc pas initialisé..

 

Résultat de close si le f vaut nil

$ (close f)
; erreur: type d'argument incorrect: streamp nil

 

 

alala ta séquence avec le (initget 1 "Oui Non") était bonne, bit 1 pour les saisie null et Oui Non pour les réponses (majuscule, minuscule avec caractère minimum).

 

Même si dans ce cas de figure on pouvait s’affranchir de la variable ecriremessage (car seul oui nous interresse), comme ceci par exemple:

(initget "Oui Non")
(if (= (getkword "\nEnregistrer dans un fichier ? [Oui/Non] <Non>: ") "Oui")
    (princ "\nOui!!! -> Lance la fonction d'écriture du rapport")        
)

 

(Ps : Au cas où le [Oui/Non] renseigne le menu contextuel)

 

A+

[bonuscad]

Un truc qui me choque à la lecture du code (je ne l'ai pas testé), est que si on choisi "Non", la routine va tenter de fermer un fichier qui n'a pas été ouvert: (close f) est en dehors de la condition...

 

C'est d'ailleurs, peut être l'explication de l'erreur de lecrabe

; erreur: type d'argument incorrect: streamp nil

sur la generation du rapport alors que j'ai dis NON !

[alala]

J'ai corrigé tout cela dans mon dernier message!

 

Merci a vous tous pour ce retour d'erreur et la correction qui en résulte.

 

J'ai fait ça un poil vite, faudra que je passe plus de temps à tester à l'avenir.

[VDH-Bruno]

J'ai fait ça un poil vite, faudra que je passe plus de temps à tester à l'avenir.

Pas de soucis, c’est un forum d’entraide,donc même si il y a un ou deux petits disfonctionnements à la marge, c’est déjà beaucoup de prendre sur ton temps pour faire un code pour d'autres.

Et à lire la réaction enthousiaste de x_all, cela allait déjà au-dessus de sa demande initiale. :)

 

A+