offset sur polyligne 3D

[Tramber]

Je suis d'accord pour considérer que si il y a un décaler Vertical ou horizontal, ca ne peut être qu'une vulgaire copie.

 

Un vrai "décalage" dans l'espace comme on l'entend est forcemment plus complexe et pose des questions.

[Concombre_masque]

, peut-être un "fort en decro" pourait confirmer (à l'aide Concombre_masqué !).

 

J'ai rien compris à tout le thread :P

[(gile)]

J'ai rien compris à tout le thread

 

Eh bien, moi qui doit donner mon premier cours de dessin technique et géométrie descriptive à la rentrée, je crois que j'ai du boulot si je veux me faire comprendre par des profanes :(

[couma-co]

Je suis d'accord pour considérer que si il y a un décaler Vertical ou horizontal, ca ne peut être qu'une vulgaire copie.

 

Un vrai "décalage" dans l'espace comme on l'entend est forcemment plus complexe et pose des questions.

 

Ben pas tout a fait, il y a simplement un décalage de l'image de la polyligne 3d dans le SCU choisi, ici vertical ou horizontal, une copie d'une sinusoidale ferait se chevaucher la polyligne et sa copie, or là il y a decalage 2D d'une polyligne 3D, par contre dans un des plan il s'agira en effet d'une copie, mais pour la topo, c'est exactement ce qu'il faut pour créer des mur 3D, le décaler qui vous pose problém ici, c'est un "decaler" qui crée une elipsoide, mais même pour l'exemple de l'escalier, je maintient qu'il s'agit d'un decalage de l'image 2D en plan puis d'une copie verticale, car à la réalisation materiel de l'objet, il me semble compliqué de construire une forme d'elice pour un escalier!

Sinon sans reference plan, je ne vois pas comment faire decaler une poly ligne 3D car le côté à decaler est lui même désigné selon un plan.

Et une fois encore, pouquoi autocad ne le fait-t-il pas!!! :hallucine:

 

[Tramber]

Alors un "décaler" normal si je regarde le plan XY et je ré-injecte les Z correspondant de chaque point d'origine. Là c'est possible et mathématiquement sans ambiguïté.

[(gile)]

Salut Concombre_masqué,

 

Ton message est illisible (en tout cas chez moi) peut--être un problème de bbcode ou de smiley.

 

[Edité le 21/7/2006 par (gile)]

[couma-co]

pour moi oui, sauf que à part la copier, la coller au même endroit, l'applatir pour la transformer en 2D, la decaler et la redessiner en 3D en réafectant les Z manuellement, je vois pas comment faire + simple?!? :mad2:

d"'ailleur si quelqu'un à une autre solution, j'suis preneur :thumbup:

[Concombre_masque]

Salut Concombre_masqué,

 

Ton message est illisible (en tout cas chez moi) peut--être un problème de bbcode ou de smiley.

 

[Edité le 21/7/2006 par (gile)]

 

Je sais pas ce qui y a. Je disais donc:

 

Je suis prof de traçage. Tu as effectivement du soucis à te faire car l'enseignement de la descriptive est délicat car c'est un peu compliqué pour ceux qui n'ont pas l'habitude de "voir" dans l'espace. A ceci tu ajoutes le fait que tes cours trouvent rarement un vif intéret de la part des eleves... Tu comprends la suite.

 

En plus, dans ce thread, ils débatent de programmation pour faciliter le tout :o

[(gile)]

Merci,

 

Heureusement pour moi, il s'agit plus de dessin techinque que de géométrie descriptive, et ce, dans le cadre d'une formation professionnelle pour adultes (à priori consentants, voire motivés).

[Concombre_masque]

voire motivés.

 

ne te fais pas trop d'illusions. Surtout si la sale est climatisée... :casstet:

 

Mais j'espère pour toi que je fais juste la bouche de vieille. Si tu as besoin de cours de descro pure j'ai peu de trucs mais je pense assez bien fait (position du point dans les plans frontal et horizontal / 7 position remarquables de la droite...) ensuite je lache la descro pour du tracage de volume: developpement de cylindre coupé par un plan, intersection, pyramide, prisme, surface composée.... C'est légerement plus interessant

[(gile)]

Merci pour tes propositions, mais comme il s'agit de remplacer un formateur qui s'en va, les support de cours existent déjà.

[bonuscad]

Voici un lisp sans aucune prétention, car imparfait, qui est dans cette optique évoqué par Tramber:

 

Alors un "décaler" normal si je regarde le plan XY et je ré-injecte les Z correspondant de chaque point d'origine. Là c'est possible et mathématiquement sans ambiguïté.

 

Il est relativement facile de monter un lisp de ce type, mais car il y a un MAIS.

Lors d'un décalage, si l'interdistance entre sommets est inférieure à la distance de décalage, certain sommets sont supprimés pour obtenir un nouveau sommet calculé.

Ce cas de figure pose un problème, le sommet pourrait être identifié, mais le code s'en trouverait énormément alourdi.

 

Voilà les limitations du code suivant (vous en serez averti). Une PMaille est proposée si ce décalage est exact.

 

(defun pm_dec (lpo lpn / l n1 n2)
(setq l (append lpo lpn) n1 1 n2 (length l))
(command "_pface")
(repeat (* 2 (length lpo))
	(command (car l))
	(setq l (cdr l))
) 
(command "")
(repeat (1- (length lpo))
	(command n1)
	(setq n1 (1+ n1))
	(command n1)
	(command (1- n2))
	(command n2)
	(setq n2 (1- n2))
	(command "")
) 
(command "")
)
(defun m_lpl (ent / l l1 x y z)
(setq l_2d '() l_3d '())
(setq l (entget (car ent)))
(if (eq (cdr (assoc 0 l)) "LWPOLYLINE")
	(setq l_2d (mapcar 'cdr (vl-remove-if '(lambda (x) (/= (car x) 10)) l)))
	(progn
		(setq l1 (entget (entnext (cdr (assoc -1 l)))))
		(while (/= "SEQEND" (cdr (assoc 0 l1)))
			(setq
				x (cadr (assoc 10 l1))
				y (caddr (assoc 10 l1))
				z (cadddr (assoc 10 l1))
			)
			(setq pt_scur (trans (list x y z) 0 1))
			(setq x (car pt_scur) y (cadr pt_scur) z (caddr pt_scur))
			(setq
				l_2d (append l_2d (list (list x y)))
				l_3d (append l_3d (list z))
				l1 (entget (entnext (cdr (assoc -1 l1))))
			)
		)
	)
)
)
(defun c:decal3d ( / ent_or typpol dec_z dec_xy c_curr l_3do l_3dn key_md counter l_3d l_2d ent_m ent_nw l_nw)
(while (null (setq ent_or (entsel "\nChoix de la 3Dpoly à décaler: "))))
(setq typpol (entget (car ent_or)))
(cond
	((and (= (cdr (assoc 0 typpol)) "POLYLINE") (eq (boole 1 (cdr (assoc 70 typpol)) 12) 8))
		(initget 1)
		(setq dec_z (getdist "\nDécalage en Z: "))
		(if (zerop dec_z)
			(progn
				(initget "Uniforme Variable")
				(setq key_md (getkword "\nDelta Z [uniforme/Variable] < U >: "))
			)
		)
		(initget 71)
		(setq dec_xy (getdist "\nDécalage dans le plan XY: "))
		(setvar "cmdecho" 0)
		(command "_.undo" "_begin")
		(setvar "osmode" (+ 16384 (rem (getvar "osmode") 16384)))
		(setq c_curr (getvar "clayer"))
		(setvar "clayer" (cdr (assoc 8 typpol)))
		(m_lpl ent_or)
		(setq l_3do (mapcar 'append l_2d (mapcar 'list l_3d)) counter 0)
		(setq l_3dn
			(reverse
				(mapcar 
					'(lambda (x) 
						(if (eq key_md "Variable")
							(progn
								(setq counter (1+ counter)) (initget 1)
								(+ x (getdist (strcat "\nDelta Z  au " (itoa counter) "(er)(eme) point: ")))
							)
							(+ x dec_z)
						)
					)
					l_3d
				)
			)
		)
		(command "_.pline") 
		(repeat (length l_2d)
			(command (car l_2d))
			(setq l_2d (cdr l_2d))
		)
		(command "")
		(setq ent_m (entlast))
		(setvar "cmdecho" 1)
		(command "_.offset" dec_xy ent_m pause "")
		(setvar "cmdecho" 0)
		(setq ent_nw (entlast))
		(m_lpl (list ent_nw '(0.0 0.0 0.0)))
		(setq l_nw (mapcar 'append l_2d (mapcar 'list l_3dn)))
		(cond
			((zerop (- (length l_2d) (length l_3do)))
				(initget "Oui Non")
				(if (eq (getkword "\nCréer une maille dans le calque courant? [Oui/Non] < Non >: ") "Oui")
					(progn
						(setvar "clayer" c_curr)
						(pm_dec l_3do (reverse l_nw))
						(setvar "clayer" (cdr (assoc 8 typpol)))
					)
				)
			)
			(T (alert "\nATTENTION présence de segments courts (< au décalage); résultat en Z erroné!"))
		)
		(entdel ent_m)
		(entdel ent_nw)
		(command "_.3dpoly")
		(repeat (length l_nw)
			(command (car l_nw))
			(setq l_nw (cdr l_nw))
		)
		(command "")
		(setvar "clayer" c_curr)
		(command "_.undo" "_end")
		(setvar "cmdecho" 1)
	)
	(T (prompt "\nEntité choisie n'est pas une polyligne 3D, ou celle ci est Splinée."))
)
(prin1)
)
(prompt "\nDECAL3D chargé! - Décalage d'une 3DPOLY en 3D dans le CALQUE et le SCU courrant")(prin1)

 

Je pense qu'il peut satisfaire quelque besoins simples, est bien sur qu'il pourrait être encore mieux!

 

[Edité le 22/7/2006 par bonuscad]

[couma-co]

Super le prog, merci bonuscad, à moi il me servira à coup sûre, seulement y a un probleme :( ca INVERSE les ALTITUDES sur les sommets!!!!

Par ex le sommet 1 à l'alt du dernier sommet, le sommet 2, celui de l'avant dernier....etc...

Vous z'auriez la solution par hazard? :calim:

[bonuscad]

Ha oui, tiens suivant la version d'autocad, il inverse les sommets. :casstet:

 

Bon ben, je te propose de faire la modif suivante:

 

(setq l_3dn

; (reverse... <- ICI

....

...

...

; ) <- ICI

)

(command "_.pline")

 

Tu enlèves (reverse ou tu mets un";" en début de ligne AVEC la paranthèse correspondante.

 

Voilà, pas trop dur? ;)

[couma-co]

BONUSCAD,

je vais faire eriger une statue en ton honneur , et dés que j'ai les moyens je construit la place autour : "PLACE DE L'ILLUSTRE BONUSCAD"

encore merci :thumbup:

 

[Edité le 28/7/2006 par couma-co]

[(gile)]

Voici un LISP qui permet de faire de solides ou des surfaces débillardés avec la version 2007.

 

Le LISP répartit des "coupes" sur le chemin spécifié et fait un lissage suivant ces coupes et ce chemin.

 

La "coupe" doit être une entité 2D unique composant d'un bloc. Attention au moment de la création du bloc à l'orientation de l'entité par rapport au SCU, c'est l'axe des X du SCO du bloc qui tangentera avec la projection du chemin sur le plan XY du SCU courant.

 

http://img476.imageshack.us/img476/1049/debil1rh6.png

 

Après avoir sélectionné le bloc dans la liste déroulante, spécifé le chemin et le nombre de coupes, les blocs sont insérés et explosés et sélectionnés dans l'ordre pour le lissage :

 

http://img149.imageshack.us/img149/1576/debil2ky2.png

 

http://img149.imageshack.us/img149/6776/debil3qs8.png

 

;;; C:DEBIL (gile)
;;; Crée un solide ou une surface "débillardé" à partir d'un profil de coupe
;;; et d'un chemin.
;;; Le profil doit être une unique entité 2D contenue dans un bloc.

;;; Loft_along_path Créé un lissage d'après une liste de coupes et un chemin
;;; Fonctionne avec COMMAND dans l'attente d'une fonction vla-...

(defun loft_along_path (lst path / echo)
 (setq echo (getvar "CMDECHO"))
 (grtext -2 "Création du lissage en cours.")
 (setvar "CMDECHO" 0)
 (command "_.loft")
 (mapcar 'command lst)
 (command "" "_path" path)
 (setvar "CMDECHO" echo)
)

;;; Fonction principale

(defun c:debil (/	Space	*error*	ucszdir	nom	sect	path
	nb	obj	dist	ins_pt	deriv1	ref	lst
       )
 (vl-load-com)
 (or *acad* (setq *acad* (vlax-get-acad-object)))
 (or *acdoc* (setq *acdoc* (vla-get-ActiveDocument *acad*)))

 (defun *error* (msg)
   (if	(or
  (= msg "Fonction annulée")
  (= msg "quitter / sortir abandon")
)
     (princ)
     (princ (strcat "\nErreur: " msg))
   )
   (vla-endundomark *acdoc*)
   (princ)
 )

 (setq	Space	(if (= (getvar "CVPORT") 1)
	  (vla-get-PaperSpace *acdoc*)
	  (vla-get-ModelSpace *acdoc*)
	)
ucszdir	(trans '(0 0 1) 1 0 T)
 )
 (sssetfirst nil nil)
 (vla-StartUndoMark *acdoc*)
 (if (setq nom (getblock nil))
   (if
     (and
(setq bloc_def (vla-Item (vla-get-Blocks *acdoc*) nom))
(= (vla-get-Count bloc_def) 1)
(or
  (member (vla-get-ObjectName (setq sect (vla-Item bloc_def 0)))
	  '("AcDbArc"	       "AcDbCircle"
	    "AcDbEllipse"      "AcDbLine"
	    "AcDbPolyline"     "AcDb2dPolyline"
	   )
  )
  (and (= (vla-get-ObjectName sect) "AcDbSpline")
       (= :vlax-true (vla-get-isPlanar sect))
  )
)
     )
      (progn
 (while
   (not
     (and
       (setq path (car (entsel "\nChoix du chemin: "))
	     obj  (vlax-ename->vla-object path)
       )
       (not (vl-catch-all-error-p
	      (vl-catch-all-apply
		'vlax-curve-getEndParam
		(list obj)
	      )
	    )
       )
     )
   )
 )
 (initget 7)
 (setq nb (getint "\nEntrez le nombre de coupes: "))
 (setq dist (/ (vlax-curve-getDistAtParam
		 obj
		 (vlax-curve-getEndParam obj)
	       )
	       nb
	    )
 )
 (repeat (setq nb (1- nb))
   (setq ins_pt (vlax-curve-getPointAtDist obj (* nb dist)))
   (setq deriv1	(vlax-curve-getFirstDeriv
		  obj
		  (vlax-curve-getParamAtDist obj (* nb dist))
		)
   )
   (setq ref
	  (vla-InsertBlock
	    Space
	    (vlax-3d-point ins_pt)
	    nom
	    1
	    1
	    1
	    (angle '(0 0 0) (trans deriv1 0 ucszdir))
	  )
   )
   (setq lst (append (vlax-invoke ref 'explode) lst))
   (vla-delete ref)
   (setq nb (1- nb))
 )
 (setq ins_pt (vlax-curve-getStartPoint obj)
       deriv1 (vlax-curve-getFirstDeriv
		obj
		(vlax-curve-getStartParam obj)
	      )
 )
 (setq ref
	(vla-InsertBlock
	  Space
	  (vlax-3d-point ins_pt)
	  nom
	  1
	  1
	  1
	  (angle '(0 0 0) (trans deriv1 0 ucszdir))
	)
 )
 (setq lst (append (vlax-invoke ref 'explode) lst))
 (vla-delete ref)
 (if (or
       (member (vla-get-Objectname obj)
	       '("AcDbArc" "AcDbHelix" "AcDbLine")
       )
       (and (= (vla-get-Objectname obj) "AcDbEllipse")
	    (or
	      (/= (vla-get-StartAngle obj) 0.0)
	      (/= (vla-get-EndAngle obj) (* 2 pi))
	    )
       )
       (and (member (vla-get-Objectname obj)
		    '("AcDbPolyline"
		      "AcDb2dPolyline"
		      "AcDb3dPolyline"
		      "AcDbSpline"
		     )
	    )
	    (and
	      (= :vlax-false (vla-get-Closed obj))
	      (not (equal (vlax-curve-getStartPoint obj)
			  (vlax-curve-getEndPoint obj)
			  1e-9
		   )
	      )
	    )
       )
     )
   (progn
     (setq ins_pt (vlax-curve-getEndPoint obj)
	   deriv1 (vlax-curve-getFirstDeriv
		    obj
		    (vlax-curve-getEndParam obj)
		  )
     )
     (setq ref
	    (vla-InsertBlock
	      Space
	      (vlax-3d-point ins_pt)
	      nom
	      1
	      1
	      1
	      (angle '(0 0 0) (trans deriv1 0 ucszdir))
	    )
     )
     (setq lst
	    (append lst (vlax-invoke ref 'explode))
     )
     (vla-delete ref)
   )
 )
 (if (<= 17 (read (substr (getvar "ACADVER") 1 4)))
   (loft_along_path (mapcar 'vlax-vla-object->ename lst) path)
   (alert
     "La commande LISSAGE (_LOFT) n'est pas accessible aux versions antérieures à 2007"
   )
 )
 (setvar "INSNAME" nom)
      )
      (prompt "\nLe bloc ne doit contenir qu'une seule entité 2D."
      )
   )
 )
 (vla-EndUndoMark *acdoc*)
 (princ)
)

;;; Getblock (gile) 03/11/07
;;; Retourne le nom du bloc entré ou choisi par l'utilisateur 
;;; dans une liste déroulante de la boite de dialogue ou depuis la boite
;;; de dialogue standard d'AutoCAD
;;; Argument : le titre (string) ou nil (défaut : "Choisir un bloc")

(defun getblock	(titre / bloc n lst tmp file what_next dcl_id nom)
 (while (setq bloc (tblnext "BLOCK" (not bloc)))
   (setq lst (cons (cdr (assoc 2 bloc)) lst)
   )
 )
 (setq	lst  (acad_strlsort
       (vl-remove-if
	 (function (lambda (n) (= (substr n 1 1) "*")))
	 lst
       )
     )
tmp  (vl-filename-mktemp "Tmp.dcl")
file (open tmp "w")
 )
 (write-line
   (strcat
     "getblock:dialog{label="
     (cond (titre (vl-prin1-to-string titre))
    ("\"Choisir un bloc\"")
     )
     ";initial_focus=\"bl\";:boxed_column{
     :row{:text{label=\"Sélectionner\";alignment=left;}
     :button{label=\">>\";key=\"sel\";alignment=right;fixed_width=true;}}
     spacer;
     :column{:button{label=\"Parcourir...\";key=\"wbl\";alignment=right;fixed_width=true;}}
     :column{:text{label=\"Nom :\";alignment=left;}}
     :edit_box{key=\"tp\";edit_width=25;}
     :popup_list{key=\"bl\";edit_width=25;}spacer;}
     spacer;
     ok_cancel;}"
   )
   file
 )
 (close file)
 (setq dcl_id (load_dialog tmp))
 (setq what_next 2)
 (while (>= what_next 2)
   (if	(not (new_dialog "getblock" dcl_id))
     (exit)
   )
   (start_list "bl")
   (mapcar 'add_list lst)
   (end_list)
   (if	(setq n	(vl-position
	  (strcase (getvar "INSNAME"))
	  (mapcar 'strcase lst)
	)
)
     (setq nom (nth n lst))
     (setq nom	(car lst)
    n	0
     )
   )
   (set_tile "bl" (itoa n))
   (action_tile "sel" "(done_dialog 5)")
   (action_tile "bl" "(setq nom (nth (atoi $value) lst))")
   (action_tile "wbl" "(done_dialog 3)")
   (action_tile "tp" "(setq nom $value) (done_dialog 4)")
   (action_tile
     "accept"
     "(setq nom (nth (atoi (get_tile \"bl\")) lst)) (done_dialog 1)"
   )
   (setq what_next (start_dialog))
   (cond
     ((= what_next 3)
      (if (setq nom (getfiled "Sélectionner un fichier" "" "dwg" 0))
 (setq what_next 1)
 (setq what_next 2)
      )
     )
     ((= what_next 4)
      (cond
 ((not (read nom))
  (setq what_next 2)
 )
 ((tblsearch "BLOCK" nom)
  (setq what_next 1)
 )
 ((findfile (setq nom (strcat nom ".dwg")))
  (setq what_next 1)
 )
 (T
  (alert (strcat "Le fichier \"" nom "\" est introuvable."))
  (setq	nom nil
	what_next 2
  )
 )
      )
     )
     ((= what_next 5)
      (if (and	(setq ent (car (entsel)))
	(= "INSERT" (cdr (assoc 0 (entget ent))))
   )
 (setq nom	 (cdr (assoc 2 (entget ent)))
       what_next 1
 )
 (setq what_next 2)
      )
     )
     ((= what_next 0)
      (setq nom nil)
     )
   )
 )
 (unload_dialog dcl_id)
 (vl-file-delete tmp)
 nom
)

 

EDIT : J'ai ajouté un test sur la version d'AutoCAD pour que ceux qui 'ont pas AutoCAD 2007 puissent tester. Ils n'auront que l'insertion/décomposition du bloc et un message d'alerte à la place du lissage. Un résultat similaire, sans décomposition ni insertion aux extrémités est possible avec Dviser3d, et les options Aligner : Oui, Plan de référence : Scu.

 

Et puisqu'il est question de main courante d'escalier :

 

http://img314.imageshack.us/img314/4615/maincourantejy2.png [Edité le 1/8/2006 par (gile)][Edité le 2/8/2006 par (gile)][Edité le 2/8/2006 par (gile)]

[Edité le 25/7/2008 par (gile)]

[(gile)]

Le LISP ci-dessus était incomplet (les sous routines avaient échappé au copier/coller), c'est réparé, toutes mes excuses.

 

PS : Je vais tacher d'y ajouter des commentaires ...

[(gile)]

Voilà le LISP est abondamment commenté, j'ai essayé d'écrire le plus possible en VisualLISP pour que la traduction en VBA soit plus "facile" (pour Culnuteurdebase).

[JL]

Aaaaah là, Gile, je dois dire que c'est du grand art, ton lisp fonctionne à merveille et tu es le plus grand.

 

Enfin une solution sans bidouillage pour réaliser n'importe quels types de rampes ou de limons courbes et surtout en utilisant le profile que l'on veut.

 

Vraiment du beau boulot.

Je réalise des escaliers courbes en bois et ce lisp me sera très très utile pour la présentation à mes clients.

 

Merci merci.

 

[Concombre_masque]

Comment ca se fabrique concretement ? Exemple du dernier dessin. On usine une barre (en bois) et on la tord, c'est fait en partie usiné dans la masse ou autre ? :casstet: Je suis vraiment curieux de connaitre l'étape suivante

[(gile)]

Pour JL,

 

Merci pour le compliment :red:

mais sans la nouvelle commande LISSAGE (_LOFT), on était bien obligé de bidouiller, une grande partie du "mérite" revient donc aux développeurs d'AutoCAD.

 

Pour Concombre_masque,

 

Si aujourd'hui certains limons, et sûrement aussi des mains courantes, sont d'abord construites (ébauchées) en lamellé-collé, il est toujours nécessaire d'usiner les "bois croches".

 

Traditionnellement les limons et les mains courantes sont usinées dans la masse en plusieurs tronçons pour rester le maximum "dans le fil" et assemblés ensuite.

Le profilage des parties croches des mains courantes s'effectue à la toupie, "au champignon", c'est en partie ce genre d'opération, qui ne peut se faire que sans réelle protection, qui a valu à la toupie sa réputation (pas complètement usurpée) de machine dangereuse, et qui a coûté des doigts à beaucoup de menuisier (je n'ai, pour ma part, jamais fait de toupillage "au champignon".

 

Mais peut-être que JL qui, lui, pratique la contruction d'escalier courbes pourra t'en dire un peu plus (et corrigé les éventuelles bétises que j'aurais dites).

 

 

[JL]

Salut

 

Gile a très bien résumé la fabrication et aucune bêtise n'a été dite.

 

Pour ma part, j'utilise une méthode qui demande une bonne recherche préalable en faisant des dessins à l'échelle 1 et que j'ai apprise dans une entreprise (des Yvelines) qui fabrique beaucoup d'escaliers courbes.

 

La méthode consiste à développer chaques "feuillets", c'est à dire de trouver la forme déroulée des lames de bois qui constituent le limon ou la main courrante.

Compte tenu que la courbe et la pente varient entre l'intérieur et l'extérieur d'un limon, les feuillets qui le compose ont leurs formes propres. Selon qu'il s'agit d'une courbe régulière (hélicoïdale), irégulière (en S ou autre) ou d'un noyau (petite partie courbe dans un angle comme le dessin de Gile) les feuillets peuvent être relativement complexe. Et ce principe permet de gagner beaucoup de temps et de matière car une fois collé sur un moule, il n'y a plus beaucoup de travail pour débillarder les chants supérieurs et inférieurs.

L'épaisseur des feuillets est petite (3mm ou même moins) si la courbe est serrée comme par exemple un limon intérieur d'un rayon inférieur à 1m et plus épaisse si la courbe est plus grande.

C'est le lamellé-collé.

 

Autrement une autre méthode mais que je n'utilise pas et qui se perd consiste à façonner plusieurs pieces de bois massif que l'on joint bout à bout avec un "coupe à crochet".

Méthode très chère et très longue mais traditionnelle.

 

Voilà, Concombre, peut-être que tu seras plus éclairé avec nos explications mais d'autres techniques existent probablement.

 

J'arrête là car le sujet dépasse un peu les limites de ce forum.

[(gile)]

Pour JL

 

Pour les développés, j'avais fait un LISP ici, qui fait le dévellopé de surfaces réglées (contrairement au titre du sujet il fait aussi un développé -faux- des surfaces réglées non-développables, je ne suis pas assez fort en math pour arriver à filtrer les surfaces développables).

 

Cela demanderais, pour ton usage, de faire une surface réglée pour les faces intérieure et extérieure de chaque limon (ou pour chaque feuillets), de les développer avec le LISP et de les imprimer à l'échelle 1 sur un traceur à rouleau.

[JL]

Merci Gile je vais regarder ça ce WE. Ça à l'air très intérressant mais y a t il une possibilité dans ton lisp de tenir compte de l'épaisseur d'un feuillet.

 

[(gile)]

y a t il une possibilité dans ton lisp de tenir compte de l'épaisseur d'un feuillet.

 

Non, il s'agit de surfaces, donc sans épaisseur...

 

Pour les feuillets fins, on doit pouvoir ne faire qu'un développé à l'axe du feuillet (fibre neutre), pour les plus épais il faudrait en faire un par face (ceux des "joints de colle" servant 2 fois).

 

À première vue, le plus rapide serait de faire un solide par feuillet (soit un bloc par feuillet et d'utiliser le même chemin), puis de "copier des arrêtes" (édition de solides) pour faire les surfaces gauches et les développés.