Problème Liste de Points à traiter

[VtKp]

Bonjour à tous,

 

Je n'ai plus Internet chez moi depuis 3 mois pour cause de déménagement d'où mes rares interventions ces derniers temps

mais je suis quand même l'actu de cadxp de temps à autre

 

Voici mon problème

 

J'ai une liste de points comme suit :

 

(("1" "748.508" "749.573" "31.362" "740") ("2" "747.758" "749.56" "31.028" "780") ("3" "747.162" "752.98" "31.083" "783")

("4" "748.025" "753.042" "31.464" "743") ("5" "747.212" "757.872" "31.657" "743") ("6" "746.384" "757.796" "31.234" "780")

("7" "745.738" "761.566" "31.345" "783") ("8" "746.639" "761.686" "31.74" "743") ("20" "740.952" "786.986" "31.772" "4010")

("21" "740.575" "786.391" "31.818" "4013") ("22" "740.955" "786.738" "31.845" "3920")

("23" "740.498" "786.353" "31.817" "3923") ("31" "744.11" "783.727" "31.979" "930")

("32" "742.181" "783.418" "31.942" "933") ("33" "741.756" "786.621" "32.026" "933")

("34" "743.499" "786.977" "32.015" "938") ("36" "742.774" "791.674" "32.012" "900")

("37" "743.795" "786.223" "31.943" "903") ("38" "744.837" "780.736" "31.901" "903")

("39" "745.959" "774.738" "31.853" "903") ("40" "747.14" "768.723" "31.788" "903")

("41" "748.16" "763.341" "31.727" "903") ("44" "749.241" "757.617" "31.649" "903"))

 

Le but étant de pouvoir tracer des polylignes 3D liant les points contenant les mêmes codes.

Il s'agit d'une liste de points où le 4ième élement de chaque point est un identifiant.

Tous les points contenant le même préfixe d'un identifiant doivent être reliés par une polyligne 3D.

 

Exemple, une polyligne 3D doit être tracer et passer par les points 36 à 44.

De même, une autre polyligne 3D doit passer par les points 2 à 3.

 

Par contre, l'identifiant du point 2 est le même que celui du point 6.

Il faut par conséquent deux polylignes différentes.

 

Pour chaque point, l'identifiant est un préfixe correspond au 4ième élement de chaque point moins un caractères.

Un identifiant peut être composé de plusieurs caractères, que des nombres mais ce n'est pas limité.

 

Ce qui compte est le suffixe de chaque identifiant

 

Le suffixe 0 est un point de début de polyligne 3D.

Le suffixe 3 est un point intermédiaire de polyligne 3D.

Le suffixe 8 est un point de fermeture de polyligne 3D.

 

Ainsi par exemple, tant qu'il y a un identifiant égal à 743, la polyligne 3D doit passer par le point 1, 4, 5, 8 mais si un identifiant 740 apparait, il

faut redemarrer la création d'une liste de points comme indiqué ci-dessous.

 

Gile à l'époque m'avait quelque chose qui marchait très bien mais les identifiants n'étaient pas strucutres de la même manière.

J'ai essayé de modifié le bout de code d'origine mais je bloque toujours.

 

Voici le code en question :

 

;;Traitement des polylignes 3D
(setq lsth nil)
(if (/= cpol nil)
(progn
(setq lsth (append lsth cpol))
;; boucle principale : tant que lst n'est pas nil
(while lsth
;; initialisation des données
(setq loop  T ; balise pour la boucle secondaire
cnt   0 ; conmpteur dans la liste
start (car lsth) ; premier élément
pref  (substr (nth 4 start) 1 3) ; préfixe du code
pts   (list (list (atof (cadr start)) ; liste de points
(atof (caddr start))
(atof (cadddr start))
)
)
lsth   (cdr lsth) ; la liste sans son premier élément
)
;; boucle secondaire : tant que loop, lst et start ne sont pas nil
(while (and loop lsth (setq start (nth cnt lsth)))
;; évalue si start a le même préfixe de code
(if (= (substr (nth 4 start) 1 3) pref)
;; si oui :
(progn
;; ajout du point à la liste pts et suppression de l'élément de la liste
(setq pts (cons (list (atof (cadr start)) (atof (caddr start)) (atof (cadddr start))) pts) lsth (vl-remove start lsth))
;; évalue si le suffixe du code  = 3
(if (= (substr (nth 4 start) 5) "3")
;; si oui
(progn
;; dessiner la poly
(command "_.3dpoly")
(foreach p (reverse pts)
(command "_non" p)
)
(command)
;; terminer la boucle secondaire
(setq loop nil)
)
)
;; évalue si le suffixe du code  = 4
(if (= (substr (nth 4 start) 5) "4")
;; si oui
(progn
;; dessiner la poly
(command "_.3dpoly")
(foreach p (reverse pts)
(command "_non" p)
)
(command "_c")
(command)
;; terminer la boucle secondaire
(setq loop nil)
)
)
)
; si non, passer à l'élément suivant dans la liste
(setq cnt (1+ cnt))
)
)
)
)
)

 

Et voici un bout de code que j'ai modifié

 

;;Traitement des polylignes 3D
(setq lsth nil)
(if (/= cpol nil)
(progn
(setq lsth (append lsth cpol))
;; boucle principale : tant que lsth n'est pas nil
(while lsth
;; initialisation des données
(setq loop  T ; balise pour la boucle secondaire
cnt   0 ; conmpteur dans la liste
start (car lsth) ; premier élément
pref  (substr (nth 4 start) 1 (1- (strlen (nth 4 start)))) ; préfixe du code
pts   (list (list (atof (cadr start)) ; liste de points
(atof (caddr start))
(atof (cadddr start))
)
)
lsth   (cdr lsth) ; la liste sans son premier élément
)
;; boucle secondaire : tant que loop, lst et start ne sont pas nil
(while (and loop lsth (setq start (nth cnt lsth)))
;; évalue si start a le même préfixe de code
(if 
(and
(= (substr (nth 4 start) 1 (1- (strlen (nth 4 start)))) pref)
(/= (substr (nth 4 start) (strlen (nth 4 start))) 0)
)
(progn
;; si oui :
;; ajout du point à la liste pts et suppression de l'élément de la liste
(setq pts (cons (list (atof (cadr start)) (atof (caddr start)) (atof (cadddr start))) pts) lsth (vl-remove start lsth))

(if 
(or 
(= (length lsth) 0)
(/= (substr (nth 4 (cadr lsth)) 1 (1- (strlen (nth 4 (cadr lsth))))) pref)
)
(progn
;; dessiner la poly
(command "_.3dpoly")
(foreach p (reverse pts)
(command "_non" p)
)
(command)
;; terminer la boucle secondaire
(setq loop nil)
)
)
)
(setq cnt (1+ cnt))
)
)
)
)
)

 

Si quelqu'un pouvait y jeter un oeil, Merci par avance de votre aide.

 

John

[VtKp]

Personne ne peut donc m'aider sur ce problème.

le sujet et l'explication n'est pas assez claire ?

 

John

[didier]

coucou

 

ce n'est pas que le l'explication ne soit pas assez claire ou non,

ce que tu demandes dépasse le "coup de main"

car on marche sur les plates-bandes de ceux qui font des routines professionnelles

 

pour régler ce genre de problème il faut rentrer dedans à bras le corps

et y passer réellement du temps

je pense que c'est ce qui explique le manque de réponses

 

personnellement, j'ai lu et c'est pour cette raison que je ne m'y suis pas collé.

déjà je n'aime pas trop le levé codé, et ensuite je gère les listes de façon assez basique.

 

toutefois, il est possible que quelqu'un s'y colle

il y a des pointures sur le site.

 

amicalement

[Tramber]

Je pense que ca doit être tout à fait accessible. Mais je dois dire aussi que les explications m'embrouillent.

Voudrais-tu recommencer, simplement et autrement ?

[Tramber]

(setq l_entree
'(("1" "748.508" "749.573" "31.362" "740") ("2" "747.758" "749.56" "31.028" "780") ("3" "747.162" "752.98" "31.083" "783")
("4" "748.025" "753.042" "31.464" "743") ("5" "747.212" "757.872" "31.657" "743") ("6" "746.384" "757.796" "31.234" "780")
("7" "745.738" "761.566" "31.345" "783") ("8" "746.639" "761.686" "31.74" "743") ("20" "740.952" "786.986" "31.772" "4010")
("21" "740.575" "786.391" "31.818" "4013") ("22" "740.955" "786.738" "31.845" "3920")
("23" "740.498" "786.353" "31.817" "3923") ("31" "744.11" "783.727" "31.979" "930")
("32" "742.181" "783.418" "31.942" "933") ("33" "741.756" "786.621" "32.026" "933")
("34" "743.499" "786.977" "32.015" "938") ("36" "742.774" "791.674" "32.012" "900")
("37" "743.795" "786.223" "31.943" "903") ("38" "744.837" "780.736" "31.901" "903")
("39" "745.959" "774.738" "31.853" "903") ("40" "747.14" "768.723" "31.788" "903")
("41" "748.16" "763.341" "31.727" "903") ("44" "749.241" "757.617" "31.649" "903"))
)


(defun code(n)(last n)); (code '("1" "748.508" "749.573" "31.362" "740"))
(defun subcode(n)(substr(code n) 1 (1- (strlen(code n))))) ; ( subcode '("1" "748.508" "749.573" "31.362" "740"))
(defun subind(n)(atoi(substr(code n)(strlen(code n)) 1)));( subind '("1" "748.508" "749.573" "31.362" "740"))

(setq liste_tetes(vl-remove-if-not '(lambda(x)(zerop(subind x))) l_entree)); liste avec tous les 740, 780, 4010, etc
(setq liste_restants(vl-remove-if '(lambda(x)(zerop(subind x))) l_entree)); le contraire
;;;assemblage de chaque tête de liste commencant par indice zéro avec le reste ayant un subcode commun et ainsi de suite.
(mapcar
 '(lambda(p)
 (append(list p)(vl-remove-if-not '(lambda(x)(=(subcode p)(subcode x))) liste_restants)))
 liste_tetes)

 

C'était pas si difficile.

Je ne fais plus de boucles imbriquées depuis longtemps. Dis-moi :

• Si ca marche
  
• Si tu veux des explications
  

 

Petites remarques :

• je n'ai pas éliminé les listes ne contennant pas de "8" à la fin. C'est facile, veux-tu le faire ?
  
• On est d'accord, on suppose que ton listing envoie les infos dans le bon ordre.
  
• Si j'ai bien compris, le tout premier indice n'a pas d'importance. Veux-tu aussi que je t'aide à les éliminer ?

[VtKp]

Bonjour Didider Tramber

 

Merci de vous pencher sur mon problème.

Voici un bout de code de ce que je veux exactement faire.

Relier des points entre eux par une polyligne 3D et la fermé si le suffixe du code est un 8

 

(setq cpol '(("1" "748.508" "749.573" "31.362" "740") ("2" "747.758" "749.56" "31.028" "780") ("3" "747.162" "752.98" "31.083" "786")
("4" "748.025" "753.042" "31.464" "743") ("5" "747.212" "757.872" "31.657" "743") ("6" "746.384" "757.796" "31.234" "780")
("7" "745.738" "761.566" "31.345" "786") ("8" "746.639" "761.686" "31.74" "746") ("20" "740.952" "786.986" "31.772" "4010")
("21" "740.575" "786.391" "31.818" "4016") ("22" "740.955" "786.738" "31.845" "3920")
("23" "740.498" "786.353" "31.817" "3926") ("31" "744.11" "783.727" "31.979" "930")
("32" "742.181" "783.418" "31.942" "933") ("33" "741.756" "786.621" "32.026" "933")
("34" "743.499" "786.977" "32.015" "938") ("36" "742.774" "791.674" "32.012" "900")
("37" "743.795" "786.223" "31.943" "903") ("38" "744.837" "780.736" "31.901" "903")
("39" "745.959" "774.738" "31.853" "903") ("40" "747.14" "768.723" "31.788" "903")
("41" "748.16" "763.341" "31.727" "903") ("44" "749.241" "757.617" "31.649" "906")))



;;Traitement des polylignes 3D
(setq lsth nil)
(if (/= cpol nil)
(progn
(setq lsth (append lsth cpol))
;; boucle principale : tant que lsth n'est pas nil
(while lsth
;; initialisation des données
(setq loop  T ; balise pour la boucle secondaire
cnt   0 ; conmpteur dans la liste
start (car lsth) ; premier élément
pref  (substr (nth 4 start) 1 (1- (strlen (nth 4 start)))) ; préfixe du code
pts   (list (list (atof (cadr start)) ; liste de points
(atof (caddr start))
(atof (cadddr start))
)
)
lsth   (cdr lsth) ; la liste sans son premier élément
)
;; boucle secondaire : tant que loop, lst et start ne sont pas nil
(while (and loop lsth (setq start (nth cnt lsth)))
;; évalue si start a le même préfixe de code
(if
(or
(= (nth 4 start) (strcat pref "3"))
(= (nth 4 start) (strcat pref "6"))
(= (nth 4 start) (strcat pref "8"))
)
(progn
;; si oui :
;; ajout du point à la liste pts et suppression de l'élément de la liste
(setq pts (cons (list (atof (cadr start)) (atof (caddr start)) (atof (cadddr start))) pts) lsth (vl-remove start lsth))

(if 
(= (nth 4 start) (strcat pref "6"))
(progn
;; dessiner la poly
(command "_.3dpoly")
(foreach p (reverse pts)
(command "_non" p)
)
(command)
;; terminer la boucle secondaire
(setq loop nil)
)
)

(if 
(= (nth 4 start) (strcat pref "8"))
(progn
;; dessiner la poly
(command "_.3dpoly")
(foreach p (reverse pts)
(command "_non" p)
)
(command "_c")
(command)
;; terminer la boucle secondaire
(setq loop nil)
)
)

)
(setq cnt (1+ cnt))
)
)
)
)
)

 

 

Tramber, ton code semble correct mais si par exemple tu as dans ta liste plusieurs code 740, tous les codes 743 se mettent à la suite alors que je voudrais que dès que le programme rencontre un code avec un suffixe 0, il recommence une autre ligne.

 

Tu peux t'en apercevoir avec cette liste

 

(setq l_entree 
'(("1" "748.508" "749.573" "31.362" "740") ("2" "747.758" "749.56" "31.028" "780") ("3" "747.162" "752.98" "31.083" "783") 
("4" "748.025" "753.042" "31.464" "743") ("5" "747.212" "757.872" "31.657" "740") ("6" "746.384" "757.796" "31.234" "780") 
("7" "745.738" "761.566" "31.345" "783") ("8" "746.639" "761.686" "31.74" "743") ("20" "740.952" "786.986" "31.772" "4010") 
("21" "740.575" "786.391" "31.818" "4013") ("22" "740.955" "786.738" "31.845" "3920") 
("23" "740.498" "786.353" "31.817" "3923") ("31" "744.11" "783.727" "31.979" "930") 
("32" "742.181" "783.418" "31.942" "933") ("33" "741.756" "786.621" "32.026" "933") 
("34" "743.499" "786.977" "32.015" "938") ("36" "742.774" "791.674" "32.012" "900") 
("37" "743.795" "786.223" "31.943" "903") ("38" "744.837" "780.736" "31.901" "903") 
("39" "745.959" "774.738" "31.853" "903") ("40" "747.14" "768.723" "31.788" "903") 
("41" "748.16" "763.341" "31.727" "903") ("44" "749.241" "757.617" "31.649" "903")) 
)

 

Ton lisp ajoute le point 8 à la suite du pont 1 et 4 alors que dans ce cas, il faudrait deux listes

une avec seulement les points 1 et 4 et une autre avec les points 5 et 8 par exemple quoi.

 

Bon, je crois avec simplifier le problème avec l'ajout du suffixe du code 6 dans mon code exemple.

Le problème, c'est qu'en réalité, ce suffixe de code n'existe pas, on ne codifie pas comme çà sur le terrain.

 

Il faudrait je pense mais là ca dépasse un peu mais compétence qu'au dernier point avec un suffixe de code 3, il le remplace par un 6

 

Un exemple est souvent plus parlant

 

Voici ma liste de départ

 

(setq cpol '(("1" "748.508" "749.573" "31.362" "740") ("2" "747.758" "749.56" "31.028" "780") ("3" "747.162" "752.98" "31.083" "783")
("4" "748.025" "753.042" "31.464" "743") ("5" "747.212" "757.872" "31.657" "740") ("6" "746.384" "757.796" "31.234" "780")
("7" "745.738" "761.566" "31.345" "783") ("8" "746.639" "761.686" "31.74" "743") ("20" "740.952" "786.986" "31.772" "4010")
("21" "740.575" "786.391" "31.818" "4013") ("22" "740.955" "786.738" "31.845" "3920")
("23" "740.498" "786.353" "31.817" "3923") ("31" "744.11" "783.727" "31.979" "930")
("32" "742.181" "783.418" "31.942" "933") ("33" "741.756" "786.621" "32.026" "933")
("34" "743.499" "786.977" "32.015" "938") ("36" "742.774" "791.674" "32.012" "900")
("37" "743.795" "786.223" "31.943" "903") ("38" "744.837" "780.736" "31.901" "903")
("39" "745.959" "774.738" "31.853" "903") ("40" "747.14" "768.723" "31.788" "903")
("41" "748.16" "763.341" "31.727" "903") ("44" "749.241" "757.617" "31.649" "903")))

 

Et voici la liste qu'il faudrait à créer en remplacant le dernier point d'un suffixe de code 3 par un suffixe de code 6 avant un nouveau suffixe du même code 0. Un petit coup d'oeil sur ces deux listes permet de comprendre le principe, je pense, Non ??? Avec le point 44 ou le point 8 ou encore le point 4. Les suffixes de code de ces points ne sont pas les mêmes que la liste précédente.

 

(setq cpol '(("1" "748.508" "749.573" "31.362" "740") ("2" "747.758" "749.56" "31.028" "780") ("3" "747.162" "752.98" "31.083" "786")
("4" "748.025" "753.042" "31.464" "746") ("5" "747.212" "757.872" "31.657" "740") ("6" "746.384" "757.796" "31.234" "780")
("7" "745.738" "761.566" "31.345" "786") ("8" "746.639" "761.686" "31.74" "746") ("20" "740.952" "786.986" "31.772" "4010")
("21" "740.575" "786.391" "31.818" "4016") ("22" "740.955" "786.738" "31.845" "3920")
("23" "740.498" "786.353" "31.817" "3926") ("31" "744.11" "783.727" "31.979" "930")
("32" "742.181" "783.418" "31.942" "933") ("33" "741.756" "786.621" "32.026" "933")
("34" "743.499" "786.977" "32.015" "938") ("36" "742.774" "791.674" "32.012" "900")
("37" "743.795" "786.223" "31.943" "903") ("38" "744.837" "780.736" "31.901" "903")
("39" "745.959" "774.738" "31.853" "903") ("40" "747.14" "768.723" "31.788" "903")
("41" "748.16" "763.341" "31.727" "903") ("44" "749.241" "757.617" "31.649" "906")))

 

Merci encore de votre aide.

 

John

[Tramber]

Ah, ta remarque est juste concernant mon code. J'aurais dû y penser.

A voir demain si j'ai 5 minutes....

[VtKp]

Merci Tramber pour ton aide.

 

En réponse à tes questions, le code doit traiter les points ayant un suffixe de code égal à 3 ou à 8

Et oui, les points dans le bon ordre le traitement

 

A demain

 

John

[Tramber]

(defun code(n)(last n))
(defun subcode(n)(substr(code n) 1 (1- (strlen(code n))))) 
(defun subind(n)(atoi(substr(code n)(strlen(code n)) 1)))
(setq liste_tetes(vl-remove-if-not '(lambda(x)(zerop(subind x))) l_entree))
(mapcar
 '(lambda(p)
    (vl-remove-if-not '(lambda(x)(=(subcode p)(subcode x)))
      (reverse(cond((cdr(vl-member-if'(lambda (x) (= (last x)(strcat(subcode p)"0")))   (reverse(member p l_entree)))))
	    ((reverse(member p l_entree)))))))
 liste_tetes)

 

Nouvelle proposition. Je fais encore quelques tests.

Ca devient balaise :blink:

[Tramber]

(defun code(n)(last n)); (code '("1" "748.508" "749.573" "31.362" "740"))
(defun subcode(n)(substr(code n) 1 (1- (strlen(code n))))) ; ( subcode '("1" "748.508" "749.573" "31.362" "740"))
(defun subind(n)(atoi(substr(code n)(strlen(code n)) 1)));( subind '("1" "748.508" "749.573" "31.362" "740"))
(setq liste_tetes(vl-remove-if-not '(lambda(x)(zerop(subind x))) l_entree)); liste avec tous les 740, 780, 4010, etc
(setq resultat(mapcar
 '(lambda(p)
    (vl-remove-if-not '(lambda(x)(=(subcode p)(subcode x)))       
      (vl-remove-if '(lambda(x)(member x(vl-member-if'(lambda (x) (= (last x)(strcat(subcode p)"0")))   (cdr(member p l_entree)))))
 (member p l_entree)
 )       
      ))
 liste_tetes))

 

Mon précédent code était sympa mais j'avais oublié la possibilité qu'il y ait 3 groupe commençant, par exemple 3 groupes 740.

Mon principe est meilleur ici, il y a comme un "double member" qui borne le traitement.

Traitement qui consiste, à chaque fois, à écarter ce qui n'a pas le même subcode (vl-remove-if-not).

On dirait que ca marche ici. Merci de nous dire B)

[VtKp]

Merci Tramber pour ton aide.

Ca marche très bien

 

John