Presque Parallele

[Fraid]

Bonjour,

 

J'ai 2 polylignes presque parallele

je voudrai qu'elle le devienne en jouant sur la position des 4 sommets

une seul condition, les sommets ne doivent pas se deplacer de plus de 0.05 unité de dessin

sinon on déclare l'operation impossible

 

dois je tout d'abord trouver la fonction mathematique avant de me lancer en lisp?

 

car cela m'a l'air de haut niveau et se n'est pas mon cas :P

 

merci

[(gile)]

Salut,

 

Le "contrôle du parallélisme" avait été le sujet de ce challenge.

[Fraid]

merci

 

mais une fois le test effectué je n'arrive pas a calculer les nouvelles positions

 

en plus le probleme se corse

les 4 point formant un presque parallelograme doit le devenir :(

 

je vais essayer de trouver un forum de math...

 

[(gile)]

Salut,

 

Il faudrait plus de précisions :

Est-ce que tous les sommets peuvent être déplacés ?

Sinon, combien et lesquels doivent rester fixes ?

Les segments sont ils de même longueur ?

 

 

[Fraid]

oui,tout les sommets doivent se deplacer (pour que cela soit le moins possible, je n'ai que 5 cm de marge)

les segments ne sont pas tout a fait de la meme longueur , mais les segments qui deviendrons paralleles deviendrons aussi egales

 

je te donne les coordonnées de quatre points en exemple

208.5591,529.6605

237.0721,515.3904

223.8607,488.8605

195.3344,503.1231

 

l'unité du dessin est le metre

 

j'ai bien trouvé un truc mais il ne marche que si les segments sont egaux des le depart....

 

 

 

 

 

[(gile)]

Un exemple qui ne déplace que les points p2 et p4 des segments p1 p2 et p3 p4.

Pseudo code :

- calcul des vecteurs v1 de p1 à p2, v2 de p3 à p4

- calcul du vecteur normé v0 de direction v1 + v2 (ou v1 -v2 si l'angle entre les vecteurs est supérieur à 90°). Ce vecteur donne la direction des parallèles telles que le déplacement des points p2 et p4 soit égal.

- calcul des vecteurs v3 et v4 parallèles à v0

- calcul des points p2 et p4 déplacés si le déplacement est inférieur à la tolérance.

 

;; SetParallel (gile)
;; Retourne les points p2 et p4 déplacés de façon à rendre les segments
;; p1 p2 et p3 p4 parallèles si le déplacement n'excède pas la tolérance (fuzz),
;; sinon, retourne nil

(defun SetParallel (p1 p2 p3 p4 fuzz / v1 v2 v0 v3 v4)
 (setq v1 (mapcar '- p2 p1)
       v2 (mapcar '- p4 p3)
 )
 (if (minusp (vxv v1 v2))
   (setq v0 (vunit (mapcar '- v1 v2))
         v4 (vxs v0 (- (distance p3 p4)))
   )
   (setq v0 (vunit (mapcar '+ v1 v2))
         v4 (vxs v0 (distance p3 p4))
   )
 )
 (setq v3 (vxs v0 (distance p1 p2)))
 (if (    (list (mapcar '+ p1 v3) (mapcar '+ p3 v4))
 )
)

;; VUNIT (gile)
;; Retourne le vecteur normé (unitaire) d'un vecteur
;;
;; Argument : un vecteur

(defun vunit (v)
 ((lambda (l)
    (if (/= 0 l)
      (mapcar (function (lambda (x) (/ x l))) v)
    )
  )
   (distance '(0 0 0) v)
 )
)

;; VXS
;; Retourne le produit d'un vecteur par un scalaire
;;
;; Arguments : un vecteur et un réel

(defun vxs (v s) (mapcar (function (lambda (x) (* x s))) v))

;; VXV
;; Retourne le produit scalaire (réel) de deux vecteurs
;;
;; Arguments : deux vecteurs

(defun vxv (v1 v2) (apply '+ (mapcar '* v1 v2)))

[(gile)]

Dans le même esprit, en déplaçant les 4 points de la même distance

 

usage :

(SetParallel '(208.5591 529.6605) '(237.0721 515.3904) '(223.8607 488.8605) '(195.3344 503.1231) 0.05)

retourne :

((208.558 529.658) (237.074 515.393) (223.859 488.858) (195.336 503.126))

Les déplacements sont, dans ce cas de 0.003164 unités pour chaque point.

 

;; SetParallel (gile)
;; Retourne les points p1, p2 p3 et p4 déplacés de façon à rendre les segments
;; p1 p2 et p3 p4 parallèles si le déplacement n'excède pas la tolérance (fuzz),
;; sinon, retourne nil

(defun SetParallel (p1 p2 p3 p4 fuzz / m1 m2 v1 v2 v0 v3 v4)
 (setq m1 (midpt p1 p2)
       m2 (midpt p3 p4)
       v1 (mapcar '- m1 p1)
       v2 (mapcar '- m2 p3)
 )
 (if (minusp (vxv v1 v2))
   (setq v0 (vunit (mapcar '- v1 v2))
         v4 (vxs v0 (- (distance m2 p3)))
   )
   (setq v0 (vunit (mapcar '+ v1 v2))
         v4 (vxs v0 (distance m2 p3))
   )
 )
 (setq v3 (vxs v0 (distance m1 p1)))
 (if (    (list (mapcar '- m1 v3)
         (mapcar '+ m1 v3)
         (mapcar '- m2 v4)
         (mapcar '+ m2 v4)
   )
 )
)

;; VUNIT (gile)
;; Retourne le vecteur normé (unitaire) d'un vecteur
;;
;; Argument : un vecteur

(defun vunit (v)
 ((lambda (l)
    (if (/= 0 l)
      (mapcar (function (lambda (x) (/ x l))) v)
    )
  )
   (distance '(0 0 0) v)
 )
)

;; VXS
;; Retourne le produit d'un vecteur par un scalaire
;;
;; Arguments : un vecteur et un réel

(defun vxs (v s) (mapcar (function (lambda (x) (* x s))) v))

;; VXV
;; Retourne le produit scalaire (réel) de deux vecteurs
;;
;; Arguments : deux vecteurs

(defun vxv (v1 v2) (apply '+ (mapcar '* v1 v2)))

;; MIDPT
;; Retourne le milieu du segement p1 p2
;;
;; Arguments : 2 points

(defun midpt (p1 p2)
 (mapcar (function (lambda (x1 x2) (/ (+ x1 x2) 2.))) p1 p2)
)

[Fraid]

Terrible

 

je vais faire un petit dodo et je teste tout cela demain

 

merci, je te tient au courant

[(gile)]

Re,

 

J'avais zappé le parallélogramme, les routines ci-dessus ne font que mettre les segments parallèles sans modifier leurs longueurs.

 

Celle-ci devrait faire l'affaire.

 

;; SetParallelogram (gile)
;; Déplace les points p1 p2 p3 p4 de façon à ce qu'ils figurent un parallélograme.
;;
;; Retour :
;; si les déplacements sont inférieurs ou égaux à la tolérance (fuzz),
;; la liste des points déplacé, sinon, nil.
;;
;; Arguments : 4 points

(defun SetParallelogram (p1 p2 p3 p4 fuzz / m1 m2 v1 v2 dm vm v3 v4)
 (setq m1 (midpt p1 p2)
       m2 (midpt p3 p4)
       v1 (mapcar '- m1 p1)
       v2 (mapcar '- m2 p3)
       dm (/ (+ (distance p1 p2) (distance p3 p4)) 4.)
 )
 (if (minusp (vxv v1 v2))
   (progn
     (setq vm (vunit (mapcar '- v1 v2))
           v3 (vxs vm dm)
           v4 (vxs vm dm)
     )
     (if (        (list (mapcar '- m1 v3)
             (mapcar '+ m1 v3)
             (mapcar '+ m2 v4)
             (mapcar '- m2 v4)
       )
     )
   )
   (progn
     (setq vm (vunit (mapcar '+ v1 v2))
           v3 (vxs vm dm)
           v4 (vxs vm dm)
     )
     (if (        (list (mapcar '- m1 v3)
             (mapcar '+ m1 v3)
             (mapcar '- m2 v4)
             (mapcar '+ m2 v4)
       )
     )
   )
 )
)

;; VUNIT (gile)
;; Retourne le vecteur normé (unitaire) d'un vecteur
;;
;; Argument : un vecteur

(defun vunit (v)
 ((lambda (l)
    (if (/= 0 l)
      (mapcar (function (lambda (x) (/ x l))) v)
    )
  )
   (distance '(0 0 0) v)
 )
)

;; VXS
;; Retourne le produit d'un vecteur par un scalaire
;;
;; Arguments : un vecteur et un réel

(defun vxs (v s) (mapcar (function (lambda (x) (* x s))) v))

;; VXV
;; Retourne le produit scalaire (réel) de deux vecteurs
;;
;; Arguments : deux vecteurs

(defun vxv (v1 v2) (apply '+ (mapcar '* v1 v2)))

;; MIDPT
;; Retourne le milieu du segement p1 p2
;;
;; Arguments : 2 points

(defun midpt (p1 p2)
 (mapcar (function (lambda (x1 x2) (/ (+ x1 x2) 2.))) p1 p2)
)