krunch

Ce serait sans doute faisable en fabriquant les fonctions de conversion RVB>TSL et TSL>RVB décrites ici, mais il y a peut-être plus rapide.

J'ai lu ça plusieurs fois mais je me suis toujours demandé comment c'était possible concrètement. Est ce que ce genre de chose serait basé sur la fonction apply ? Est ce que c'est spécifique au Lisp ? (par exemple en javascript il y a une fonction eval qui exécute une chaîne) Ensuite il faut que le fichier s'auto-enregistre ... Je l'ai lu plusieurs fois mais jamais vu une fonction qui permette de s'attaquer à ce genre de logique.

Rien à voir avec AutoCad mais pour info, et pour aller plus loin en LISP .... Les hubots de la série Real Humans diffusée en ce moment sur Arte sont programmés en Lisp ! La preuve ici (saison 2 - épisode 6) : http://img4.hostingpics.net/thumbs/mini_402283Sanstitre1.jpg

Bonjour Il me semble me souvenir que j'avais des problèmes avec ces fonctions quand les coordonnées (z en particulier) n'étaient pas tout à fait nulles (genre 1.23E-17), ce qui peut arriver avec trans. D'autre part rien à voir mais vlax-ename->vla-object n'est pas nécessaire je crois (les ename marchent aussi)

Oui, à la base ma question portait juste sur le format, et par 'application alternative' je ne pensais pas au remplacement d'AutoCad (je m'intéresse aux possibilités de viewers online en l'occurrence). Mais le fait qu'une telle bibliothèque existe, ainsi que des clones (pas forcément chinois par ailleurs) me semble maintenant normal : AutoCad est un super logiciel, mais vendu à un prix hallucinant (comparé à d'autres logiciels qui sont aussi au top, comme par exemple chez Adobe) alors qu'il est probablement très très très largement rentabilisé depuis toutes ces années. Je suis pas sûr que l'argument de l'innovation soit encore bien pertinent (d'ailleurs elle est maintenant plus du côté des BIM), par contre celui de l'actionnariat oui... En attendant ce que tu dis sur la stratégie d'équipement est tout à fait vrai.

Merci pour tes réponses. Donc en résumé ce serait plutôt ici ou là que ça se passe, c'est du C, et AutoDesk n'est pas content... Par ailleurs je ne sais pas si ça concernait cette library on d'autres mais j'ai lu que les applis alternatives n'arrivaient généralement pas vraiment à une compatibilité à 100%.

Bonjour C'est une question générale et sans doute un peu bêta mais comment font les applis non-AutoDesk pour décoder un fichier au format DWG et accéder aux objets de la bdd ? Comment ont été faites les applis alternatives qui ouvrent directement ce format : à partir d'un back-engineering laborieux ou y a t-il quelque part un algo 'ParseDWG' ? Je sais bien que c'est possible avec le DXF mais avec le DWG comment font ils ?

Oui voilà, les 2 .. c'était un lapsus ;)

Conversation faite, merci à Jalna ..

Bonjour j'aurais besoin d'un enregistrer sous (en modifiant le format dans les options) vers un format antérieur. Mon fichier est au format 2012 et je ne peux pas l'ouvrir. Si quelqu'un a un 3DS Max 2012 ou postérieur sous la main ce serait très sympa...

L'état 'highlight' n'est pas une propriété stockée dans l'entité (comme l'est par exemple la propriété Visible), donc je ne pense pas que cette info soit accessible en Lisp (à moins qu'elle soit stockée quelque part ailleurs dans un dictionnaire mais il me semble pas). Le mieux est de stocker les entités highlightées avec redraw dans une liste, ou un jeu de sélection, pour pouvoir ensuite les rétablir ...

Alors voilà un exemple sur un ilôt (format 2010), ici il s'agit des couches de toiture. - avant : MPolys pas jointifs (quand tu zoomes) avec OD - après : Polys jointifs (+ centroïdes dissociés avec les OD initiaux) C'est un exemple de plan urbain courant où les contours relevés ne sont pas jointifs. J'aurais dû poser la question autrement, de façon plus générale : comment feriez vous pour rendre les contours jointifs en acceptant de modifier légèrement les coordonnées des points ? Là j'ai adopté le processus décrit, à savoir EXPLODE et CleanUp .. ilot.zip

Bonjour Pour ajuster les contours d'un plan urbain (qui se chevauchent légèrement ou ne sont pas tout à fait jointifs comme souvent) j'utilise les outils de Nettoyage (Drawing Clean Up), donc je suis obligé d'exploser les MPolys en polys ou en lignes. Ensuite en multipliant les Clean Up actions j'arrive à créer une topologie valide. Question : comment refabriquer les contours MPolys ou Polylignes de cette topologie (l'équivalent d'un CONTOUR systématique dans AutoCad) ? __________________ Et aussi question subsidiaire : au moment de la fabrication de la topologie, comment réaffecter les anciens centroïdes que j'ai fabriqué avant d'exploser les MPolys, afin de faire transiter les ObjectsDatas ? Merci d'avance

Ça marche aussi. J'avais pas compris que new pouvais être utilisé hors déclaration et répété .. thanks again

D'accord, du coup il faut carrément éviter la variable de sous-liste l, effecivement. Ça marche au poil, merci encore !

Rebonjour Malgré ces quelques réserves j'aimerais finir ma fonction, et je bute sur un problème de déclaration ou affectation de variable avec les List<>. En fait il semble que l'ajout d'une variable (dans l'exemple la variable l) dans une liste se fasse en tant que référence ... J'ai finis par faire l'extraction de ResultBuffer suivante, pour un appel de la forme ( fct A ((B C) (D E)) ). Il est basé uniquement sur le niveau de profondeur des parenthèses (i), la structure a l'air ok (en tous cas le défilement i / entités est bon) : [LispFunction("fct")] public void function(ResultBuffer resbuf) { ObjectId ent = new ObjectId(); // ent : entité de niveau Objet List<List<ObjectId>> sub = new List<List<ObjectId>>(); // sub : liste des path d'entités imbriquées (optionnelle) bool on = new bool(); // on : true/false (true si argument 1 est fourni / false sinon) int i = -1; List<ObjectId> l = new List<ObjectId>(); foreach (TypedValue tv in resbuf) { switch (tv.TypeCode) { case 5006: // ObjectId if (i == -1) ent = (ObjectId)tv.Value; else { l.Add((ObjectId)tv.Value); } break; case 5016: // '(' if (i == 0) l.Clear(); i++; break; case 5017: // ')' if (i == 1) sub.Add(l); i--; break; case 5003: // int16 on = ((Int16)tv.Value == 1); break; } } // ensuite traitement exception ent absent (sub est optionnel) etc ... Mais si j'appelle ( fct A ((B C) (D E)) ) je récupère sub = ((D E)(D E)) ... C'est à dire que la liste l est ajoutée dans sub en tant que référence. Je me dis qu'elle est peut être boxée (qu'une liste se comporte comme un Object) mais si je déboxe l au moment de l'ajouter ça ne change rien : case 5017: // ')' if (i == 1) sub.Add((List<ObjectId>)l); Est ce un problème de déclaration ?

C'est sûr qu'on fait moins de choses avec AutoLisp et on les fait plus lentement. Mais AutoLisp n'a pas besoin d'évoluer pour permettre l'accès et le traitement d'éventuels nouveaux objets (en plus il n'y en a pas vraiment comme tu le dis). A l'inverse l'API .Net change, ce qui peut rendre obsolète la spécification de la plus quelconque des méthodes, alors que son objet n'a pas évolué. Prends l'exemple de l'évolution 2013 : dans 1 ou 2 ans les programmeurs ne se soucieront même plus de la compatibilité de leur appli avec AutoCad2012 ! (et il y a des chances qu'elle ne le soit pas). Ensuite il y aura l'évolution 2016 etc .. C'est ça qui est gonflant Autre point décourageant, si on parle de l'apprentissage du C# : le fait qu'il soit spécifiquement Microsoft .. qui a les pratiques qu'on connait. A ce propos j'étais tombé là dessus.

D'accord c'est donc ça ... Je reconnais que le .Net offre des possibilités épatantes, mais quand on vient du Lisp (et sans même parler des nouveaux concepts de prog) .. quel labyrinthe ! Et aussi cette remarque impertinente, mais flagrante : avec le .Net TOUT pousse à la mise à jour des versions ... La performance est complètement au service des bénéfices des deux World Companies ...

Je ne sais pas comment tu fais ... pas chez moi :-( Je suis toujours sous version 2010 c'est peut être ça ? Donc apparemment ça ira mieux plus tard, merci pour cette précision !

Bonjour Juste une question générale de méthode, pour confirmer quelques points évoqués ici. En fait actuellement je trouve totalement infernal de faire de la conception (ou même d'apprendre le .Net sous AutoCAD) avec ça ... Vu que apparemment les points d'arrêt (et en gros tout le menu Déboguer) ne fonctionnent pas avec un système 64bits, tout ce que j'ai trouvé c'est de parsemer le code de doc.Editor.WriteMessage("\n" + ....ToString()) de relancer une exécution à chaque fois ... c'est vraiment pénible. Concrètement comment faites vous ? Qu'est ce que j'ai pu rater qui facilite la tache ?

Ok c'est la différence .. Il faut donc faire ça (try/catch) ou alors faire un return new TypedValue(5019); en cas d'échec et arrêter l'exécution en Lisp si la fonction renvoie nil.Compris merci.

Oui j'avais vu ça dans cet autre exemple. C'est la version sophistiquée (perso je fais de l'hybride : c'est un code Lisp qui appelle la fonction et non pas l'utilisateur, donc je m'arrange en amont pour qu'il n'y ait pas d'exception), mais c'est bien, ça permet de comprendre les protections à mettre en place en cas d'entrée utilisateur. Et là dessus j'aurais juste 2 remarques : - si un des arguments est une liste, par exemple d'entités, en nombre indéfini, dans ce cas le nombre d'arguments du tableau n'est pas pertinent (?) - dans d'autres exemples pour arrêter le code en cas d'exception ils mettent juste un return, par exemple dans ton exemple ça donnerait quelque chose comme : ... if (args.Length < 3) { acadApp.ShowAlertDialog("nombre d'arguments insuffisant"); return; } C'est pas valable comme méthode ? Sinon ma question de base est résolue, la liste de sous-listes marche avec les entités, merci.

Ok, donc on peut faire une liste de listes en déclarant l'imbrication des types de données. Effectivement ça marche avec les string (pas essayé avec des ObjectId mais ça devrait aussi). Quant au ArrayList ils sont souvent déconseillés en effet. Merci bien pour ces précisions, ça devrait aller maintenant. Sinon, de façon générale (toujours pour le traitement du ResultBuffer) et d'après ce que j'ai compris en analysant des exemples (notamment tes routines), on utilise de préférence : - un tableau donné directement par resbuf.AsArray() quand on a un nombre déterminé de données - une liste fabriquée avec la méthode Add par itération du ResultBuffer avec conditionnelles et analyse du type (beaucoup plus compliqué) quand on a un nombre indéterminé de données .. C'est bien ça ?

Bonjour J'essaie de transposer une sous-fonction Lisp en .Net, et le plus compliqué est le traitement de l'argument (ResultBuffer) .. En l'occurrence j'ai un argument qui est une liste de liste dont aucun élément n'est en nombre connu. A priori j'exclus les Array pour cette raison, le meilleur type de données semble être la List (grace à la méthode Add), mais le problème est qu'apparemment on ne peut pas faire une liste de liste (?) : List<string> sub = new List<string>(); sub.Add("truc"); List<List> subs = new List<List>(); subs.Add(sub); // NON :-( Par contre il semble qu'on puisse faire une liste de tableaux : string[] subs; subs = new string[] { "truc" }; List<Array> sub = new List<Array>(); sub.Add(subs); Mais le stockage dynamique dans un tableau n'est vraiment pas pratique. J'ai vu qu'il y avait une classe ArrayList mais qui semble beaucoup plus lente (et dans ce cas pour une fois la performance compte). Bref quelle est la meilleure solution sachant que j'ai 3 arguments qui sont : entname + ((entname ..) ..) / nil + 0/1

OK .. sans doute était ce une mauvaise idée. Merci pour vos réponse et votes