Blocs dynamique avec mise en réseau ... particulière

[(gile)]

... je ne sais pas programmer dans ce langage...

 

Je vais le prouver : Je ne sais même pas commencer appeler le programme de Gile... :(

 

Regarde ce sujet.

[BixenteLiz]

Je vais peut être dire encore une bêtise.

 

Si ton mur fait 50 m de long et que sur pratiquement la totalité tu mets des 240, pourquoi ne pas déjà utiliser la commande Mesurer avec ton bloc de 240 pour les positionner sur la polyligne.

 

Ensuite pour le final tu utilise un bloc dyn avec paramètre de visibilité qui contient les 240+120, 240+90, 240+60 etc.

 

 

C'est ce que je fais aujourd'hui, le problème est que le cas que je vous ai mis ici est extrêmement simplifié (même un local poubelle aurait une structure plus complexe que celle là ! )

 

Lorsque je doit placer des blocs manuellement sur 2000m ou 3000m de mur, ça prend très vite du temps. Je cherche donc une solution "tout auto".

 

La solution qui me ferait rêver :

1. je pointe la polyligne

2. je saisie l'épaisseur du mur

3. je dis si le mur et bloqué ou libre

4. ...j'admire le résultat et je gagne un temps dingue sur une journée ...! :D

 

 

 

 

[BixenteLiz]

On définit une commande en LISP en faisant précéder le nom de la commande/fonction par c: au début de la routine, juste après (defun , exemple :

(defun c:toto (...))

Dans ce cas il suffit de taper à la ligne de commande : toto et de valider.

 

j'ai bien copié le code dans le bloc note, enregistré en tant que "toto.lsp", APPLOAD > toto.lsp > correctement chargé

 

je tape "toto" dans la ligne de commande > Commande inconnue "TOTO". Appuyez sur F1 pour obtenir de l'aide.

 

Pardon pour mon incompétence dans le domaine du lisp...

 

[Edité le 4/6/2010 par masterdisco]

[BixenteLiz]

Bon il semble que ce soit mon AutoCAD qui déconne, je n'ai plus aucun lisp qui fonctionne ...

[lili2006]

Re,

 

Non, sinon je n'aurais pas fait de LISP.

 

Peut-être que quelque chose m'avait échappé,...

[(gile)]

masterdisco,

 

Le LISP que j'ai donné plus haut essayait juste de répondre à ta première demande (pas très précise).

Il ne fonctionnera pas correctement avec le type de dessin que tu as mis en lien qui est en mètres alors que les longueurs de banches sont exprimées en centimètres, il ne traiterait que les "murs bloqués", etc.

 

Au vu de tes demandes plus précises et de fichier joint, il est tout à fait possible de faire quelque chose qui réponde exactement à ta demande (voir plus).

 

Contacte moi par MP ou ici :

 

chanteau point gilles chez orange point fr

[BixenteLiz]

Bonjour à tous,

 

J'ai réparé mon AutoCAD, tout fonctionne à nouveau j'ai donc pu testé la solution de Gile,

 

Il s'agit là d'un bon début, j'ai donc essayé de l'agrémenter pour obtenir ce que je souhaite mais ne connaissant pas le langage Lisp, je ne parviens pas à créer le programme "idéal" décrit précédemment... J'aurais vraiment besoin d'un coup de main SVP...

[(gile)]

Salut,

 

Au vu des informations plus précises et du fichier mis en ligne, il est possible de faire quelque chose de plus efficace. Il est par exemple inutile de créer un nouveau bloc contenant des blocs imbriqués à chaque insertion.

 

Comme ta demande est spécifique et que je pense que la routine que je te donne peut te faire gagner beaucoup de temps, j'ai un peu hésité à te donner une solution toute faite.

Tu as de la chance, je suis dans un bon jour.

 

Il est certainement possible d'aller beaucoup plus loin dans l'automatisation de ce type de travail, je suis près à étudier toute demande, mais moyennant rémunération.

 

(defun c:Bancher
      (/ *error* foo1 foo2 pl ep fr ins pt len lst rot blk names)
 (vl-load-com)
 (or *acdoc*
     (setq *acdoc* (vla-get-ActiveDocument (vlax-get-acad-object)))
 )
 (or *wallwidth* (setq *wallwidth* 0.2))

 (defun *error* (msg)
   (and msg
 (/= msg "Fonction annulée")
 (princ (strcat "Erreur: " msg))
   )
   (vla-EndUndoMark *acdoc*)
   (princ)
 )

 (defun foo1 (len)
   (cond
     ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      (T (cons 240 (foo1 (- len 240))))
   )
 )

 (defun foo2 (len)
   (cond
     ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      (T (cons 240 (foo2 (- len 240))))
   )
 )

 (setq	names '((40 . "B40x2")
	(60 . "B60x2")
	(90 . "B90x2")
	(120 . "B120x2")
	(240 . "B240x2")
       )
 )
 (if (setq ss (ssget '((0 . "LWPOLYLINE") (8 . "J*- Mur"))))
   (progn
     (if (setq	ep
	 (getdist
	   (strcat "\nEpaisseur du mur : ")
	 )
  )
(setq *wallwidth* ep)
(setq ep *wallwidth*)
     )
     (initget 1 "Bloqué Libre")
     (setq fr (getkword "\nSpécifiez une option [bloqué/Libre]: "))
     (vla-StartUndoMark *acdoc*)
     (vlax-for	pl (setq ss (vla-get-ActiveselectionSet *acdoc*))
(setq ins (vlax-curve-getStartPoint pl)
      pt  (vlax-curve-getPointAtParam pl 1)
      len (distance ins pt)
      rot (angle ins pt)
      lst (if (= fr "Bloqué")
	    (foo1 (* 100 len))
	    (foo2 (* 100 len))
	  )
      vec (polar '(0. 0. 0.) rot 0.01)
)
(while (setq n (car lst))
  (setq	blk
	    (vla-InsertBlock
	      (vla-get-ModelSpace *acdoc*)
	      (vlax-3d-point ins)
	      (cdr (assoc n names))
	      1.0
	      1.0
	      1.0
	      rot
	    )
	ins (mapcar '+ ins (mapcar '* vec (list n n n)))
	lst (cdr lst)
  )
  (vla-Move
    blk
    (vlax-3d-point ins)
    (vlax-3d-point (polar ins (- rot (/ pi 2.0)) (/ ep 2.0)))
  )
  (foreach p (vlax-invoke blk 'GetDynamicBlockProperties)
    (if	(= (vla-get-PropertyName p) "Ep")
      (vla-put-Value p ep)
    )
  )
)
     )
     (vla-delete ss)
   )
 )
 (*error* nil)
)

 

 

[BixenteLiz]

>> Gile : MERCI !

 

C'est énorme, il faut vraiment que j'arrive à me plonger dans la programmation lisp, ca va me faire gagner un temps dingue. Je comprends parfaitement votre position en me proposant une mission rémunérée, mais pour l'instant cette solution me conviens bien. En tout cas un énorme merci d'avoir pris le temps de m'aider (et pardon de demander une solution toute faite, je sais que cela est à la limite du correct mais je n'ai vraiment aucune base...)

 

Merci beaucoup !

[BixenteLiz]

Re bonjour,

 

Gile, je viens de travailler avec votre code. Les murs bloqués fonctionnent bien, c'est sur les murs libres que je trouve étonnant certains résultats.

 

Exemple ; cas d'un mur LIBRE d'une longueur de 4.82cm :

 

Résultat : 2.40 + 1.20 +0.90 + 0.40

> Comment faire pour que le résultat soit plutôt 2.40 + 2.40 + 0.40 ?

 

Il est vrai que je n'ai peut être pas bien expliqué le coup des "murs libres".

Il est préférable que les banches dépassent un peu du mur (entre 10cm et 30cm de part et d'autre).

 

Avec Lml = Longueur du mur libre et Lbanches = longueur totale de l'assemblage

Il faudrait donc que :

Lmb + (0.10x2) <= Lbanches <= Lmb + (0.30x2)

 

Il faut savoir qu'une banche = 1 certain temps de mise en place.

Du coup, assembler 2.40 + 1.20 + 0.90 + 0.40 demande plus de travail que d'assembler 2.40 + 2.40 + 0.40.

 

Comment puis-je intégrer cette contrainte dans le calcul des éléments et priviligier les assemblages avec le moins d'éléments possible ? (pour les murs LIBRES uniquements, je le rappelle)

 

Merci pour votre aide...

 

[Edité le 7/6/2010 par masterdisco]

[(gile)]

Salut,

 

Remplace la sous routine foo2 par celle-ci :

 

(defun foo2 (len)
   (cond
     ((      ((      ((      ((      ((      ((      ((      (T (cons 240 (foo2 (- len 240))))
   )
 )

[BixenteLiz]

Merci beaucoup Gile. Je me remets au travail avec cette nouvelle routine pour tester ça !

 

[BixenteLiz]

Bonjour à tous,

 

Gile : J'ai donc essayé la nouvelle version du code et il semblait y avoir une erreur dans le calcul.

 

Cas d'un mur d'une longueur de 2,16m, libre :

>> Sont placées 2 banches de 120 par le programme. Pourquoi le résultat d'abouti pas à 1 banche de 240 ?

 

J'ai donc changé dans foo2 :

 

 ((<= len 220) (cons 120 (foo2 (- len 120)))) 

 

par :

((<= len 210) (cons 120 (foo2 (- len 120)))) 

 

Et cela semble marcher.

 

Voila c'était juste pour vous tenir informé si quelqu'un utilise le code par la suite.

Encore merci.

[(gile)]

Tu peux même descendre à 190, sinon tu auras encore 2 x 1.20 pour un mur entre 1.90 et 2.10 :

((
 
Mais l'essentiel c'est que tu aies compris et que tu arrive à modifier le code, bravo.

[BixenteLiz]

Re,

 

Oui je me suis rendu compte qu'il fallait descendre à 190, j'ai donc fait le même modification que toi, je venais justement pour la poster ! :D

 

Merci beaucoup gile, je pense que ce petit bout de code que vous m'avez donné va m'inciter à me plonger dans le LISP.

 

Par contre j'ai une question mais qui n'a rien à voir avec mon problème. J'ai vu que le VBA a été supprimé d'AutoCAD 2010 (je l'ai rajouté avec le patch d'autodesk). J'ai pu lire par ailleurs qu'au delà d'AutoCAD, c'est le VBA tout court qui va disparaitre. Cela m'ennuie, c'est le seul code de programmation que je maitrise. Est ce que le LISP va également disparaitre dans les prochaines années ou est ce que je peux me lancer dans l'apprentissage de ce code et espérer en tirer profit pendant un petit moment sans crainte de le voir disparaitre ?

[(gile)]

Salut,

 

VBA va disparaître parce que Microsoft l'abandonne (en fait ne veut pas le porter aux processeurs 64 bits).

AutoLISP ne dépend pas de Microsoft et Autodesk n'a aucune raison (ni intention à ce jour) de l'abandonner.

AutoLISP va donc devenir le seul langage de programmation "facilement accessible" pour programmer AutoCAD.

Il serait donc, à mon avis, suicidaire de la part d'Autodesk d'abandonner AutoLISP dont ils ont l'entière maitrise.

[BixenteLiz]

Merci pour ces précisions !

[BixenteLiz]

Gile,

 

Je me suis bien pris au jeu de la programmation vu le temps que ca me fait gagner. J'aimerais donc introduire une nouvelle donnée pour la réalisation des murs bloqués uniquement.

 

On s'aperçoit qu'il reste parfois plusieurs centimètres sur lesquels ne se trouvent pas de banche. Il manque donc un coffrage à ce niveau là.

Nous possédons deux autres matériels, des règles ajustables, qui permettent de combler ces manques. Ce sont des banches qui coulissent contre les autres, avec une infinité de dimensions possible dans un intervale donné.

 

1er type : R0.02-0.09

Permet de coffrer de 2cm à 9.99cm

 

2ème type : R0.10-0.30

Permet de coffrer de 10cm à 30cm compris

 

Il s'agit donc d'insérer un nouveau type de banche, selon le même principe que les 240; 120; 90 etc. sauf que cette fois ci elle ne peut être placée qu'à l'extrémité de l'assemblage.

 

de plus, il s'agit de blocs dynamiques avec un paramètre de distance "Lg" qui correspond à la longueur du manque.

 

MA QUESTION :

Comment puis-je récupérer le delta entre la longueur de l'assemblage et la longueur du mur, et le répercuter sur la valeur de Lg dans mon bloc dynamique ?

 

Du coup :

 

Si delta < 2cm >>> ne rien faire

 

Si 2cm <= delta < 0.10 >>> Insérer le bloc "R0.02-0.09" avec un paramètre "Lg" = delta

 

Si 10cm <= delta <= 0.30 >>> Insérer le bloc "R0.10-0.30" avec un paramètre "Lg" = delta

 

 

Merci pour votre aide

 

[Edité le 8/6/2010 par masterdisco]

[BixenteLiz]

J'ai essayé ceci mais évidemment ça ne marche pas (le contraire m'aurait vraiment étonné).

 

 ;-------------------------------------------

(defun c:Coffrer

      (/ *error* foo1 foo2 pl ep fr ins pt len lst rot blk names)

 (vl-load-com)

 (or *acdoc*

     (setq *acdoc* (vla-get-ActiveDocument (vlax-get-acad-object)))

 )

 (or *wallwidth* (setq *wallwidth* 0.2))



 (defun *error* (msg)

   (and msg

 (/= msg "Fonction annulée")

 (princ (strcat "Erreur: " msg))

   )

   (vla-EndUndoMark *acdoc*)

   (princ)

 )



 (defun foo1 (len)

   (cond

     ((<= len 2) nil)

     ((<= len 10) '(9))
     
     ((<= len 30) '(30))

     ((< len 60) '(40))

     ((< len 80) '(60))

     ((< len 90) '(40 40))

     ((< len 100) '(90))

     ((< len 120) '(60 40))

     ((< len 130) '(120))

     ((< len 150) '(90 40))

     ((< len 160) '(90 60))

     ((< len 240) (cons 120 (foo1 (- len 120))))

     ((< len 250) '(240))

     ((< len 280) (cons 120 (foo1 (- len 120))))

     (T (cons 240 (foo1 (- len 240))))

   )
   
 )





(defun foo2 (len)

   (cond

     ((< len 0) nil)

     ((<= len 20) '(40))

     ((<= len 40) '(60))

     ((<= len 70) '(90))

     ((<= len 100) '(120))

     ((<= len 140) (cons 120 (foo2 (- len 120))))      	

     ((<= len 190) (cons 120 (foo2 (- len 120)))) 

     ((<= len 230) '(240))

     ((<= len 250) '(240 40))

     (T (cons 240 (foo2 (- len 240))))

   )

 )



 (setq	names '((40 . "B40x2")

	(60 . "B60x2")

	(90 . "B90x2")

	(120 . "B120x2")

	(240 . "B240x2")

	(9 . "R0.02-0.09")

	(30 . "R0.10-0.30")

       )

 )

 (if (setq ss (ssget '((0 . "LWPOLYLINE") (8 . "*"))))

   (progn

     (if (setq	ep

	 (getdist

	   (strcat "\nEpaisseur du mur <" (rtos *wallwidth*) ">: ")

	 )

  )

(setq *wallwidth* ep)

(setq ep *wallwidth*)

     )

     (initget 1 "Bloqué Libre")

     (setq fr (getkword "\nSpécifiez une option [bloqué/Libre]: "))

     (vla-StartUndoMark *acdoc*)

     (vlax-for	pl (setq ss (vla-get-ActiveselectionSet *acdoc*))

(setq ins (vlax-curve-getStartPoint pl)

      pt  (vlax-curve-getPointAtParam pl 1)

      len (distance ins pt)

      rot (angle ins pt)

      lst (if (= fr "Bloqué")

	    (foo1 (* 100 len))

	    (foo2 (* 100 len))

	  )

      vec (polar '(0. 0. 0.) rot 0.01)

)

(while (setq n (car lst))

  (setq	blk

	    (vla-InsertBlock

	      (vla-get-ModelSpace *acdoc*)

	      (vlax-3d-point ins)

	      (cdr (assoc n names))

	      1.0

	      1.0

	      1.0

	      rot

	    )

	ins (mapcar '+ ins (mapcar '* vec (list n n n)))

	lst (cdr lst)

  )

  (vla-Move

    blk

    (vlax-3d-point ins)

    (vlax-3d-point (polar ins (- rot (/ pi 2.0)) (/ ep 2.0)))

  )

  (foreach p (vlax-invoke blk 'GetDynamicBlockProperties)

    (if	(= (vla-get-PropertyName p) "Ep")

      (vla-put-Value p ep)

    )

    (if	(= (vla-get-PropertyName p) "Lg")

      (vla-put-Value p len)

    )

  )

)

     )

     (vla-delete ss)

   )

 )

 (*error* nil)

)

 

 

Je suppose mes modifs sont bourrées d'erreur de syntaxe... Si quelqu'un pouvais me corriger svp...

 

[Edité le 8/6/2010 par masterdisco]

[BixenteLiz]

J'ai réussi à placer automatiquement les bonnes réglettes réglables avec le code suivant :

 

   (defun foo1 (len)

   (cond

     ((< len 40) nil)
 
     ((< len 50) '(40 12))

     ((< len 60) '(40 32))

     ((< len 70) '(60 12))

     ((< len 80) '(60 32))
     
     ((< len 90) '(60 32))

     ((< len 92) '(90))
     
     ((< len 100) '(90 12))

     ((< len 110) '(90 32))

     ((< len 120) '(90 32))

     ((< len 122) '(120))

     ((< len 130) '(120 12))

     ((< len 150) '(120 32))

     ((< len 160) '(90 60 12))

     ((< len 170) '(120 40 12))

     ((< len 182) '(120 40 32))

     ((< len 190) '(120 60 12))

     ((< len 210) '(120 60 32))

     ((< len 212) '(120 90))

     ((< len 220) '(120 90 12))

     ((< len 230) '(120 90 32))

     ((< len 240) (cons 120 (foo1 (- len 120))))

     ((< len 250) '(240 12))

     ((< len 270) '(240 32))

     ((< len 280) (cons 120 (foo1 (- len 120))))

     (T (cons 240 (foo1 (- len 240))))

   )

 )

 

 

Maintenant comment puis-je faire pour attribuer au paramètre Lg de ces blocs la valeur /

Delta = [Longueur de la polyligne] - [Longueur totale de l'assemblage (hors réglette)] ??

[(gile)]

Je savais bien qu'en répondant à ce sujet, je mettais le doigt dans un engrenage.

 

Je pense avoir répondu avec le code ci-dessous aux différentes demandes successives.

 

J'arrêterai là même si je sais qu'on pourrait aller beaucoup plus loin. Mais pour une demande spécifique, j'en ai donné beaucoup plus que ce que je voudrais me fixer comme limite de ce qu'on peut donner gracieusement.

 

Je suis conscient que ce type de routine peut faire gagner énormément de temps à ceux qui l'utilisent, mais les développer demande aussi du temps qu'il serait normal de rémunérer...

 

;-------------------------------------------

(defun c:Coffrer
      (/ *error* foo1 foo2 pl ep fr ins pt len lst rot blk names)
 (vl-load-com)
 (or *acdoc*
     (setq *acdoc* (vla-get-ActiveDocument (vlax-get-acad-object)))
 )
 (or *wallwidth* (setq *wallwidth* 0.2))

 (defun *error* (msg)
   (and msg
 (/= msg "Fonction annulée")
 (princ (strcat "Erreur: " msg))
   )
   (vla-EndUndoMark *acdoc*)
   (princ)
 )

 (defun foo1 (len)
   (cond
     ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      ((      (T (cons 240 (foo1 (- len 240))))
   )
 )

(defun foo2 (len)
   (cond
     ((      ((      ((      ((      ((      ((      ((      ((      ((      (T (cons 240 (foo2 (- len 240))))
   )
 )

 (setq	names '((40 . "B40x2")
	(60 . "B60x2")
	(90 . "B90x2")
	(120 . "B120x2")
	(240 . "B240x2")
       )
 )
 (if (setq ss (ssget '((0 . "LWPOLYLINE") (8 . "*"))))
   (progn
     (if (setq	ep
	 (getdist
	   (strcat "\nEpaisseur du mur : ")
	 )
  )
(setq *wallwidth* ep)
(setq ep *wallwidth*)
     )
     (initget 1 "Bloqué Libre")
     (setq fr (getkword "\nSpécifiez une option [bloqué/Libre]: "))
     (vla-StartUndoMark *acdoc*)
     (vlax-for	pl (setq ss (vla-get-ActiveselectionSet *acdoc*))
(setq ins (vlax-curve-getStartPoint pl)
      pt  (vlax-curve-getPointAtParam pl 1)
      len (distance ins pt)
      rot (angle ins pt)
      lst (if (= fr "Bloqué")
	    (foo1 (* 100 len))
	    (foo2 (* 100 len))
	  )
      vec (polar '(0. 0. 0.) rot 0.01)
)
(while (setq n (car lst))
  (setq	name
	 (cond
	   ((cdr (assoc n names)))
	   ((		   (T "R0.10-0.30")
	 )
  )
  (setq	blk
	    (vla-InsertBlock
	      (vla-get-ModelSpace *acdoc*)
	      (vlax-3d-point ins)
	      name
	      1.0
	      1.0
	      1.0
	      rot
	    )
	ins (mapcar '+ ins (mapcar '* vec (list n n n)))
	lst (cdr lst)
  )
  (vla-Move
    blk
    (vlax-3d-point ins)
    (vlax-3d-point (polar ins (- rot (/ pi 2.0)) (/ ep 2.0)))
  )
  (foreach p (vlax-invoke blk 'GetDynamicBlockProperties)
    (if	(= (vla-get-PropertyName p) "Ep")
      (vla-put-Value p ep)
    )
    (if	(= (vla-get-PropertyName p) "Lg")
      (vla-put-Value p (/ n 100.))
    )
  )
)
     )
     (vla-delete ss)
   )
 )
 (*error* nil)
)

[BixenteLiz]

Bonjour,

 

Effectivement tout semble convenir, j'ai pu tester rapidement ce matin.

Il est vrai que j'en ai demandé beaucoup sur ce fil, j'en suis parfaitement conscient. Je tiens juste à dire qu'il s'agissait vraiment des point sur lesquels je bloquais, j'ai réellement essayé de me débrouiller par moi même, mais n'ayant aucune base, forcément mes limites sont vites atteintes...

 

Il y a deux ans je me suis lancé dans la programmation VBA sur Excel, de la même manière, c'est à dire en autodidacte et en n'ayant aucune connaissance en programmation. J'ai fais tout mon apprentissage sur le forum XLD. Au début, les gens se plaignait de mes demandes qu'ils jugeaient excessives. Aujourd'hui je suis un membre actif de ce forum, et tant que possible j'aide les membres débutants.

 

Tout ca pour dire que vos efforts n'ont pas servi à rien Gile, non seulement ils me permettent de gagner du temps mais ils vont peut être à terme me permettre d'aider les autres à mon tour...

 

[(gile)]

Salut,

 

Il n'y a aucune animosité à ton égard dans mes propos.

 

C'est juste que la demande est suffisamment complexe par rapport à ton niveau en LISP pour qu'il soit plus rapide pour moi de donner un code tout fait que de me lancer dans des explications pour le modifier.

[BixenteLiz]

Il est vrai que pour un premier projet en LISP j'ai peut être vu un peu haut. En fait le LISP s'est imposé à moi cette fois ci, à la base je cherchais une solution par blocs dynamiques.

 

Pour mes prochaines requêtes sur un problème de LISP, j'essaierai de faire en sorte que le projet soit moins ambitieux, afin de pouvoir en faire le plus possible par moi même, comme ça cela donnera moins l'impression que j'arrive en demandant un solution clé en main, car je le redis, je ne demandais pas une solution clé en main, je demandais juste de l'aide...

 

En tout cas merci pour tout, la solution finale me conviens très bien, j'en suis vraiment satisfait, et votre implication Gile dans mon projet est à la hauteur du gain de productivité qui en découle.

 

A +

 

[Edité le 9/6/2010 par masterdisco]

[BixenteLiz]

Bonjour tous le monde,

 

je déterre mon topic car je souhaite apporter une petite modif sur le programme que gile a conçu à l'époque (je le remercie encore pour cela).

 

Nous avions parlé de mur libre et de mur bloqué. J'aimerais ajouter une troisième notion : mur "en appui".

 

Je souhaiterais donc avoir ces 3 options :

- Mur libre (mur complètement libre, ni coincé entre deux autres, ni en appui contre un autre.)

- Mur en appui (mur libre d'un côté, mais venant se coller à un mur déjà réalisé de l'autre)

- Mur bloqué (mur coincé entre deux autres déjà réalisés)

 

Je m'explique. Aujourd'hui lorsque je choisis l'option "Mur libre", mes banches sont placées avec un débord, mais celui-ci se trouve intégralement du côté du point d'arrivée du premier segment de polyligne, c'est à dire que mon premier bloc est aligné avec le premier point. Le calcul actuel du "mur libre" deviendrait donc "mur en appui".

 

Je souhaite donc créer le troisième code correspondant aux nouveau calcul de "mur libre". Le calcul de la composition ne diffère pas de calcul des "murs en appui", les compositions issues de ce calcul doivent être les mêmes, j'aimerais simplement que l'écart entre la longueur de l'assemblage et la longueur du mur (débord) soit réparti de part et d'autre du mur (1/2 débord à gauche et 1/2 débord à droite). Je n'ai pas compris la partie du code correspondant au placement des blocs...

 

merci d'avance pour votre aide, et merci à Gile s'il passe par ce topic...