Vous trouverez ici tous les outils que j'utilise pour faire des plans de ferraillage, ainsi que quelques exemples de plans.

J'ai fait un menu qui donne accès à chaque module. C'est du lisp/dcl compilé en vlx.

Comme j'ai été sollicité par ailleurs et si ça peut intéresser du monde, j'ai fait une

Merci à tous ceux, ils se reconnaitront, qui ont participé indirectement à ce projet en répondant à mes questions et en mettant des lignes de code à disposition sur CADXP. Il y a encore du travail pour améliorer mais, pour l'instant, ça me convient pour mon travail quotidien.

Il y a sans doute mieux, mais c'est plus cher !

Amicalement

Vincent

Je vous propose de tester ScanDXF, un outil de mon cru qui permet de compter les blocs d'un dessin et de récupérer les propriétés (calque, longueur, aire) des lignes, polylignes, splines, etc.

Avec AutoCAD, ça peut bien sûr être fait sans passer par un programme externe, en Lisp par exemple.

Mais ScanDXF permet de le faire même avec une version LT !

Il peut-être utilisé soit directement en "standalone" pour analyser un ficher DXF, soit lancé depuis AutoCAD pour analyser les objets sélectionnés dans le dessin.

Le principe est d'utiliser dans AutoCAD une macro qui va exporter les objets en DXF, puis lancer ScanDXF, lequel va analyser les objets décrits dans ce DXF, calculer les longueurs, surfaces, et afficher un rapport.

Procédure d'installation :

- télécharger le Zip

- décompresser le Zip dans un répertoire de votre choix.

ScanDXF est maintenant directement utilisable pour analyser un fichier DXF.

Pour pouvoir le lancer depuis AutoCAD, quelques étapes supplémentaires sont nécessaires :

- lancer ScanDXF.exe et se rendre dans l'onglet Options

- copier la commande d'installation pour AutoCAD ou celle pour LT, suivant la version utilisée

- lancer AutoCAD ou LT

- coller dans la ligne de commande la macro d'installation (puis appuyer sur Entrée si besoin)

- créer un bouton dans la boîte de dialogue CUI, avec comme macro la macro de bouton affichée dans l'onglet Infos de ScanDXF

OU, plus simple,

- charger le menu partiel scandxf.cuix (depuis la boîte de dialogue CUI, ou avec la commande CHARGIUPERSO). Ce menu rajoute à AutoCAD une mini barre d'outils (un seul bouton) pour les vieux :P , et un bouton dans l'onglet Sortie du Ruban pour les djeunz. :P

- C'est prêt ! B)

Utilisation:

- dans AutoCAD, cliquer sur le bouton ScanDXF et sélectionner les objets, valider

OU

- "gripper"/sélectionner les objets par la méthode de votre choix (clic clic, Sélection rapide, Sélectionner similaire, etc.), puis cliquer sur le bouton ScanDXF.

- dans ScanDXF, vous pouvez filtrer les résultats par type d'objet et/ou par calque, trier par colonne...

- liste des objets supportés pour l'instant : blocs (y compris dynamiques), polylignes "légères", lignes, cercles, points, arcs, splines, ellipses.

NB: la longueur des splines est une valeur approchée, elle diffère légèrement de celle indiquée dans AutoCAD.

Résultat :

Si vous trouvez des bugs, ou si vous avez des suggestions d'amélioration, je suis tout ouïe ! :)

-- Mises à jour --

29/04/2012: Beta 2

- support des Faces 3D

- affichage du nom des couleurs 1 à 7 (au lieu du numéro)

30/04/2012: Beta 3

- correction d'un bug sur le tri des colonnes numériques

30/04/2012: Beta 4

- la liste des types d'objets et celles des calques sont masquées selon l'onglet courant

- prise en compte des insertions multiples de blocs (INSERM ou _MINSERT). Attention, dans ScanDXF les coordonnées d'insertion de ces blocs ne sont justes que si les blocs sont dans un plan parallèle au plan XY du SCG.

02/05/2012: Beta 5

amélioration de l'export Excel, les 3 onglets sont exportés en une fois dans le même classeur.

02/06/2012: Beta 6

ajout d'un onglet Calques.

01/07/2012: Beta 7

- affichage des attributs dans la vue détaillée des blocs

- réécriture complète en POO du parser dxf.

12/07/2012: Beta 8

-ajout d'une colonne affichant la largeur globale des polylignes.

02/08/2012: Beta 9

- correction d'un bug sur l'affichage du nom des blocs dynamiques

- amélioration du redimensionnement des colonnes (dans l'onglet Entités seulement pour le moment)

- possibilité de choisir les colonnes à afficher (dans l'onglet Entités seulement pour le moment)

- ajout d'un bouton pour répartir la largeur des colonnes (dans l'onglet Entités seulement pour le moment)

29/08/2012: Beta 10

- amélioration du redimensionnement des colonnes dans tous les onglets

- possibilité de choisir les colonnes à afficher dans tous les onglets

- bouton pour répartir la largeur des colonnes présent dans tous les onglets

- affichage du texte et du style de texte

- correction d'un bug qui affichait l'aire de certaines polylignes en négatif

- l'aire des polylignes et splines n'est affichée que si elles ne comportent aucune autointersection (dans les versions précédentes, une valeur fausse était affichée)

- amélioration des performances.

11/09/2012: Beta 11

- gestion des colonnes dans l'onglet Calques identique aux autres onglets

- export automatique des résultats au format csv dans le dossier "export" en utilisant le commutateur -x

- ajout d'un bouton pour l'export auto dans la barre d'outils et le groupe de fonctions AutoCAD

- les dimensions de la fenêtre sont mémorisées d'une session à l'autre + ajout d'une option dans l'onglet Infos pour réinitialiser les préférences.

09/10/2012: Beta 12

- correction d'un bug lors de l'export en CSV de textes multilignes contenant des sauts de ligne

- correction d'un bug : dernière rangée de l'onglet Entités manquante lors de l'export en CSV/Excel

- les coordonnées X, Y et Z des textes correspondent au point d'alignement (point de justification) au lieu du point d'insertion

- ajout d'une colonne pour le facteur de largeur des textes.

18/10/2012: Beta 13

- prise en charge des états de visibilité des blocs dynamiques (expérimental, à tester)

- ajout d'un bouton pour l'export au format CSV.

01/12/2012: Beta 14

- support des multilignes

- utilisation automatique du séparateur décimal défini dans Excel lors de l'export vers Excel

- correction d'un bug sur la gestion des colonnes.

09/04/2013: Beta 15

- correction d'un bug lors de la restauration de la taille de la fenêtre.

26/04/2013: Beta 16

- correction d'un bug provoquant un crash lors du calcul de l'aire des Faces 3D.

27/06/2013: Beta 17

- tri par ordre alphabétique des filtres de calques, blocs, types d'entités

- date d'expiration repoussée au 31/07/2013.

14/01/2014: Beta 18

- correction d'un bug sur les sommes lorsque le séparateur décimal système est la virgule

- date d'expiration repoussée au 31/03/2014.

29/04/2014: Beta 19

- correction d'un bug (coordonnées des entités point non affichées)

- date d'expiration repoussée au 31/07/2014.

02/03/2015: Beta 20

- correction d'un bug (longueurs des arcs non affichées)

- ajout d'une colonne affichant le rayon des arcs et cercles

- date d'expiration repoussée au 30/04/2014.

10/03/2015: Beta 21

- onglet Infos renommé en Options

- les boutons d'export ne sont plus affichés dans l'onglet Options

- ajout d'une option pour changer l'extension des fichiers exportés en txt (dans l'onglet Options).

03/07/2015: Beta 22

- correction d'un bug lors de l'export Excel (fichier vide s'il n'y a qu'un objet à exporter)

- ajout de la propriété Fermé pour les ellipses

- si un fichier nommé autorun.bat se trouve dans le même répertoire que scandxf.exe, il sera automatiquement executé en fin de traitement (uniquement si ScanDXF est lancé en mode silencieux via autoscandxf.bat)

- date d'expiration repoussée au 31/12/2015.

19/12/2015: Beta 23

- prise en charge des polylignes 3D et polylignes 2D "lourdes"

- ajout des coordonnées XYZ des extrémités de lignes dans les propriétés récupérées

- date d'expiration repoussée au 31/03/2016.

29/01/2016: Beta 24

- correction d'un bug lors de l'export CSV (fichier vide s'il n'y a qu'un objet à exporter)

- possibilité d'utiliser l'argument "-txt" ou "-csv" dans autoscandxf.bat pour forcer le format d'export auto

- le dossier de destination est ouvert automatiquement lors d'un export CSV depuis l'interface graphique.

01/02/2016: Beta 25

- lors d'un export auto, un fichier de configuration (ent_properties.cfg) permet de choisir les propriétés à extraire et leur ordre.

08/10/2016: Beta 26

- correction d'un bug provoquant un crash en cas de présence d'un bloc anonyme.

07/12/2016: Beta 27

- le nombre de colonnes de propriétés est limité à 64 pour éviter un crash (limite de RealBasic/Xojo).

20/01/2017: Beta 28

- ajout d'un message signalant la fin du traitement lors d'un export auto

 - ajout des arguments -skipEntities (ne traite que les calques) et -silent (supprime le message de fin lors d'un export auto).

30/05/2017: Beta 29

- ajout d'un onglet listant les présentations

- ajout de l'argument -layersOnly pour traiter uniquement les calques

- ajout de l'argument -layoutsOnly pour traiter uniquement les présentations

- l'argument -skipEntities traite les calques et les présentations.

04/07/2017: Beta 30

- toutes les coordonnées sont maintenant exprimées dans le SCG (implémentation de l'algorithme d'axe arbitraire)

- calcul des longueurs et aires des arcs d'ellipse.

10/10/2017: Beta 31

- ajout d'une colonne affichant l'ordre des présentations.

12/11/2017: Beta 32

- les sommets en doublon dans les polylignes sont ignorés, ce qui permet d'en calculer l'aire

- les polylignes dont les extrémités sont confondues sont considérées comme fermées.

J'ai un petit problème de géométrie pour lequel je cherche la meilleure approche (indépendamment du langage).

J'ai un ensemble de point et 3 droites partant d'un point connu en XY et réparti selon les angles A1, A2, A3.

Connaissant un rayon depuis le centre et un décalage des droites, je cherche à classer mes points en 4 catégories selon les 3 secteurs et la zone de proximité.

Je vais avoir environ 40 000 fois géométrie et 50 à 400 points à chaque fois, donc je cherche quelque chose d'assez rapide.

Merci si vous avez des idées.

Olivier

je me fait rare mais je ne vous oublie pas.
j'ai même un petit cadeau pour ceux qui font de la ventilation

j'avais besoin d'un truc en APS APD pour estimer à la louche les diamètres de ventil et je m'étais fait un tableau excel qui cumule les débit et calcule un diamètre en fonction de la vitesse limite du réseau
le pb, c'est qu'un coup sur 2, l'exutoire n'est pas à la fin..

on vante le no code et les IA?
testons

J'ai voulu tester ChatGTP, trop court (je paie pas j'ai droit qu'à qqs questions),
DeepSeek ? trop de monde et pas assez stable? à 1ere vue pas mal, mais inexploitable, sans doute il y a trop de hype il faut laisser le temps

c'est finalement Qwen qui m'a pondu ça.
https://chat.qwenlm.ai/

Alors si il y a des codeurs html ils vont rigoler, c'est pas parfait sans doute, ça marche pas sur un téléphone portable (?), et il resterait un ou deux truc à boucler pour une vrai version finale.. mais c'est fonctionnel et j'ai plus trop de temps (<acronym class=dict title= comme d'ab)

si vous la voulez hors ligne, vous pouvez directement piquer la page HTML les CCS et le JS sont dedans, 
http://joch04.free.fr/test/Air00.html

pour les plus curieux
j'ai documenté la manip...

https://docs.google.com/document/d/1R8Qm_BBw8sZOrl0Rrol6IypCY8uwxtSTuLkkm-c9kEk/edit?usp=sharing

++

de traiter les images... donc j'ai fait un truc du genre :

[url=https://ibb.co/sscSFm7][img]https://i.ibb.co/frZRC1J/delimiter-xref.gif[/img][/url]

https://ibb.co/sscSFm7

et vous comment les traiter vous ?

ça fait un mnt que je veux me faire une fonction qui sélectionne tous les blocs dynamique en ft de leur nom
J'ai piquer des bout de code à droite et à gauche, (merci (gile) et lee mac) mais je bute sur la fin

comment faire pour que quand le lisp me rend la main, les bloc soit effectivement "au bout de la souris" 
Naïvement je croyait que le rappel de Bsel à la fin ferai ce boulot comme il m'a sembler le voir faire dans ssd de (gile) mais apparemment, ça suffit pas...

Tout tourne pas trop mal il me semble sauf que rien n'est sélect bien que bsel contienne bien les bloc que je veux à l'inspection dans l'éditeur

merci de vos lumières

;; ssbn sélectionne par nom de bloc dynamique


(defun C:ssbn (/ doc-vba bs sel-vba nom-ch ent-vba sbloc bl j bsel )

  (print
    " sélectionner un bloc, retourne une sélection des blocs ayant le même non (blocdyn acceptés) "
  )

					; initialisation VL
  (vl-load-com)
  (setq doc-vba (vla-get-activedocument (vlax-get-acad-object)))
  (vla-startundomark doc-vba)		; Activer le début de l'undo



  (while (not bs) (setq bs (ssget '((0 . "INSERT")))))
					; seléctionne un bloc
  (setq sel-vba (vla-get-activeselectionset doc-vba))
					; sel-vba est le selection set courant de doc
  (setq ent-vba (vla-item sel-vba 0))	;ent-vba est le 1er élément de sel-vba

  (setq nom-ch (LM:blockname ent-vba))
  (princ nom-ch)

  ;;  sélection de tous les blocs du dessin (astuce (gile) pour prendre que les blocdyn avec un nom *u
  (setq	sbloc	(ssget "X" (list (cons 0 "INSERT") (cons 2 (strcat nom-ch ",`*U*"))) )				
	sel-vba	(vla-get-activeselectionset doc-vba)
					; sel-vba est le selection set courant de doc-vba
	j	0
	bsel	(ssadd)
  )

  (vlax-for bl sel-vba

    (if	(= (LM:blockname bl) nom-ch)
      (progn
	(ssadd (vlax-vla-object->ename bl) bsel)  
	(setq j (+ 1 j))
      )
    )
    ;; fin de if
    (print j)
  )
(print)
 bsel
)


;; Block Name  -  Lee Mac
;; Returns the true (effective) name of a supplied block reference

(defun LM:blockname (obj)
  (if (vlax-property-available-p obj 'effectivename)
    (defun LM:blockname (obj) (vla-get-effectivename obj))
    (defun LM:blockname (obj) (vla-get-name obj))
  )
  (LM:blockname obj)
)

Je vais essayer de lancer un petit challenge de géométrie.

Dans AutoCAD, pour dessiner un arc elliptique, on peut spécifier les angles de départ et de fin, mais il existe aussi une option 'Paramètres'.
Extrait de l'aide :
 

Quote

Paramètre (option spécialisée)

    Nécessite une saisie angulaire, mais crée l'arc elliptique à l'aide de l'équation vectorielle paramétrique suivante pour l'angle de chaque extrémité :

    p(angle) = c + a * cos(angle) + b * sin(angle)

    où c représente le centre de l'ellipse, tandis que les lettres a et b représentent les longueurs négatives du grand axe et du petit axe, respectivement.

En programmation d'AutoCAD, on retrouve cette notion de paramètre pour tous les objets curviligne (vlax-curve-getParamAtPoint en LISP ou Curve.GetParamAtPoint avec.NET).

On a coutume de dire qu'un petit dessin vaut mieux qu'un long discours :

Le challenge, donc, serait de définir deux fonctions (peu importe le langage) :
- AngleToParam : qui prend comme arguments une ellipse et un angle et qui renvoie le paramètre correspondant
- ParamToAngle : qui prend comme arguments une ellipse et un paramètre et qui renvoie l'angle correspondant

Exemples avec une ellipse de 10 100 unités de grand axe pour 60 unités de petit axe :
- AngleToParam d'un angle de 30° doit retourner un paramètre de 43.90°
- ParamToAngle d'un paramètre de 30° doit retourner un angle de 19.11°
- AngleToParam d'un angle de 230° doit retourner un paramètre de 243.28°
- ParamToAngle d'un paramètre de 230° doit retourner un angle de 215.57°

Les exemples sont donnés en degrés, mais pour plus de simplicité et de cohérence avec les fonction natives fonctions utiliseront les radians.

Fournissez nous le listing de votre programme AutoLISP. Gardez à l'esprit que l'art de la programmation, c'est la concision et l'élégance !

En se basant sur cette image qui représente un labyrinthe avec une forme en "P", pensez-vous qu'il soit possible de dessiner le chemin de sortie en une ligne (ou plutôt polyligne) ? 🤔

Contrainte pour la représentation du labyrinthe :
- pas de polyligne donc que des lignes et des arcs
- un calque "Mur" pour les traits épais en noir et un calque "Cloison" pour les traits fins en gris

Langage autorisé :
- Lisp 
- mais VBA et autres sont les bienvenus 😉

C'est bientôt Noël, et pour certains bientôt les vacances, et donc :

Je vous envoie un mini jeu voir micro jeu... un jeu de fléchette (très simple) !

Je vous explique un peu :

Deux modes de jeux 501 ou 301:

On marque des points qu'on soustrait a notre score et si vous arrivez PILE à zéro vous gagner sinon vous perdez...

Les petites zones extérieures doublent les points (afficher dans le prolongement du "triangle") il faut d'ailleurs finir sur l'une de ces cases !

Les petits zones intérieures triplent les points

Au centre 50 Points pour la plus petite zone et 25 plus la plus grande !

Attention il faut Finir sur un double pour tombé à zéro (exemple si vous êtes à 8, il faut finir sur un 2x4 !)

Plus le niveau est haut : plus vous serez précis (mais plus loin sera la cible)

Plus le niveau est bas : vous serez prêt de la cible mais avec une précision moindre...

(Je conseil le niveau 4) mais vous pouvez tout tester ^^

Pour lancer le jeu, il suffit de sauvegarder le dwg pour lancer le programme allez bonne fête de fin d'année ^^

- Configuration minimal :

- Autocad version complète

- Le module VBA

video d'explication

JEU_FLECHETTE_V2.zip

je suis sous outlooks pour recevoir mes mails.

et j'en recois des tonnes qui sont de la pub ou autres

depuis longtemps j'ai créer une regle ayant pour liste  la fin des adresses mails, qui me les déplace dans un dossier que je vide de temps en temps,

il y a souvent des mails de n'importe quoi qui arrive d'une meme adresse type "*****anichoice@menustreetanalys.fr"

donc j'écris a la mano dans la liste de la regle "menustreetanalys",

c'est long car je dois cliquer chaque mail, ouvrir la regle, ouvrir la liste, écrire le truc, fermer la liste, fermer la regle et recommencer.

vous n'auriez pas un programme en BASIC a rajouter au menu ( clic droit sur le mail) qui

chercherai la fin du nom de l'adresse ( apres l @ : "nenustreetanalys" , avant le "fr" )

et qui le mettrai directement dans la liste des nom d'une regle prédéfinie.

histoire de gagner un peu de temps, et eviter les faute de frappe

merci

Phil

En tombant sur cet article à propos d'un algorithme pour calculer l'enveloppe convexe d'une collection de points, je me suis dit que ça pourrait faire l'objet d'un nouveau challenge et que ça pourrait aussi être une base pour résoudre un problème plus complex posé par @Luna dans ce sujet : faire une enveloppe concave (concave hull).

Donc, il s'agit toujours d'écrire un fonction (dans le langage de son choix) qui prend en argument une liste de points et qui renvoie la liste des points qui constituent l'enveloppe convexe (convex hull) des points passés en argument. Il existe au moins un autre algorithme bien connu pour extraire l'enveloppe convexe d'une collection de points, mais comme il a déjà été souvent implémenté, je trouve plus intéressant de se pencher sur celui-là et je suppute qu'il se prête mieux à la généralisation vers une enveloppe concave (mais c'est une autre histoire...).

On doit pouvoir tester la fonction 'quickhull' via une sélection d'entités points (nodal) en dessinant une polyligne.
Exemple en LISP :
 

(defun c:test (/ ss i pts)
  (if (setq ss (ssget '((0 . "point"))))
    (progn
      (repeat (setq i (sslength ss))
	(setq pts
	       (cons (cdr (assoc 10 (entget (ssname ss (setq i (1- i))))))
		       pts
	       )
	)
      )
      (command "_pline")
      (foreach p (quickhull pts)
	(command "_non" p)
      )
      (command "_close")
    )
  )
  (princ)
)

Un exercice sans difficulté de programmation en tant que tel, mais le but étant de réfléchir "autrement". On a tous eu besoin à un moment donné eu besoin de récupérer la liste des sommets d'une polyligne et pour ce faire, on a chacun(e) sa méthode :3
Cependant je me suis bien souvent demandé, existe-t-il une solution plus rapide ?

Pour simplifier le challenge, l'exercice se porte uniquement sur les LWPOLYLINE, car les SPLINE, LINE, POLYLINE, ARC, etc ne possède pas les mêmes approches de programmation selon les objets. On peut prendre n'importe quel langage (en revanche je ne sais pas s'il existe un moyen d'utiliser un BenchMark sur plusieurs type de langage différent...?) histoire de comparer également les simplicités d'écriture selon les langages.

La liste retournée doit contenir l'ensemble des sommets de la polyligne, dans le sens de lecture de la polyligne (donc le sommet de départ au début, le dernier à la fin) et le but étant de trouver une version qui permet d'aller suffisamment vite en fonction du nombre de sommets.

J'ai généré sur le fichier ci-joint 4 polylignes ayant respectivement 10, 100, 1 000 et 10 000 sommets qui serviront de base (pour que tout le monde est la même). Le nombre de lignes importe peu, la vitesse d'exécution servira de comparaison. Concernant le Benchmark, j'utilise le BenchMark de Michael Puckett mais si vous en avez un autre, dite le histoire de maximiser les points communs pour la comparaison. Pour le temps de réponse, disons que je posterais mes versions ce we mais il n'y a pas de limite de temps 😜

Bisous,
Luna

get-pt-list.dwg BenchMark (Michael Puckett).lsp

Je viens de me souvenir d'un challenge perso qui m'avais bien tordu l'esprit.

Convertir un texte pour injection d'URL. (ou requete HTML).

Lorsque nous tapons une adresse internet dans la barre d'adresse d'un navigateur, c'est une injection.

Exemple simple "https://www.openstreetmap.org/#map=16/48.4674/-2.5486"

Ici nous arrivons directement au coordonnées injectées.

Mais lorsque nous utilisons une URL en programmation, nous utilisons pas la barre du navigateur, cela va directement au serveur.

Si l'injection contient des caractères spéciaux il faut les convertir en Caractères hexadécimales.

Exemple "https://fr.wikipedia.org/wiki/Saint-Barthélemy-d'Anjou" doit devenir "https://fr.wikipedia.org/wiki/Saint-Barth%C3%A9lemy-d'Anjou"

ou  "aB 09_éùl'o @£" -> "aB%2009_%C3%A9%C3%B9l'o%20%40%C2%A3"

Il existe des fonctions ou méthodes dans beaucoup de langage qui s'occupe très bien de cela, mais pas en Autolisp.

Je me permet donc de vous proposer d'écrire l'équivalent de ces 2 fonctions Javascript

encodeURIComponent

decodeURIComponent

Évidement sans énumération telle que '(("é" . "%C3%A9") ...)

Je poste mes fonctions Dimanche soir.

bonne exploration et à bientôt.

J'ai donc un nouveau "truc" à vous proposer...

Quelque-soit le langage que vous proposerez sera le bien venu (Lisp, V-Lisp, VBA, C#, F# Ruby, patatruc...), vous êtes libre :

C'est de la géométrie, désolé, mais c'est mon truc. Le challenge est :

Dessinez un cercle (oui, c'est graphique Et géométrique).

Dans ce cercle, dessinez un carré inscrit, et dans ce carré un cercle inscrit... Et ce, au moins 4 ...

Mais avant tout, Est-ce judicieux comme challenge ? Ai-je oublié quelque-chose ?

Mais bien à vous, et lancez-vous...

On ne "jugera" as sur la quantité de fonction/commande et non du nombre de lignes de programmation...

Un nouveau challenge (tout langage accepté).

L'objectif est de définir une fonction pour grouper les points (coordonnées) d'une liste en fonction de leur coordonnée X avec une tolérance de 10 unités.
La fonction devra prendre comme argument une liste de points 2d (x y) ou 3d (x y z) et renvoyer les points groupés sous la forme que permet le langage utilisé (en LISP ce sera forcément une liste de sous-listes, avec d'autre langages, ça peut-être une autre structure de données : un tableau déchiqueté, un dictionnaire, ...).

Exemple, avec la liste suivante en entrée :

(setq pts
       '((14.4 4.7)
	 (4.8 0.7)
	 (8.0 0.9)
	 (9.3 4.7)
	 (-14.3 14.3)
	 (-6.3 14.2)
	 (-13.6 7.5)
	 (-1.9 -3.2)
	 (2.4 -4.9)
	 (6.6 11.2)
	 (-6.6 4.7)
	)
)

on devrait obtenir 3 groupes :

((-6.6 4.7) (-13.6 7.5) (-6.3 14.2) (-14.3 14.3))
((2.4 -4.9) (-1.9 -3.2) (4.8 0.7))
((6.6 11.2) (9.3 4.7) (8.0 0.9) (14.4 4.7))

On pourra ensuite pousser un peu plus loin pour rendre la fonction plus générique en passant la tolérance en argument, puis en groupant par X et Y.

Je pense que vous savez déjà de quoi je vais parler.

Faites un programme, quel qu'il soit, mais comment les protéger...

En gros, on vous paye pour dessiner, mais vous programmez, mais sur votre bulletin de paie est écrit "Dessinateur". La législation française est très explicite là-dessus...

Vous êtes dessinateur (c'est sur votre bulletin de paye) et non programmeur/développeur ? Donc, tous ce que vous développez/programmez est en votre entière possession et sauf votre accord, votre employeur ne DOIT pas les utiliser sans votre accord, avant (?), pendant (Ok), et après (c'est là, l'arnaque)...

Mais, comment protéger vos développement, vos logiciels, pour les quelles vous n'avez pas été embauché, mais jamais payé... Attention, on parle bien d'un jeu...

Attention, je ne suis pas contre le patronat... Je veux juste protéger les développements qui se font exploités... Et aussi, protéger les développements de programmateurs qui aimeraient vendre un peu leur travail, ou les monnayer...

Je vous propose donc un nouveau Chalenge...

Comment faire un programme "entier" (qui sera utilisable partout et en dehors de toutes contraintes) et le protéger...

Donc, je vous propose un défit pour protéger un lisp ou autre. Voici les condition (et je reste ouvert aux remarques) :

Comment faire un .lsp (ou autre, mais la principale demande reste pour AutoCAD, mais je ne suis pas fermé) et le protéger (.ini, base de registre, fichier caché, suite de code ASCII, clef différentielle, encodée...)

Premièrement, comment protéger son travail :

1.soit dans le temps (un mois d'utilisation accordé, par exemple)

2.soit dans le nombre d'utilisation ( 10, 20, 200)

3.soit autre chose dont je n'ai pas connaissance, mais je reste ouvert...

Et comment le distribuer :

1.Un Bundle

2.Un fichier compiler (qui contiendrait tous les programmes)

3.Être aider d'un autre logiciel de distribution, gratuit s'il vous plait... Car le but est de protégé le petit développeur qui s'est ruiner pour son bosse et qui repart avec rien... Donc, Tout doit être gratuit...

je vous propose un petit développement de mon cru, comment le rendriez-vous inviolable et protégé, car là est la question, ce programme dessine une crois dans un quadrilatère (Oui, certain me dirait, Wouaouw, quel effort... je sais, mais je n'est pas le problème), mais comment le vendre (pas important) mais comment le protéger (tu l'utilises, tu me dois 10 euros (toutes les 10, 20, 100 utilisations, tous les mois, une "licence ad-vitam"...) Et là, vous avez toutes les libertés) :

Je suis désolé, c'est du Lisp, mais vous faites comme vous le voulez, le seul impératif, c'est que c'est pour AutoCAD (ou ZWCAD, Draftsight...)

Libre à vous :

(vl-load-com)
;;; *****************************************
;;; Dessine une croix dans un quadrilatère   
;;; *****************************************
(defun c:CroixDsQuadri (/ ent ent-liste n liste-sommets)
 (princ "\n\tDéveloppé par Denis H. (1.0)")
 (setq doc (vla-get-activedocument (vlax-get-acad-object)))
 (vla-startundomark doc)
 (if (eval 'CleRegCerene)
   (CleRegCerene "DenisH")
 ) ;_ Fin de if
 (while (= "LWPOLYLINE" (cdr (assoc 0 (entget (setq ent (car (entsel "\nChoix de la polyligne\n")))))))
   (setvar "clayer" (cdr (assoc 8 (entget ent))))
   (setq ent-liste (entget ent)
         n 0
         ent 0
         liste-sommets nil
   ) ;_ Fin de setq
   (repeat (length ent-liste)
     (if (= 10 (car (nth n ent-liste)))
       (setq liste-sommets (cons (cdr (nth n ent-liste)) liste-sommets))
     ) ;_ Fin de if
     (setq n (+ 1 n))
   ) ;_ Fin de repeat
   (setq liste-sommets (reverse liste-sommets))
   (command "_.line" (nth 0 Liste-sommets) (nth 2 Liste-sommets) "")
   (command "_.line" (nth 1 Liste-sommets) (nth 3 Liste-sommets) "")
 ) ;_ Fin de while
 (vla-endundomark doc)
 (princ)
) ;_ Fin de defun

Je propose un petit jeu, mais en Lisp et/ou en VLisp et sans mélanger les deux. Mais si vous êtes en mesure de proposer d'autres langages, libre à vous, faites-nous voir vos connaissances... ;)

Avec le moins de lignes possible, faire ceci :

1.La base est une chaine contenant un nombre à 16 chiffres (ex : "5637159071856346"),

2.Passer par l'étape d'inversion de ce contenu (ex : "6436581709517365"), en fait il faut lire la chaine depuis la fin,

3.Puis, permuter les paires 2 à 2 (ex : "46638571901537765"), on inverse les chiffres 2 par 2, 64 devient 46, 36 devient 63...

C'est parti... ;)

Denis...

Alors voici la premier version !

Présentation de la version 1 :

Dernière version à télécharger dans le post

avec le mode d'emploi ici :

Note de base :

- Sauvegarde des options

- Dossier pour y déposer vos répertoires

- Sauvegarde possible d'une partie avec un amis

Bug connu et à corriger :

- L'échec et mat ne termine pas la partie

- Forcé le camps en échec a en sortir

- Msgbox de trait a la couleur alors que la piece fait un déplacement illégale

- Sauvegarde des Couleurs choisi pour les cases

- Le roi ne peut pas se mettre en échec (sauf contre l'autre roi : je vais le corriger)

- La promotion du pion ne fonctionne pas !

- Le roi ne doit pas pouvoir se mettre en echec sur les case de l'autre roi.

- Les échecs ne sont pas signalés

A améliorer :

- Les images des pièces infographie en cours ! (faut avouer elle sont moches !!)

- Faire l’algorithme pour réviser les répertoires

- Sauvegarder une position (utile dans un premier temps pour vérifier si le roi est toujours en échec

D'ailleurs la Dernière version sera en VB.net !

CHESS V2.2.zip

Chess v2.4a.zip

Bonjour,

Juste pour infos et mettre les choses au clair :

Je sais qu'il existe des programmes pour convertir des points d'un système et les transformer vers un autre...

c'est juste que mes boss ne veulent pas dépenser dans ce genre de programme...

Qui pour moi sont indispensable lorsqu'on travail dans un bureau de topographie...

Tous les documents sont disponible sur le site de l'IGN :

donc je ne vais rien inventer ni révolutionner (sauf pour mes collègues et moi même XD)

J'ai lu la procédure de calcul, donc je connais la théorie...

J'ai chercher pour essayer de simplifier les transformations mais c'est peine perdu...

Donc j'ai décider d'y allez juste "bourrin" et

donc je vais développer traduire en VBA le code pour mettre ce système en place !

Allez c'est parti :

Je démarre par créer des fonctions pour chaque algo et j'ai commencé par le 13

(je prends les algos dans l'ordre : et je traite ceux qui doivent être appellé)

Bien sur ce que je poste ici est vérifié par les jeux d'essais

Function TRANSFORMATION_COORDONNEES_7_PARAMETRES_2_SYSTEME_GEO(T, D, R, U)
'Algo 013
Dim V(0 To 2) As Double
'T Translation
'D Facteur d'echelle
'R Rotation autour de l'axe (radian)
'U Vecteur de coordonnées cartésienne tridimensionnelle dans le systeme 1
x = 0
y = 1
Z = 2
V(x) = T(x) + (U(x) * (1 + D)) + U(Z) * R(y) - U(y) * R(Z)
V(y) = T(y) + (U(y) * (1 + D)) + U(x) * R(Z) - U(Z) * R(x)
V(Z) = T(Z) + (U(Z) * (1 + D)) + U(y) * R(x) - U(x) * R(y)
TRANSFORMATION_COORDONNEES_7_PARAMETRES_2_SYSTEME_GEO = V
End Function

Puis le 38 qui fait appel à l'algo 001 / 002 / 014 / 015 / 043

Function CALCUL_LATITUDE_ISOMETRIQUE(premiere_excentricite_ellipsoide, Lati)
'Algo 001
e = premiere_excentricite_ellipsoide
R = Lati
F1 = Tan(PI / 4 + R / 2)
F2 = (1 - e * Sin(R)) / ((1 + e * Sin(R)) ^ (e / 2))
E_M1 = 1 - e * Sin(R)
E_P1 = 1 + e * Sin(R)
E_MP = E_M1 / E_P1
E_PUIS = E_MP ^ (e / 2)
CALCUL_LATITUDE_ISOMETRIQUE = Log(F1 * E_PUIS)
End Function

EDIT :

Donc je vais mettre ici le code VBA après avoir télécharger et installé CircéBATCHFrance

Après l'installation, on ajoute le dossier du Circebatch.exe dans le PATH de windows voir video

en test il aparrait qu'il ne trouve pas les fichier donc j'ai copier le dossier pour le mettre dans c:/users/NOMPC

les commandes via cmd.exe fonctionne

[codage en cours]

je ne sais pas si vous connaissez ce jeu solo pour les etudiant en étude qui s'ennuie...

On fais une grille de 5x5 puis on dois la remplir de 1 à 25 mais en respectant des déplacements pour poser le numéro suivant !

attention il y a un fichier TEMP.xls

c'est pour jouer au fichier "jeu du 25" en lecture seul si le fichier est deja ouvert par quelqu'un d'autres sur un réseau et enregistrer le score :-) !

allez dite moi ce que vous en pensez !

je ne l'ai pas inventé j'ai juste digitalisé ce jeu en excel xD

JEU DU 25.zip

l'objectif est de créer un calque s'il existe il faudrait une option nous demandant s'il l'ont veux fusionner les objets de l'ancien calque vers le nouveau qui va etre créé !

Edit :

Ajout de la fonctionnalité de rangé le dessin via type de ligne ou eapaisseur ou couleur !

c'est parti :

1°) Création d'une interface

2°) Création du code pour la fusion de claque ok

3°) [en cours] Création du code pour rangé via couleur / épaisseur ou type de ligne

4°) Si probleme répondre au post

TT_CALQUE.dvb!AFF.TT_OBJ

TT_CALQUE.zip

Je me lance dans différents "challenge" pour la programmation de modules sur autocad (en VBA car je sais que vous n'aimez pas ça XD).

J'ai réussi à calculer les longueurs de certains réseaux dans un polygone, et extraire les longueurs qui sont à l’intérieur dans un tableur (oui un peu comme pour les IC-OL)...

Mais, il m'arrive parfois de travailler sur des dessin dwg très (trop) grand et plûtot que de mettre en reference mes fonds de plan et de les délimiter

(rassurez vous c'est ce que je fais mais bon là : c'est pour le jeu).

Les règles :

Créer une forme :

Tous les objets en contact avec cette polyligne seront coupées !

Tout ce qui est à l'extérieur de cette forme sera effacer !

Avancement :

1°) Détecter les objets dans une polyligne

2°) Couper les intersections

3°) Supprimer les objets à l'exterieur

4°) PRET !

5°) J'ai aperçu un petit problème ! vous pouvez le télécharger pour voir où est le bug si le coeur vous en dit !

A appeler :

SUPP_EXT_FEN.dvb!SUPP_EXT_FEN.SUPP_EXT_FEN

SUPP_EXT_FEN.zip

Je programme souvent de mon coté et je n'en fait profiter personne... car le vba blabliblablo...

Je vais donc tester de vous partager un Work in Progress qui sera utile (pour peut-etre plein de monde).

Avant les critiques : je signale que je vais faire du VBA pour ce projet et Je vous invite à aller voir mes outils...Si la curiosité vous en dit...(voir ma signature)

Pas de référence à ajouter (histoire que cela circule)

en piece jointe l'interface ! que je me permettrais de mettre à jour en fonction de vos avis !

Je mettrais ce topic à jour dès que mon programme évoluera !

Données :

L'idée est de réaliser un explorerateur sans référence.

Alimenter une liste avec les documents favoris à ajouter dans le programme.

et si vous avez d'autres idées n'hésitez pas !

Avancement :

1°)

L'interface est créée (du moins la première version)

2°)

Le code pour extraire les noms des dossiers dans le dossier courant (liste de gauche est faite)

Le code pour extraire le nom des fichiers du dossier courant (liste de droite est faite)

3°)

La naviguation fonctionne grâce au bouton retour !

(Vous pouvez coller votre chemin pour y accéder plus vite si besoin ! et cliquer sur le label "Dossier Courant")

4°) Les chemins favoris peuvent etre enregistré dans une liste (avec un nom que vous choisirez)

5°) Le chemin courant peut etre ouvert (ajout d'un bouton d'ouverture)

6°) Ajout d'une liste pour sélectionner un chemin réseau et y accéder (utile pour les serveur en local)

7°) Ajout d'un bouton retour... (pour revenir au dossier précédent qui n'est pas le parent par exemple)

8°) Possibilité de sélectionner plusieurs fichiers.. en controlant qu'il n'a pas été deja sélectionné

9°) Voir les infos des fichiers au survol de la souris du fichier sélectionné en dessous (Date de modification et taille du fichier suivant l'unité la plus raisonnable !)

10°) Verification si un fichier est deja sélectionné

11°) Retour au dossier précédent jusqu'au dossier source

12°)

Installation manuelle

ou par code :

ThisDrawing.Application.LoadDVB DossierDudvb & "\Explorer.dvb" 

une démonstration sans son :

DEMONSTRATION de l'outil en exclusitivé (SANS VOIX)

Important la fonction à cibler : USF_EXPLORER.fichiers_liste

et renvoie la liste des fichiers en liste dans la page option

Mon mail et mon site(toujours en construction) sous dispo et sont cliquable.

utilité ?

- Boite de dialogue indépendante plus besoin de passer par uneboite de dialogue externe via excel acess ou autre...

- Import de fichiers de points

- Envoie de mail directement via Autocad avec des pièces jointes

- Import de Xref ou d'image

- créer des dossiers favoris pour "juste" les ouvrirs (meme utilité que windows sauf qu'il peuvent etre appellé par une entrée clavier !)

Explorer.zip

Il y a de cela quelques années, nous avons parlé de ce sujet

Afin de rendre à César ce qui est à César et à Jordan ce qui est à Jordan, je vous invite à consulter le théorème de Jordan

Il est célèbre par le caractère apparemment intuitif de son énoncé et la difficulté de sa démonstration

Une proposition de code dont l'objectif est de savoir où est un point par rapport à une polyligne plane fermée. Le principe est simple : on trace une demi-droite à partir du point étudié et on compte le nombre d'intersections avec la polyligne. Si ce nombre est pair, on est à l'extérieur, sinon à l'intérieur. La difficulté est qu'il faut s'assurer que la demi-droite ne passe ni par un sommet de la polyligne, ni par un point de tangence s'il y a des segments courbes.

(defun getpolySegs (ent / PTL I PTB SEG LSEG)
 ;; Afralisp
 ;; renvoie les segments d'une polyligne
 ;; sous la forme d'une liste
 ;; '(((x1 y1) bulge1 (x2 y2)) ... ((xn-1 yn-1) bulgen (xn yn)))
 (if (= (type ent) 'ENAME)
   (setq ent (vlax-ename->vla-object ent))
 )
 ;; collecter la liste des point sous la forme (x1 y1 x2 y2 ... xn yn)
 (setq PTL (vlax-safearray->list (vlax-variant-value (vla-get-Coordinates ENT))))
 ;; collecter la liste des bulges
 (setq I 0) 
 (repeat (/ (length PTL) 2)
   (setq PTB (cons (vla-GetBulge ent I) PTB))
   (setq I (1+ I))
 )
 (setq PTB (reverse PTB))
 ;; polyligne fermée -> rajouter le premier point à la liste de points
 (if (= (vla-get-closed ent) :vlax-true)
   (setq PTL (append PTL (list (car PTL) (cadr PTL))))
 )
 ;; transformer en liste de segments
 (setq I 0)
 (repeat (- (/ (length PTL) 2) 1)
   (setq SEG
     (list
       (list (nth I PTL) (nth (+ I 1) PTL))
       (nth (/ I 2) PTB)
       (list (nth (+ I 2) PTL) (nth (+ I 3) PTL))
     )
   )
   (setq LSEG (cons SEG LSEG))
   (setq I (+ I 2))
 )
 (reverse LSEG)
)

(defun getArcInfo (segment / a p1 bulge p2 c p3 p4 p r s result)
 ;; Afralisp
 ;; renvoie les informations d"un segment courbe
 ;; sous la forme d'une liste '((xc yc) R)
 ;;
 ;; assigner variables avec les valeurs de l'argument
 (mapcar 'set '(p1 bulge p2) segment)
 (if (not (zerop bulge))
   (progn
     ;; trouver la corde
     (setq c (distance p1 p2))
     ;; trouver la flèche
     (setq s (* (/ c 2.0) (abs bulge)))
     ;; trouver le rayon par Pythagore
     (setq r (/ (+ (expt s 2.0) (expt (/ c 2.0) 2.0)) (* 2.0 s)))
     ;; distance au centre
     (setq a (- r s))
     ;; coordonnées du milieu de p1 et P2
     (setq P4 (polar P1 (angle P1 P2) (/ c 2.0)))
     ;; coordonnées du centre
     (setq p
       (if (>= bulge 0)
         (polar p4 (+ (angle p1 p2) (/ pi 2.0)) a)
         (polar p4 (- (angle p1 p2) (/ pi 2.0)) a)
       )  
     )
     ;; coordonnées de P3
     (setq p3
       (if (>= bulge 0)
         (polar p4 (- (angle p1 p2) (/ pi 2.0)) s)
         (polar p4 (+ (angle p1 p2) (/ pi 2.0)) s)
       )  
     )
     (setq result (list p r))
   )
   (setq result nil)
 )
 result
)

(defun randnum (/ modulus multiplier increment random)
 ;; afralisp
 ;; renvoie un nombre pseudo aléatoire entre 0 et 1
 ;;
 (if (not seed)
   (setq seed (getvar "DATE"))
 )
 (setq modulus    65536
       multiplier 25173
       increment  13849
       seed  (rem (+ (* multiplier seed) increment) modulus)
       random     (/ seed modulus)
 )
)

(defun inout (pt ent / AcDoc Space RES LSEG LANGLE ArcInf D D1 ANG pttan1 pttan2 RAY NBPTS)
 ;; revoie 0 -> pt est sur ent
 ;; +1 -> pt à l'intérieur de ent
 ;; -1 -> pt à l'extérieur de ent
 ;;
 (setq AcDoc (vla-get-activeDocument (vlax-get-acad-object))
       Space (if (= (getvar "CVPORT") 1)
               (vla-get-PaperSpace AcDoc)
               (vla-get-ModelSpace AcDoc) 
             )
 )
 (if (equal (distance pt (vlax-curve-GetClosestPointTo ent pt)) 0.0 1e-10) ;; pt est sur le contour
   (setq RES 0)
   (progn
     (setq LSEG (getpolysegs ent))

     (foreach X (mapcar 'car LSEG)  ;; je collectionne tous les angles que fait pt avec chaque sommet
       (setq LANGLE (cons (angle PT X) LANGLE))
     )

     (foreach X (vl-remove-if '(lambda (x) (zerop (cadr x))) LSEG) ;; on ne garde que les segments qui ont une courbure
       (setq ArcInf (getarcinfo X))
       (setq D (distance PT (car ArcInf)))
       (if (> D (cadr ArcInf))  ;; on ne cherche les tangentes que si le point est en dehors du cercle
         (progn
           (setq D1 (sqrt (- (expt D 2) (expt (cadr ArcInf) 2))))
           (setq ANG (atan (/ (cadr ArcInf) D1)))
           (setq pttan1 (polar pt (+ (angle pt (car ArcInf)) ANG) D1))
           (setq pttan2 (polar pt (- (angle pt (car ArcInf)) ANG) D1))
           (setq LANGLE (cons (angle PT pttan1) LANGLE)) ;; je collecte les points de tangence que je garde
           (setq LANGLE (cons (angle PT pttan2) LANGLE)) ;; même s'ils ne sont pas forcément sur le contour de ent.
         )
       )
     ) ;; foreach

     ;; on cherche un angle pour tracer la demi-droite différent de ceux collectés ci-dessus
     ;; pour s'assurer que la demi-droite ne passera pas par un sommet ou un point de tangence
     (while
       (member (rtos (setq ANG (* (randnum) 2 pi)) 2 2) (mapcar '(lambda (x) (rtos x 2 2)) LANGLE))
     )
     (setq RAY (vla-addRay Space (vlax-3d-point pt) (vlax-3d-point (polar pt ang 1.00))))  ;; on trace une demi-droite
     (setq NBPTS (/ (length (vlax-invoke ent 'IntersectWith RAY acExtendNone)) 3))         ;; on regarde le nombre de point
     (vla-erase RAY)
     (cond
       ((= (rem NBPTS 2) 0) (setq RES -1))  ;; c'est pair donc c'est à l'extérieur
       (T (setq RES 1))                     ;; c'est impair donc à l'intérieur
     )
   )
 )
 RES
) ;; defun




(defun c:test (/ ent pt RES)
 (and
   (setq ent (car (entsel "\nSélectionnez une polyligne: ")))
   (setq ent (vlax-ename->vla-object ent))
   (= (vla-get-ObjectName ent) "AcDbPolyline")
   (= (vla-get-Closed ent) :vlax-true)
   (setq pt (trans (getpoint "\nSpécifiez un point: ") 1 0))
   (setq RES (inout pt ent))
   (cond
     ((zerop RES) (alert "Sur le contour"))
     ((minusp RES) (alert "Dehors"))
     (T (alert "Dedans"))
   )  
 )
 (princ)
) 

Amicalement

Vincent