[RESOLU] Quadrillage de référence

Ksow · le 28 février 2019

Edit 15.07.19 : (ci-joint un lien pour passer directement à la dernière version du programme : Dernière version du programme)

Bonjour,

je débute dans la programmation LISP. J'ai pour projet de faire un programme LISP permettant la création de "traits de construction" (horizontaux et verticaux) pour pouvoir faire des coupes... avec le niveau NGF renseignés pour les axes horizontaux et la distance en m pour les axes verticaux.

Voici-ci un "organigramme"algorithme pour mieux comprendre mon projet.

1 Clique sur un icone
↓
2 Choix échelle (m/cm/mm)
↓
3 Renseigner un point de référence
↓
4 NGF de ce point
↓
5 Point à intégrer
↓
6 Valeur
↓
7 Autre point ? OUI nous ramène à la ligne 5 (boucle)
NON
↓
Axes verticaux ? NON met fin au programme
OUI
↓
Renseigner l’axe le plus à gauche
↓
… (boucle idem que Axes horizontaux)
↓
Fin du programme

Donc maintenant concernant le programme LISP voici la base que j'ai pu réalisé :

;;					+---------------------------+
;;					|         Projet NGF        |
;;					+---------------------------+

;;;*****************
;;;	DONNEES
;;;*****************
				;Récupération et redéfinition des données utilisateur
(defun boot ()
 (setq acrobj (getvar "OSMODE"))	;Accrochage aux objets
 (setq units_angle (getvar "AUNITS"))	;Unités angulaire

 (setvar "OSMODE" 167)			;Accrobj (Ext'/Mil'/Centre/Intersect'/Perpendi')
 (setvar "AUNITS" 0)			;Angle en degrés
)

				;RàZ des modifications des données utilisateur
(defun reboot ()
 (setvar "OSMODE" acrobj)
 (setvar "AUNITS" units_angle)
 (setvar "PLINEWID" 0)
)
;;; *****************
;;;	PROGRAMME
;;; *****************
(defun c:NGF ()
 (boot)				;Initialisation

				;Vérification de l'existance du calque NGF
 (if (not (tblsearch "LAYER" "00-PIC-NGF"))
				;Création du calque NGF (s'il est inexistant)
   (command "-CALQUE"	  "N"	       "00-PIC-NGF" "CO"
     "230"	  "00-PIC-NGF" "TL"	    "AXES"
     "00-PIC-NGF" ""
    )
 )

 (command "-CALQUE" "CH" "00-PIC-NGF" "") ;Rend courant le calque
 (setvar "CECOLOR" "DUCALQUE")

				;Choix de l'unité de dessin
 (initget 1 "MIllimetre CEntimetre MEtre")
 (setq	choix_unit
 (getkword
   "\nSpécifier l'unité de dessin [MIllimetre/CEntimetre/MEtre]"
 )
 )
 (cond
   ((= choix_unit "MIllimetre") (command "INSUNITS" 4))
				;si l'unité est des mm
   ((= choix_unit "CEntimetre") (command "INSUNITS" 5))
				;si l'unité est des cm
   ((= choix_unit "MEtre") (command "INSUNITS" 6))
				;si l'unité est des m
 )

 ;;; AXES HORIZONTAUX
				;Renseignement du point de référence
 (command "DROITE" "H")
 (setq Pref (getpoint "\nVeuillez renseigner le point de référence."))
 (command Pref "")

				;Saisie de la première valeur NGF
 (setq name_NGF (entlast))
 (command "-TEXTE"
   pause
   "15"
   "0"
   (setq Ht_NGF
	  (strcat
	    (rtos (getreal "\nVeuillez saisir la côte NGF (en m) :"))
	    " NGF"
	  )
   )
 )

 (initget 1 "Oui Non")
 (setq	Choix_utilisateur
 (getkword
   "\nVoulez vous tracer un nouveau niveau NGF ? [Oui/Non]"
 )
 )
 (cond
   ((= Choix_utilisateur "Oui")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUSQUE LA CA FONCTIONNE
   ; (setq Ht_NGF (getreal "\nVeuillez saisir le niveau NGF (en m) :"))
   ; (setq DELTA (distance Pref PtNGF))
   ; (setq PtNGF (polar Pref (/ pi 2) DELTA))
    

   ; (command "DECALER" "DELTA")

   )
 )
 
;;;;;;;;;;;;;;;;;;;;((= Choix_utilisateur "Non")
;;;;;;;;;;;;;;;;;;;;...... PASSER DIRECTEMENT A LA PARTIE AXE VERTICAUX

;;; AXE VERTICAUX

 (reboot)				; => RàZ
)

Du coup, jusqu'à la ligne ";;; JUSQUE LA CA FONCTIONNE" je ne pense pas avoir de souci (bien qu'il faudra que je mette en place des coefficients selon l'échelle choisi car pour l'instant j'essaye de faire fonctionner mon programme avec une seule échelle)

J'arrive ainsi à créer mon premier niveau NGF mais je n'arrive pas à créer les autres en fonction de celui-ci.

Je m'explique, j'aimerai qu'en rentrant le prochain niveau NGF (exemple : 40.00 NGF), cela crée automatiquement ma deuxième droite avec son texte. (mais il faudrait aussi que ça soit possible en cliquant directement sur le prochain point)

J'ai essayé de passer par la commande "DECALER" mais rien à faire, j'enchaine erreur sur erreur et après multiple tentative, j'avoue être perdu...

Voici aussi un petit schéma très très simpliste, qui permettra je l'espère de mieux comprendre mon début de programme :

Merci à ceux qui prendront la peine de tout lire et de m'aider ~

Bonne journée.

didier · le 28 février 2019

Coucou

Pour une fois on voit un premier message clairement expliqué et avec un code déjà bien commencé, bravo

Je vais donc me permettre d'y apporter commentaires et conseils.pour commencer on ne parle pas d'organigramme mais d’algorithme

Je n'ai pas tout à fait compris la finalité du programme, ce que je comprends c'est qu'il sera demandé à l'utilisateur de rentrer une cote NGF et suivant ce qui est dessiné (3D ?) dans le DWG cette cote on peut la trouver par programmation, c'est mieux que de taper au clavier qui est une grosse source d'erreurs.

Au début on trouve la fonction boot (le nom porte à confusion, mais ce n'est pas le sujet)

Cette fonction change des variables et il est plus commun de faire une fonction qui enregistre l'état actuel du dessin et qui change ensuite les variables de cette façon il est simple à la fin du programme de "remettre" le dessin dans lequel on l'a trouvé au lancement de la routine.

C'est très bien de tester l'existence du calque par TBLSEARCH avant de le créer,

Il est préférable d'utiliser la syntaxe internationale pour les "command"

(command "-CALQUE" deviendra (command "_LAYER"

Pour cette partie

(command "DROITE" "H")
(setq Pref (getpoint "\nVeuillez renseigner le point de référence."))
(command Pref "")

Je choisirais plutôt de faire :

(setq Pref (getpoint "\nVeuillez renseigner le point de référence."))
(command "_XLINE" "_H" Pref )

Quand on utilise RTOS il est conseillé de choisir ses décimales, la valeur par défaut n'étant pas toujours correcte

voila une première critique dans un esprit constructif

Le reste des explications devrait se trouver sur mon site (lien en signature), je n'aimerais pas avoir tout ce travail pour rien.

Amicalement

didier · le 28 février 2019

Coucou

J'ai regardé de plus près l'image, je comprends que c'est une coupe ou une élévation

Donc le point de référence altimétrique est une valeur Y des entités dessinées

Il y a moyen de faire plus fort et de ne pas demander à l'utilisateur de TAPER ce renseignement qui existe dans le dessin

Encore une fois : éviter de taper des valeurs au clavier, c'est la première source de problèmes...Je renouvèle mes félicitations on sent quelqu'un qui en veut...

Amicalement

Ksow · le 28 février 2019

Bonjour didier,

tout d'abord merci de ta réponse.

Je prend note pour "algorithme" et la syntaxe internationale.

Ensuite j'avoue ne pas être à l'aise du tout avec l'anglais donc il se peut que j'utilise des termes qui peuvent porter à confusion effectivement comme tu l'as fait remarqué avec boot.

C'est pourquoi j'aime bien utilisé des annotations à côté pour m'y retrouver moi mais aussi pour qu'une autre personne qui voudrait intervenir sur mon programme ne soit pas trop perdu.

Concernant ta question sur la finalité du programme, en gros si je devais résumé :

L'utilisateur doit cliquer sur un point de référence et entrer sa cote NGF pour créer le premier niveau NGF, ensuite pour les autres niveaux il aura 2 possibilités :

- soit il continu de cliquer sur chaque angle de son plan pour y faire apparaître des axes avec les côtes NGF qui se calcule en fonction de l'échelle choisi au début du programme et du premier niveau de référence choisi au préalable.

- soit après avoir créer ce premier niveau NGF, il entre les suivants et les axes (+ cotes) se tracent tout seul en fonction du premier niveau référence

Le but étant d'avoir un quadrillage qui pourra être utile pour réaliser une coupe. (cela se passe donc en 2D seulement dans mon cas)

Je vais donc rectifier mon programme en tenant compte de tes commentaires et conseils, et faire un tour sur ton site voir si j'arrive à trouver une solution à mon problème.

Encore merci d'avoir prit le temps de répondre.

Salutation.

DenisHen · le 28 février 2019

Salut.

Ce que tu appelles "Cote NGF" ne serait-ce pas un Plan horizontal de référence (ou de comparaison) ?

Et je dirais comme didier (le contraire serait suicidaire ;) ), rtos demande trois choses, un nombre, un format de donnée et un nombre de décimales...

Mais il faut le souligner, c'est clair et il y a un bon début de code... Bravo...

didier · le 28 février 2019

Coucou

Il n'y a rien de suicidaire à me contredire, quand c'est correct je m'incline tout autant que les autres

Petite correction :

Les deux derniers arguments de RTOS sont optionnels

Si on ne réponds rien comme c'est le cas dans l'exemple fourni, ça fonctionne mais avec les réglages courants ce qui n'est pas toujours ce qu'on veut obtenir,

J'ai pris l'habitude de coder "en dur" une variable dec dans mes codes comme ça quand je veux changer je n'ai pas à me taper la modification de tous les RTOS présents

Exemple :

Qui renvoie "2.36"

Amicalement

x_all · le 1 mars 2019

Félicitation pour la clarté du code...

remarque sur le fond.

Ton programme à une utilité théorique, mais dans les fait, on a rarement besoin de tracer des lignes horizontales pour la construction d'une élévation, par contre, on se retrouve fréquemment à devoir coter avec des petites flèches les hauteurs et retombées, niveau de faitage...Notion importante, ce genre de programme DOIT fonctionner quelque soit le SCU (car en pratique on dessine souvent la façade en projection de la vue en plan)

j'avais fait un truc dans le style, à la fin tu as les blocs et un code dont tu peux t'inspirer, mais je n'ai pas le niveau (loint de là) des intervenants donc mon code est plus là a titre d'exemple d'un truc qui fonctionne que d'exemple de bonne habitudes et de réalisation d'un lisp propre. le code avec les blocs dynamiques que j'utilise à la fin de la page

http://joch04.free.f...ps-bloc-dyn.htm

http://joch04.free.fr/images/alti-dyn/alti-1.jpg

DenisHen · le 1 mars 2019

Entièrement d'accord avec toi didier :D .

Perso, j'utilise la variable LUPREC pour les décimales de rtos.

PS : j'utilisais "suicidaire" car tes interventions sont très concises et très pensées ;) .

C'est du Maxwell, pas besoin d'en rajouter... :D.

Je ne doutais pas de ton humilité...

Ksow · le 1 mars 2019

Bonjour,

Je n'ai pas pu continuer hier soir d'où ma réponse un peu tardive.

J'ai donc modifié mon programme ce matin (à plusieurs reprise :D ) en tenant compte de vos commentaires, cependant j'ai quelques petits soucis :

- quand je modifie comme me l'a suggéré didier :

Pour cette partie

(command "DROITE" "H")
(setq Pref (getpoint "\nVeuillez renseigner le point de référence."))
(command Pref "")

Je choisirais plutôt de faire :

(setq Pref (getpoint "\nVeuillez renseigner le point de référence."))
(command "_XLINE" "_H" Pref )

je me retrouve avec une erreur de fonction... et je reste bloqué dans ma commande "_XLINE" sans pouvoir continuer sur l'insertion de texte. J'ai bien essayé de faire quelques changement mais rien à faire j'ai toujours ce problème et la seule façon de le résoudre c'est de revenir sur mes lignes d'origine. J'imagine que j'ai du mal comprendre le commentaire.

- pour l'utilisation de RTOS, le nombre de décimal reste bien bloqué à 2 si par exemple j'écris 10.123456 il me rend 10.12 néanmoins dans le cas où j'écrirai 10, j'aimerai qu'il m'affiche 10.00 NGF or il reste sur 10 tout simplement..

Pourtant j'ai essayé de corriger ça en utilisant la variable LUPREC (que j'ai configuré à 2).

Sinon je suis toujours en pleine recherche/phase de test avec le site de didier pour trouver comment faire mon "décalage" à partir de mon plan horizontal de référence (@DenisHen)

Je continu donc à faire mes modifications (même si je prend énormément de temps pour quelques lignes) en tenant compte de vos remarques pour améliorer, optimiser mon programme.

Voici plus ou moins à quoi ressemble mon programme pour l'instant, je suis encore en train de le modifier en ce moment même donc il est pas 100% à jour.

;;					+---------------------------+
;;					|        Projet : NGF       |
;;					+---------------------------+

;;;*****************
;;;	DONNEES
;;;*****************

;;Récupération et redéfinition des données utilisateur
(defun init ()
 (setq acrobj (getvar "OSMODE"))	;Accrochage aux objets
 (setq units_angle (getvar "AUNITS"))	;Unités angulaire
 (setq nbdeci (getvar "LUPREC"))	;Nombre de décimal

 (setvar "OSMODE" 167)			;Accrobj (Ext'/Mil'/Centre/Intersect'/Perpendi')
 (setvar "AUNITS" 0)			;Angle en degrés
 (setvar "LUPREC" 2)			;Décimale choisie : 2
)

;;RàZ des modifications des données utilisateur
(defun reinit ()
 (setvar "OSMODE" acrobj)
 (setvar "AUNITS" units_angle)
 (setvar "PLINEWID" 0)
)

;;; *****************
;;;	PROGRAMME
;;; *****************
(defun c:NGF1 ()
 (init)				;Initialisation

				;Vérification de l'existance du calque NGF
 (if (not (tblsearch "LAYER" "00-COUPE-NGF"))
				;Création du calque NGF (s'il est inexistant)
   (command "_LAYER"	   "N"		 "00-COUPE-NGF"
     "CO"	   "230"	 "00-COUPE-NGF"
     "TL"	   "AXES"	 "00-COUPE-NGF"
     ""
    )
 )

 (command "_LAYER" "CH" "00-COUPE-NGF" "") ;Rend courant le calque
 (setvar "CECOLOR" "DUCALQUE")

				;Choix de l'unité de dessin
 (initget 1 "MIllimetre CEntimetre MEtre")
 (setq	choix_unit
 (getkword
   "\nSpécifier l'unité de dessin [MIllimetre/CEntimetre/MEtre]"
 )
 )
 (cond
   ((= choix_unit "MIllimetre") (setvar "INSUNITS" 4))
				;si l'unité est des mm
   ((= choix_unit "CEntimetre") (setvar "INSUNITS" 5))
				;si l'unité est des cm
   ((= choix_unit "MEtre") (setvar "INSUNITS" 6))
				;si l'unité est des m
 )

;;; AXES HORIZONTAUX
				;Renseignement du point de référence ////PROBLEME ICI////
				;(command "_XLINE" "_H")
 (setq Pref (getpoint "\nVeuillez renseigner le point de référence."))
 (command "_XLINE" "_H" Pref)
 ;(command Pref "")

				;Saisie de la première valeur NGF
 (setq name_NGF (entlast))
 (command "_TEXT"
   pause
   "15"
   "0"
   (setq Val_NGF
	  (strcat
	    (rtos (getreal "\nVeuillez saisir le niveau NGF (en m) :")
		  2
		  2
	    )
	    " NGF"
	  )
   )
 )

 (initget 1 "Oui Non")
 (setq	Choix_utilisateur
 (getkword
   "\nVoulez vous tracer un nouveau niveau NGF ? [Oui/Non]"
 )
 )
 (cond
   ((= Choix_utilisateur "Oui")

;;;;__________________________________________________________JUSQU ICI TOUT FONCTIONNE CORRECTEMENT (ou presque...)

    (ssget "_L")
    (setq
      PtNGF
(command
  "DECALER"
  (getreal "\nVeuillez saisir le niveau NGF (en m) :")
)
    )




    (setq name_NGF1 (entlast))
    (command "_TEXT"
      pause
      "15"
      "0"
      (setq Val_NGF1
	     (strcat
	       (rtos PtNGF 2 2)
	       " NGF"
	     )
      )
    )
   )

;;;;;;	((= Choix_utilisateur "Non")
;;;;;;	ON PASSE DIRECTEMENT A LA PARTIE AXE VERTICAUX
 )

;;; AXES VERTICAUX

 (reinit)				;RàZ
)

Merci à vous!

Salutation.

didier · le 1 mars 2019

Coucou Pour ce qui de la ligne corrigée un "valid" à vide devrait faire l'affaire, un peu comme dans AutoCAD quand tu termines une commande XLINE tu valides pour dire stop

Donc la ligne sera :

(command "_XLINE" "_H" Pref "")

Pour ce qui est de la valeur ".00" lors de transformation d'un nombre entier en string, essaie de mettre la variable DIMZIN à 0 (zéro),

Je ne suis pas certain de la valeur mais fais des tests, c'est cette variable qui va gérer ça.

Ça c'est fait .

Pour le reste je n'ai pas compris la finalité du programme

Et autant je suis près à faire des efforts pour ce qui est "lisp"

Je n'ai pas envie de chercher à me mettre dans ta tête pour savoir ce qu'il faut rendre avec le code

Je ne comprends pas l'utilisation de "décaler", on "décale" quoi ? c'est pas déplacer plutôt ?

Ensuite les axes verticaux ??? quid du NGF sur une ligne verticale ?

Amicalement

Ksow · le 1 mars 2019

-

Je continu de travailler sur mon programme quand j'ai du temps libre et je vous tiens au courant de son avancé, si vous le voulez bien.

Bonne journée,

Salutation.

Ksow · le 6 mai 2019

Bonjour,

Me revoilà après quelques temps d'absences..

J'ai été assez occupé mais j'ai tout de même essayé d'avancer mon programme quand j'avais du temps libre.

Je pense l'avoir bien amélioré par rapport au début sauf que je suis arrivé à un stade où je ne sais plus quoi faire.

Tout d'abord, voici l'avancé de mon programme LISP :

;;                                      +---------------------------+
;;                                      |        Projet : NGF       |
;;                                      +---------------------------+

;;;*****************
;;;     DONNEES
;;;*****************

;;Récupération et redéfinition des données utilisateur
(defun init ()
 (setq acrobj (getvar "OSMODE"))	;Accrochage aux objets
 (setq units_angle (getvar "AUNITS"))	;Unités angulaire
 (setq nbdeci (getvar "LUPREC"))	;Nombre de décimal
 (setq dimz (getvar "DIMZIN"))
				; enregistrement des valeurs initiales de la variable système
 (setq attreq (getvar "ATTREQ"))
 (setq attdia (getvar "ATTDIA"))
 (setq units (getvar "INSUNITS"))

 (setvar "OSMODE" 167)			;Accrobj (Ext'/Mil'/Centre/Intersect'/Perpendi')
 (setvar "AUNITS" 0)			;Angle en degrés
 (setvar "LUPREC" 2)			;Décimale choisie : 2
 (setvar "DIMZIN" 0)
				; modification des valeurs courantes de la variable système
 (setvar "ATTREQ" 1)
 (setvar "ATTDIA" 0)

)

;;RàZ des modifications des données utilisateur
(defun reinit ()
 (setvar "OSMODE" acrobj)
 (setvar "AUNITS" units_angle)
 (setvar "PLINEWID" 0)
 (setvar "DIMZIN" 8)
 (setvar "ATTREQ" attreq)
 (setvar "ATTDIA" attdia)
 (setvar "INSUNITS" units)
)

;;Fonction d'insertion des blocs

(defun Ins_Bloc	(choix_unit Pt Ht_NGF)

 (setq blc_name (strcat "BLOC_" axe unit))
 (command "-inserer" blc_name Pt 1 1 0 Ht_NGF)

)

;;; *****************
;;;     PROGRAMME
;;; *****************

(defun c:NGF ()
 (init)				;Initialisation

				;Vérification de l'existance du calque NGF
 (if (not (tblsearch "LAYER" "00-QUADRILLAGE-NGF"))
				;Création du calque NGF (s'il est inexistant)
   (command "_LAYER"	       "N"		 "00-QUADRILLAGE-NGF"
     "CO"	       "230"		 "00-QUADRILLAGE-NGF"
     "TL"	       "AXES"		 "00-QUADRILLAGE-NGF"
     ""
    )
 )

 (command "_LAYER" "CH" "00-QUADRILLAGE-NGF" "")
				;Rend courant le calque
 (setvar "CECOLOR" "DUCALQUE")

				;Choix de l'unité de dessin
 (initget 1 "MIllimetre CEntimetre MEtre")
 (setq	choix_unit
 (getkword
   "\nSpécifier l'unité de dessin [MIllimetre/CEntimetre/MEtre]"
 )
 )

 ;;condition pour choisir l'unité d'échelle
 (cond
   ((= choix_unit "MIllimetre")
    (setq unit	"_mm"
   coeff_unit
    1000
    )
    (setvar "INSUNITS" 4)
   )
   ((= choix_unit "CEntimetre")
    (setq unit	"_cm"
   coeff_unit
    100
    )
    (setvar "INSUNITS" 5)
   )
   ((= choix_unit "MEtre")
    (setq unit	"_m"
   coeff_unit
    1
    )
    (setvar "INSUNITS" 6)
   )
 )

;;; AXES HORIZONTAUX

    (setq axe "NGF")

    ;;insertion bloc NGF
    (setq
      Pref (getpoint "\nVeuillez renseigner le point de référence.")
    )
    (setq P0 (list (- (car Pref) (* 2 coeff_unit))
	    (cadr Pref)
	    (caddr Pref)
      )
    )
    (command "_XLINE" "_H" Pref "")


    (setq Val_NGF (getreal "\nVeuillez saisir le niveau NGF (en m) :"))

    (Ins_Bloc
      choix_unit
      Pref
      (strcat (rtos Val_NGF 2 2) " NGF")
    )

    ;;récup nom_bloc
    (setq nom_bloc (entlast))

    (initget 1 "Oui Non")		;restreins l'utilisateur à choisir entre les deux conditions pour réitérer l'opération
    (setq Choix_utilisateur
    (getkword
      "\nVoulez vous tracer un nouveau niveau NGF ? [Oui/Non]"
    )
    )
    (cond
      ((= Choix_utilisateur "Oui")
(while
  (setq
    NGF_ins
     (getreal "\nVeuillez saisir le niveau NGF (en m) :")
  )
   (setq P_ins
	  (list	(car P0)
		(+ (cadr P0) (* (- NGF_ins Val_NGF) coeff_unit))
		(caddr P0)
	  )
   )

   (Ins_Bloc
     choix_unit
     P_ins
     (strcat (rtos NGF_ins 2 2) " NGF")
   )

   (command "_XLINE" "_H" P_ins "")
)
      )
    )
;;;/////////////////////////////////////////////////////////////////NON FONCTIONNEL
;;; AXES VERTICAUX

    (setq axe "DIST")

    ;;insertion bloc DIST
    (command "_XLINE" "_V" Pref "")
    (setq Vref	(list (car Pref)
	      (+ (cadr Pref) (* 10 coeff_unit))
	      (caddr Pref)
	)
    )

    (setq
      Val_m (getreal
       "\nVeuillez saisir la valeur de la distance (en m) :"
     )
    )

    (Ins_Bloc
      choix_unit
      Vref
      (strcat (rtos Val_m 2 2) " m")
    )

    ;;récup nom_bloc
    (setq nom_bloc2 (entlast))

    (initget 1 "Oui Non")		;restreins l'utilisateur à choisir entre les deux conditions pour réitérer l'opération
    (setq Choix_utilisateur
    (getkword
      "\nVoulez vous tracer un nouvel axe ? [Oui/Non]"
    )
    )
    (cond
      ((= Choix_utilisateur "Oui")
(while
  (setq
    m_ins (getreal "\nVeuillez saisir le niveau NGF (en m) :")
  )
   (setq Dist_ins
	  (list	(+ (car P1) (* (- m_ins Val_m) coeff_unit))
		(cadr P1)
		(caddr P1)
	  )
   )

   (Ins_Bloc
     choix_unit
     Dist_ins
     (strcat (rtos m_ins 2 2) " m")
   )

   (command "_XLINE" "_V" Dist_ins "")
)
      )
    )

;;;FIN DU PROGRAMME

    (reinit)				;RàZ
   )

J'ai donc 3 problèmes qui sont les suivants :

1 / Dans la partie axe horizontaux, la première valeur à un souci au niveau de son décalage par rapport au point de référence. Pour les suivantes le décalage s'effectue sans problème. De fait si comme premier point je lui renseigne 10 et que par la suite après avoir renseigné 11, 12 ...etc je lui renseigne de nouveau 10 cette fois ci seulement il sera bien placé avec un décalage par rapport au point de référence.

2 / La partie axe verticaux ne fonctionne pas du tout. J'ai cherché un peu partout (dont le site de Didier qui d'ailleurs je remercie pour son travail) mais sans succès. J'ai utilisé la même idée pour les axes horizontaux et je n'arrive pas à comprendre là où cela fait défaut. De ce que j'aurais compris après avoir demander des renseignements il se pourrait que la commande "-INSERER" a deux versions d'exécution :

- la première, elle va demander le nom, puis les échelles X/Y, l'angle de rotation, la définition des attributs

- la seconde, elle va demander le nom, l'échelle générale, l'angle de rotation, la définition des attributs.

Or dans la partie axe verticaux, cette commande utilise sa deuxième version ce qui expliquerait les erreurs. Mais je n'ai pas trouvé plus d'informations dessus et ni comment choisir entre ces versions (si elles existent...)

3 / Ici j'ai un problème mineur, mon bloc BLOC_DIST_ quand je l'insère par le programme a une rotation de 91 degrés alors que lorsque je l'ai créé j'avais bien précisé 0° (ou 90°). Du coup il penche légèrement.

Voilà, j'espère que malgré tout ce temps quelqu'un pourra m'aider. En attendant voilà une image représentant ce que donne le programme :

Et ci-joint le DWG qui me permet de faire des tests du programme avec les blocs nécessaires (http://fromsmash.com/ff4ebff4-6fd3-11e9-b6fe-06812412be8a)

PS : Je tiens à rappeler que je suis débutant dans l'utilisation de la programmation Lisp donc si vous voyez une quelconque amélioration du programme possible n'hésitez surtout pas ! (avec une explication s.v.p) :)

PS 2 : Une fois ce programme fonctionnel, je comptais ajouter en début de programme un choix utilisateur entre clavier et souris. La réponse Clavier serait pour le programme ci-dessus et pour la réponse Souris, j'aimerai faire quelque chose dans le style de ce que m'avait proposé x_all, où (après avoir choisi un point de référence et renseigné son niveau NGF) l'utilisateur a juste à cliquer où il veut sur le dessin et cela indiquera un niveau NGF (avec insertion d'un bloc ou juste une polyligne)

Merci à vous,

Bonne journée.

Ksow

didier · le 6 mai 2019

Coucou

Tout d'abord j'aimerais savoir si cette routine est pour :

- Dessiner des façades en rentrant des altitudes est des abscisses ?

- Faire la cotation des façades dessinées précédemment

Je ne comprends pas ce que tu demandes en 1

Est-il possible que le premier point cliqué ait une autre valeur que 0.00 ?

C'est à dire que tu montres une ligne à 512.36 (par exemple) et quand tu demandes un point à 522.36 il dessine une ligne à 10.00 de la référence

Sur mon site tu ne trouveras pas d'explication à ce genre de questionnement, c'est dans l'algo que ça se gère et dans ta tête, moi j'explique ce que font les fonctions, ensuite sachant ce qu'elles offrent comme possibilité tu t'en sers pour telle ou telle autre chose

En trois je comprends pas

Cette routine me paraît "lourde", il faut réfléchir à ne pas faire taper l'utilisateur tout le temps

Réfléchir aussi aux boucles car tu poses la question si on veut continuer mais jamais tu ne permets de cesser

Ensuite les "droites" c'est vraiment utile ?

Tout ça sont des pistes de recherche pour aider à l’amélioration

Tu fais ce programme pourquoi ? pour un TFE ou pour le travail ?

Amicalement

Ksow · le 6 mai 2019

Bonjour didier,

Tout d'abord merci pour ta réponse.

Alors pour ta première question, ce qu'il se passe c'est que lorsque je lance mon programme, après avoir choisi l'unité et le point de référence, il est demandé à l'utilisateur d'entrer le niveau NGF de ce premier point. Ici on peut y entrer n'importe quel valeur (j'ai juste prit l'habitude de commencer par 10.00 NGF lors de mes essais). Donc on a notre premier niveau qui s'insère or il s'insère là où je clique (au niveau du point de référence). Puis quand j'insère d'autres niveaux eux sont décalé sur le côté et si jamais je remet la même valeur que le premier niveau (ici 10.00 NGF) il se placera comme les autres avec un décalage sur le côté.

Du coup mon souci est que le premier niveau NGF renseigné ne veut pas faire se décalage comme tu peux le voir sur mon screen avec le premier 10.00 NGF collé au "pseudo-bâtiment" et l'autre placé correctement.

Pour ton site j'avais remarqué mais je tenais simplement à te remercier car il m'a tout de même bien servir pour savoir comment fonctionne certaines fonctions. Voilà tout :)

Pour le trois, comme je l'ai précisé c'est un problème disons mineur. En fait lorsque j'insère mon bloque je ne sais pourquoi mais il a une rotation de 91° (chose que je n'ai pas prévu à sa création) et je me retrouve donc avec mon bloc avec un angle de 1° par rapport à l'horizontal mais je ne sais pas pourquoi il applique une telle rotation sans que je lui précise.

Sinon pour mon problème majeur, je vais essayé de l'expliquer un peu mieux.

Dans mon programme j'ai créé une fonction d'insertion de bloc.

(defun Ins_Bloc	(choix_unit Pt Ht_NGF)
 (setq blc_name (strcat "BLOC_" axe unit))
 (command "-inserer" blc_name Pt 1 1 0 Ht_NGF)
)

Elle me sert à insérer mes blocs en fonction de certains critère.

(setq blc_name (strcat "BLOC_" axe unit))

ici "axe" me permet de choisir entre NGF ou DIST et "unit" entre _mm, _cm, m. Sachant que j'ai 6 blocs qui se nomment respectivement :

- BLOC_NGF_mm

- BLOC_NGF_cm

- BLOC_NGF_m

- BLOC_DIST_mm

- BLOC_DIST_cm

- BLOC_DIST_mm

Du coup grâce à cette fonction je peux choisir quel bloc je veux selon mes choix. Cela marche très bien avec les 3 premiers blocs mais lorsque je choisi les blocs BLOC_DIST_xx j'ai une erreur. Comme on peut le voir dans la barre de commande dans le screen que j'ai transmis plus haut, le programme affecte directement la valeur aux attributs et donc lorsque je rentre ma valeur à l'aide du "getreal" et bien il prend ça pour une commande. Or la commande : 2.00 m n'existe pas bien évidemment.

Voici un screen permettant d'illustrer mes propos, dans le premier menu c'est lorsque j'insère un bloc BLOC_NGF et que tout se passe bien. Dans le deuxième cas c'est la fameuse erreur dont je parle :

C'est pourquoi j'ai pensé à ce que j'ai appris lors de mes recherches, comme quoi la commande "-INSERER" aurait deux versions d'utilisation. Et je me dis que c'est peut être de là que vient le problème mais il se peut que je fasse complètement fausse route. Dans tout les cas je n'arrive pas à trouver de solution malgré mes recherches.

Pour finir, concernant mon programme, je suis étudiant en alternance en licence professionnelle et il s'agit de mon projet de fin d'étude (enfin disons plutôt que c'est une partie de mon projet). Mon tuteur d'entreprise m'a demandé de réaliser un programme LISP pour lui permettre de gagner du temps lors de la réalisation de coupe ou d'élévation.

Il m'a bien indiqué qu'il souhaitait que cela fasse un quadrillage avec en horizontal les niveaux NGF et à la vertical la distance en m.

Ensuite il m'a aussi précisé qui ne souhaitait pas de boîte de dialogue car selon lui cela ferait perdre du temps mais qu'il préférait rentrer des renseignement dans la barre de commande AutoCAD.

Ainsi le but de mon programme et de faire quelques demande en début de programme pour préparé celui-ci (unité, point de référence) et puis de continuer en entrant autant de niveaux que l'on souhaite. Pour passer à la suite il suffit de faire "entrée" sans indiquer d'autres valeurs et idem dans la partie des axes verticaux.

Je précise tout de même que lorsque je rendrai mon programme, j'y ajouterai une notice d'utilisation.

J'espère avoir été assez clair cette fois ci et que le pavé que j'ai écrit ne soit pas trop imbuvable, bonne journée !

Salutation,

didier · le 6 mai 2019

Coucou

Je regarde ce dont tu parles pour tes blocs

Par contre je trouve que c'est une façon surprenante de travailler pour dessiner des façades, je n'en vois pas trop la finalité

Si c'est pour un TFE ça va le faire mais pour "travailler" je vois pas trop à quoi ça peut servir...

Amicalement

didier · le 6 mai 2019

Coucou

Je ne sais pas trop quoi te répondre pour tes blocs

J'ai aussi constaté ce que tu dis alors j'ai décomposé le bloc puis redéfini sous le même nom....

Et tout marche bien, tiens-nous au courant.

Amicalement

Ksow · le 7 mai 2019

Bonjour,

merci didier pour ta réponse et effectivement je ne sais pas quoi dire non plus... j'ai décomposé et redéfini mes blocs "BLOC_DIST" et cela fonctionne.

Par contre, je ne comprend vraiment pas pourquoi j'ai eu un tel problème ? Surtout qu'il me semble avoir essayé avec d'autres blocs. Cela reste un mystère du Lisp pour moi.

Du coup tout fonctionne, ou presque! J'ai toujours ce même souci : lorsque j'insère le premier point demandé il n'applique pas le décalage prévu et cela me donne ça :

Mon lien

Comme on peut le constater, les niveaux 10.00 NGF et 0.00 m reste sur le point de référence. J'ai transmis mon programme à un ami et de chez il n'aurait pas ce problème apparemment. J'aimerai donc comprendre ce qui me fait défaut..

Enfin, comme je l'ai dit dans mes précédents messages, si quelqu'un voit une potentielle façon d'améliorer ce programme je suis preneur.

Merci à vous d'avoir prit le temps de m'aider, je met mon programme (fonctionnel) en fin de message au cas où cela pourrait servir.

Bonne journée.

;;                                      +---------------------------+
;;                                      |        Projet : NGF       |
;;                                      +---------------------------+

;;;*****************
;;;     DONNEES
;;;*****************

;;Récupération et redéfinition des données utilisateur
(defun init ()
 (setq acrobj (getvar "OSMODE"))	;Accrochage aux objets
 (setq units_angle (getvar "AUNITS"))	;Unités angulaire
 (setq nbdeci (getvar "LUPREC"))	;Nombre de décimal
 (setq dimz (getvar "DIMZIN"))
				; enregistrement des valeurs initiales de la variable système
 (setq attreq (getvar "ATTREQ"))
 (setq attdia (getvar "ATTDIA"))
 (setq units (getvar "INSUNITS"))

 (setvar "OSMODE" 167)			;Accrobj (Ext'/Mil'/Centre/Intersect'/Perpendi')
 (setvar "AUNITS" 0)			;Angle en degrés
 (setvar "LUPREC" 2)			;Décimale choisie : 2
 (setvar "DIMZIN" 0)
				; modification des valeurs courantes de la variable système
 (setvar "ATTREQ" 1)
 (setvar "ATTDIA" 0)

)

;;RàZ des modifications des données utilisateur
(defun reinit ()
 (setvar "OSMODE" acrobj)
 (setvar "AUNITS" units_angle)
 (setvar "PLINEWID" 0)
 (setvar "DIMZIN" 8)
 (setvar "ATTREQ" attreq)
 (setvar "ATTDIA" attdia)
 (setvar "INSUNITS" units)
)

;;Fonction d'insertion des blocs

(defun Ins_Bloc	(choix_unit Pt Ht_NGF)

 (setq blc_name (strcat "BLOC_" axe unit))
 (command "-inserer" blc_name Pt 1 1 0 Ht_NGF)

)

;;; *****************
;;;     PROGRAMME
;;; *****************

(defun c:NGF ()
 (init)				;Initialisation

				;Vérification de l'existance du calque NGF
 (if (not (tblsearch "LAYER" "00-QUADRILLAGE-NGF"))
				;Création du calque NGF (s'il est inexistant)
   (command "_LAYER"	       "N"		 "00-QUADRILLAGE-NGF"
     "CO"	       "230"		 "00-QUADRILLAGE-NGF"
     "TL"	       "AXES"		 "00-QUADRILLAGE-NGF"
     ""
    )
 )

 (command "_LAYER" "CH" "00-QUADRILLAGE-NGF" "")
				;Rend courant le calque
 (setvar "CECOLOR" "DUCALQUE")

				;Choix de l'unité de dessin
 (initget 1 "MIllimetre CEntimetre MEtre")
 (setq	choix_unit
 (getkword
   "\nSpécifier l'unité de dessin [MIllimetre/CEntimetre/MEtre]"
 )
 )

 ;;condition pour choisir l'unité d'échelle
 (cond
   ((= choix_unit "MIllimetre")
    (setq unit	"_mm"
   coeff_unit
    1000
    )
    (setvar "INSUNITS" 4)
   )
   ((= choix_unit "CEntimetre")
    (setq unit	"_cm"
   coeff_unit
    100
    )
    (setvar "INSUNITS" 5)
   )
   ((= choix_unit "MEtre")
    (setq unit	"_m"
   coeff_unit
    1
    )
    (setvar "INSUNITS" 6)
   )
 )

;;; AXES HORIZONTAUX

    (setq axe "NGF")

    ;;insertion bloc NGF
    (setq
      Pref (getpoint "\nVeuillez renseigner le point de référence.")
    )
    (setq P0 (list (- (car Pref) (* 2 coeff_unit))
	    (cadr Pref)
	    (caddr Pref)
      )
    )
    (command "_XLINE" "_H" Pref "")


    (setq Val_NGF (getreal "\nVeuillez saisir le niveau NGF (en m) :"))

    (Ins_Bloc
      choix_unit
      Pref
      (strcat (rtos Val_NGF 2 2) " NGF")
    )

    ;;récup nom_bloc
    (setq nom_bloc (entlast))

    (initget 1 "Oui Non")		;restreins l'utilisateur à choisir entre les deux conditions pour réitérer l'opération
    (setq Choix_utilisateur
    (getkword
      "\nVoulez vous tracer un nouveau niveau NGF ? [Oui/Non]"
    )
    )
    (cond
      ((= Choix_utilisateur "Oui")
(while
  (setq
    NGF_ins
     (getreal "\nVeuillez saisir le niveau NGF (en m) :")
  )
   (setq P_ins
	  (list	(car P0)
		(+ (cadr P0) (* (- NGF_ins Val_NGF) coeff_unit))
		(caddr P0)
	  )
   )

   (Ins_Bloc
     choix_unit
     P_ins
     (strcat (rtos NGF_ins 2 2) " NGF")
   )

   (command "_XLINE" "_H" P_ins "")
)
      )
    )

;;; AXES VERTICAUX

    (setq axe "DIST")

    ;;insertion bloc DIST
    (command "_XLINE" "_V" Pref "")
    (setq Vref	(list (car Pref)
	      (+ (cadr Pref) (* 10 coeff_unit))
	      (caddr Pref)
	)
    )

    (setq
      Val_m (getreal
       "\nVeuillez saisir la valeur de la distance (en m) :"
     )
    )

    (Ins_Bloc
      choix_unit
      Vref
      (strcat (rtos Val_m 2 2) " m")
    )

    ;;récup nom_bloc
    (setq nom_bloc2 (entlast))

    (initget 1 "Oui Non")		;restreins l'utilisateur à choisir entre les deux conditions pour réitérer l'opération
    (setq Choix_utilisateur
    (getkword
      "\nVoulez vous tracer un nouvel axe ? [Oui/Non]"
    )
    )
    (cond
      ((= Choix_utilisateur "Oui")
(while
  (setq
    m_ins (getreal "\nVeuillez saisir le niveau NGF (en m) :")
  )
   (setq Dist_ins
	  (list	(+ (car Vref) (* (- m_ins Val_m) coeff_unit))
		(cadr Vref)
		(caddr Vref)
	  )
   )

   (Ins_Bloc
     choix_unit
     Dist_ins
     (strcat (rtos m_ins 2 2) " m")
   )

   (command "_XLINE" "_V" Dist_ins "")
)
      )
    )

;;; *****************
;;; FIN DU PROGRAMME
;;; *****************
 
    (reinit)				;RàZ
   )

didier · le 7 mai 2019

Coucou

Ce n'est pas un problème LISP c'est sans doute un dysfonctionnement lors de la création du bloc

Si le LISP était en cause refaire le bloc n'aurait rien changé.

Amicalement

Ksow · le 20 juin 2019

Bonjour à tous!

Je reviens vers vous car, avec les quelques temps libre que j'ai eu dernièrement, j'ai modifié mon programme.

Tout semble fonctionner correctement mis à part le fait que j'ai une erreur que je n'arrive pas à résoudre alors que cela doit être tout bête, je ne vois pas ce qui fait défaut.

Avant tout je vais expliqué le fonctionnement du code que je vous joins à la suite.

Alors le but n'a pas changé, il s'agit de réaliser un quadrillage de référence pour dessiner une coupe ou une élévation. Pour cela j'ai permis à l'utilisateur d'utiliser deux façon de faire que j'ai nommé "Point" & "Saisie".

- Lorsque l'utilisateur choisi "Point" il devra (pour tracer le quadrillage) cliquer sur justement des points du dessin après avoir renseigné un point de référence. Les valeurs des points suivant se feront en fonction de ce point de référence.

- Ensuite avec "Saisie", c'est dans le cas où l'utilisateur connait les valeurs dont il a besoin, auquel cas il a juste à les renseigner dans la barre de commande et le quadrillage se réalisera par lui même (toujours après avoir renseigné un point de référence au préalable)

Donc voici le code :

;;                                      +---------------------------------------------------+
;;                              	|   	Projet : QUADRILLAGE DE REFERENCE	    |
;;                                      +---------------------------------------------------+

;;;*****************
;;;     DONNEES
;;;*****************

(defun init ()

(setq acrobj (getvar "OSMODE"))
(setq units_angle (getvar "AUNITS"))
(setq nbdeci (getvar "LUPREC"))
(setq attreq (getvar "ATTREQ"))
(setq attdia (getvar "ATTDIA"))
(setq units (getvar "INSUNITS"))

(setvar "OSMODE" 167)
(setvar "AUNITS" 0)
(setvar "LUPREC" 0)
(setvar "ATTREQ" 1)
(setvar "ATTDIA" 0)

)

(defun reinit ()

(setvar "OSMODE" acrobj)
(setvar "AUNITS" units_angle)
(setvar "PLINEWID" 0)
(setvar "ATTREQ" attreq)
(setvar "ATTDIA" attdia)
(setvar "INSUNITS" units)
(setvar "LUPREC" nbdeci)

)

(defun Ins_Bloc (Pt Ht_NGF)

(setq bloc_name (strcat "BLOC_" axe unit))
(command "-INSERER" bloc_name Pt 1 1 0 Ht_NGF)

)

;;; *****************
;;;     PROGRAMME
;;; *****************

(defun c:NGF ()

(init)
(if (not (tblsearch "LAYER" "00-QUADRILLAGE-NGF"))
	(command "_LAYER" "N" "00-QUADRILLAGE-NGF" "CO" "230" "00-QUADRILLAGE-NGF" "TL" "AXES" "00-QUADRILLAGE-NGF" "")
)
(command "_LAYER" "CH" "00-QUADRILLAGE-NGF" "")
(setvar "CECOLOR" "DUCALQUE")
(initget 1 "MIllimètre CEntimètre MEtre")
(setq Choix_unit (getkword "\nSpécifier l'unité de dessin : [MIllimètre/CEntimètre/MEtre]  "))
(cond
	((= Choix_unit "MIllimètre")
		(setq unit "mm" coeff_unit 1000.0)
		(setvar "INSUNITS" 4)
	)
	((= Choix_unit "CEntimètre")
		(setq unit "cm" coeff_unit 100.0)
		(setvar "INSUNITS" 5)
	)
	((= Choix_unit "MEtre")
		(setq unit "m" coeff_unit 1.0)
		(setvar "INSUNITS" 6)
	)
)
(setq axe "NGF_")
(prompt "\nDessin des axes HORIZONTAUX :")
(initget 1 "Point Saisie")
(setq Choix_trace (getkword "\nVeuillez préciser si vous souhaitez choisir des points ou si vous souhaitez entrer les niveaux NGF [Point/Saisie] :  "))
(setq Pt_ref (getpoint "\nVeuillez renseigner un point de référence :  "))
(setq Y-Pt_ref (cadr Pt_ref))
(setq X-Pt_ref (- (car Pt_ref) (* 1 coeff_unit)))
(setq Ht_ref (getreal "\nVeuillez renseigner le niveau NGF du point de référence (en m) :  "))
(command "_XLINE" "H" Pt_ref "")
(Ins_Bloc (list X-Pt_ref Y-Pt_ref (caddr Pt_ref)) (strcat (if (< Ht_ref 0) "-" "+") (rtos Ht_ref 2 2) " NGF"))
(cond
	((= Choix_trace "Point")
		(while
		  (setq Pt_Ins (getpoint "\nVeuillez renseigner un point altimétrique (ENTRER pour terminer) :  "))
			(setq Ht_Ins (+ Ht_ref (/ (- (cadr Pt_Ins) Y-Pt_ref) coeff_unit)))
			(setq Pt_Ins (list X-Pt_ref (cadr Pt_Ins) (caddr Pt_ref)))
			(command "_XLINE" "H" Pt_Ins "")
			(Ins_Bloc Pt_Ins (strcat (if (< Ht_Ins 0) "-" "+") (rtos Ht_Ins 2 2) " NGF"))
		)
	)
	((= Choix_trace "Saisie")
		(while (setq Ht_Ins (getreal "\nVeuillez renseigner un niveau NGF (en m) (ENTRER pour terminer) :  "))
			(setq Pt_Ins (list X-Pt_ref (+ Y-Pt_ref (* Ht_Ins coeff_unit)) (caddr Pt_ref)))
			(command "_XLINE" "H" Pt_Ins "")
			(Ins_Bloc Pt_Ins (strcat (if (< Ht_Ins 0) "-" "+") (rtos Ht_Ins 2 2) " NGF"))
		)
	)
)
(setq axe "DIST_")
(command "_XLINE" "V" Pt_ref "")
(setq Y-Pt_ref (- (cadr Pt_ref) (* 2 coeff_unit)))
(setq X-Pt_ref (car Pt_ref))
(Ins_Bloc (list X-Pt_ref Y-Pt_ref (caddr Pt_ref)) (strcat "+" "0.00" " m"))
(prompt "\nDessin des axes VERTICAUX :")
(initget 1 "Point Saisie")
(setq Choix_trace (getkword "\nVeuillez préciser si vous souhaitez choisir des points ou si vous souhaitez entrer les distances [Point/Saisie] :  "))
(setq Dist_ref 0)
(cond
	((= Choix_trace "Point")
		(while (setq Pt_Ins (getpoint "\nVeuillez renseigner un point distant du point de référence (ENTRER pour terminer) :  "))
			(setq Dist_Ins (+ Dist_ref (/ (- (car Pt_Ins) X-Pt_ref) coeff_unit)))
			(setq Pt_Ins (list (car Pt_Ins) Y-Pt_ref (caddr Pt_ref)))
			(command "_XLINE" "V" Pt_Ins "")
			(Ins_Bloc Pt_Ins (strcat (if (< Dist_Ins 0) "-" "+") (rtos Dist_Ins 2 2) " m"))
		)
	)
	((= Choix_trace "Saisie")
		(while (setq Dist_Ins (getreal "\nVeuillez renseigner une distance par rapport au point de référence (en m) (ENTRER pour terminer) :  "))
			(setq Pt_Ins (list (+ X-Pt_ref (* Dist_Ins coeff_unit)) Y-Pt_ref (caddr Pt_ref)))
			(command "_XLINE" "V" Pt_Ins "")
			(Ins_Bloc Pt_Ins (strcat (if (< Dist_Ins 0) "-" "+") (rtos Dist_Ins 2 2) " m"))
		)
	)
)
(reinit)

)

Mon problème est le fait que lorsque je veux faire mes premiers axes horizontaux, si je choisi de passer par "Saisie" et que je renseigne un point de référence, il l'affecte directement à 0 peu importe ce que je renseigne comme valeur. De fait les valeurs renseigné par la suite ont un gros décalage. Ci-dessous un screen pour vous illustrer le problème, lorsque je rentre 10 en valeur de référence il force la valeur à 0.

(Ensuite j'ai toujours ce problème concernant le point d'insertion du premier bloc qui ne se déplace pas sur la gauche par rapport au point de référence comme les autres niveaux)

Merci pour vos conseils depuis le début, j'ai pu m'améliorer au fur et à mesure et j'espère que vous allez pouvoir continuer à m'aider.

Bonne journée.

Olivier Eckmann · le 20 juin 2019

Bonjour,

pour le problème de décalage par saisie, c'est que tu décales par rapport à ton Y_pt_ref de la valeur saisie, sans tenir compte du la valeur HT_Ref correspond à ce point.

il faut modifier ta ligne

(setq Pt_Ins (list X-Pt_ref (+ Y-Pt_ref (* Ht_Ins coeff_unit)) (caddr Pt_ref)))

par

(setq Pt_Ins (list X-Pt_ref (+ Y-Pt_ref (* (- Ht_Ins Ht_Ref) coeff_unit)) (caddr Pt_ref)))

Olivier

Ksow · le 20 juin 2019

Bonjour,

pour le problème de décalage par saisie, c'est que tu décales par rapport à ton Y_pt_ref de la valeur saisie, sans tenir compte du la valeur HT_Ref correspond à ce point.
il faut modifier ta ligne
(setq Pt_Ins (list X-Pt_ref (+ Y-Pt_ref (* Ht_Ins coeff_unit)) (caddr Pt_ref)))
par
(setq Pt_Ins (list X-Pt_ref (+ Y-Pt_ref (* (- Ht_Ins Ht_Ref) coeff_unit)) (caddr Pt_ref)))
Olivier

Tout simplement...

Merci beaucoup @Olivier Eckmann cela fonctionne très bien maintenant ! J'avais beau lire et relire mes lignes de codes impossible de voir cette erreur qui était pourtant pas si compliqué.

Bonne journée

---------------------------------------------------------------

EDIT :

J'ai remarqué que ma partie "Point" est limité par le SCU. En effet, si je veux faire mon quadrillage à partir d'un plan qui a une rotation quelconque cela ne marchera pas... Je vais travaillé sur ce problème.

	((= Choix_trace "Point")
		(while
		  (setq Pt_Ins (getpoint "\nVeuillez renseigner un point altimétrique (ENTRER pour terminer) :  "))
			(setq Ht_Ins (+ Ht_ref (/ (- (cadr Pt_Ins) Y-Pt_ref) coeff_unit)))
			(setq Pt_Ins (list X-Pt_ref (cadr Pt_Ins) (caddr Pt_ref)))
			(command "_XLINE" "H" Pt_Ins "")
			(Ins_Bloc Pt_Ins (strcat (if (< Ht_Ins 0) "-" "+") (rtos Ht_Ins 2 2) " NGF"))
		)
	)

Ksow · le 27 juin 2019

Bonjour!

Oui c'est encore moi, désolé de toujours vous solliciter mais j'ai du mal avec la programmation LISP...

Comme je l'ai dit dans la partie "EDIT" de mon message au-dessus je cherche un moyen d'intervenir sur le SCU pour permettre à l'utilisateur d'utilisé la souris pour faire le quadrillage. Le but étant de pouvoir s'appuyer sur un plan incliné par rapport à notre quadrillage par exemple et les axes se créent selon la distance entre les deux clics de l'utilisateur.

Je ne sais pas si j'ai été assez clair, du coup je vous ajoute un dessin en espérant être compréhensible.

Donc j'ai essayé d'intervenir sur le SCU avec (command "_ucs") et sans succès. J'ai pensé à créer un 3ème choix "Distance" en plus des deux premiers "Point" et "Saisi".

De plus avec des recherches je suis tombé sur un sujet où un utilisateur utilise ceci :

- sauvegarde du SCU courant

(if (tblsearch "UCS" "$$temp$$")
  (command "_ucs" "_d" "$$temp$$")
)
(command "_ucs" "_s" "$$temp$$")

- retour au scu sauvegardé :

(command "_ucs" "_r" "$$temp$$")
(command "_ucs" "_d" "$$temp$$")

J'aimerai savoir d'où sors le " $$temp$$ " et comment il fonctionne? C'est la première fois que je vois ça et j'aimerai ne pas copier bêtement sans comprendre... car pour l'instant j'ai prévu de les réutiliser dans mes fonctions de données au début (init) et (reinit).

Ma partie de programme :

((= Choix_trace "Distance")
		(while
			(setq Pt_1 (getpoint "\n Spécifier le point de départ"))
			(setq Pt_2 (getpoint "\n Spécifier le point suivant"))
                       (command "_ucs" ...)  ;Problème ici, je ne sais pas quoi rentrer après "_ucs".
		  ;J'ai essayé de voir sur autocad tout les choix possible je n'arrive pas à trouver une solution malgré plusieurs essais.
		  
		  (setq Pt_dist (- (cadr Pt_2) (cadr Pt_1)))
		  (setq Pt_Ins (list X-Pt_ref (+ Y-Pt_ref (* Pt_dist coeff_unit)) (caddr Pt_ref)))
			   
		  	(command "_XLINE" "H" Pt_Ins "")
		  (Ins_Bloc Pt_Ins (strcat (if (< Ht_Ins 0) "-" "+") (rtos Ht_Ins 2 2) " NGF"))
		  )
	 )

Merci!

didier · le 27 juin 2019

Coucou

Je te prie de m'excuser si je suis trop "cash" mais je pense que tu te diriges à grands pas dans une impasse

Ton énoncé est simple et c'est une usine à gaz que tu es en train de monter !

Je pense que quelquefois, et ça m'arrive encore assez souvent, il faut savoir repartir d'une feuille blanche

Définis ton SCU et ensuite il vaut mieux créer des lignes que décaler des objets

La création étant assez simple parce que ton "altitude" n'est que la valeur Y du SCU courant

Rien de rare...

On est OK ?

lecrabe · le 27 juin 2019

Hello Didier - Le Vieux Hibou Grincheux & Malefique

+1 avec toi !

Bye, lecrabe "triste"

Ksow · le 12 juillet 2019

Bonjour,

Tout d'abord aucun souci sur le fait d'être cash, au contraire je préfère qu'on me dise directement si quelque chose ne va pas plutôt que tourner 3h autour du pot. :)

Actuellement je suis toujours en train de chercher , dès que j'ai l'occasion, une solution à mon problème énoncé plus tôt et je n'ai encore aucun résultat. J'enchaîne erreur sur erreur hahaha :D

Du coup depuis le temps, le fait de devoir chercher et essayer plusieurs lignes de codes je me suis posé une question toute bête : Est ce qu'il est possible de passer directement tout une sélection en

;commentaire

?

Car il m'arrive souvent d'essayer plusieurs lignes codes puis je les passent en commentaire une par une pour essayer autres choses sans perdre ce que j'ai fait au préalable par exemple et le fait de devoir aller devant chaque début de ligne placer ";" cela devient fastidieux.

Après il se peut aussi que je m'y prends mal dans ma "phase de recherche" ?

Sinon pour revenir sur le sujet, je travaille sur une feuille vierge sur ma partie "Distance" mais je ne comprends pas bien en quoi je me dirigeai vers une impasse et vers une usine à gaz ?

Mon but est juste de proposé 3 façon d'utiliser le programme pour que celui-ci s'adapte à tout les critères possible.

- On souhaite réalisé le quadrillage à partir de NGF connu on utilise la partie "Saisie"

- On ne connait pas les niveaux NGF et on souhaite réalisé le quadrillage à la souris à partir d'un plan de référence on utilise la partie "Point"

- Le plan de référence est incliné et donc n'a pas de SCU correspond à notre quadrillage on utilise la partie "Distance"

A savoir que si mon programme ne cesse d'évoluer (peut être dans la mauvaise direction de ce que j'ai cru comprendre) c'est parce que j'essaye de l'adapter en fonction des demandes de mon tuteur en entreprise et de ses observations (ainsi que les miennes) lors de l'utilisation du programme.

Si vous avez des idées ou des réponses à m'apporter pour l'améliorer et éviter que j'aille dans une impasse, merci de bien vouloir m'aider.

Bonne journée,

Ksow

Connexion

[RESOLU] Quadrillage de référence

Messages recommandés

Ksow

didier

didier

Ksow

DenisHen

didier

x_all

DenisHen

Ksow

didier

Ksow

Ksow

didier

Ksow

didier

didier

Ksow

didier

Ksow

Olivier Eckmann

Ksow

Ksow

didier

lecrabe

Ksow

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante