Quadrillage dynamique

[LUDWIG]

Bonjour à tous,

 

Je pensais que ce serait très simple affaire en bloc dynamique : que nenni !

J'aurais besoin de créer un rectangle (Longueur et largeur modifiables).

A l'intérieur de ce rectangle, je voudrais de axes verticaux : je veux pouvoir choisir le nombre, et qu'ils soient équidistants. Idem avec des axes horizontaux.

J'aurais bien utiliser une action de réseau, mais les paramètres "décalage de rangées" et "décalage de colonne" ne semblent accepter que des valeurs fixes, et pas d'autres paramètres.

Idem si je veux jouer avec le paramètre "variation de distance" de l'action d'étirement.

 

Un astuce ?

 

Pour le moment j'ai fait 1 bloc rectangle avec des axes horizontaux, je gère le nombre d'axe avec un paramètre de visibilité.

J'utilise le même bloc tourné à 90° pour gérer les axes verticaux.

Ci joint

Diviseur de pièce.dwg

[didier]

Bonjour @LUDWIG

Ton quadrillage devra-t-il respecter une équidistance entre les axes verticaux et horizontaux ?

Ou bien devra-t-il y avoir un axe dans chaque sens au milieu du rectangle ?

Amicalement

 

[LUDWIG]

Bonjour Didier,

 

Non les axes horizontaux et verticaux sont indépendants.

En fait c'est pour calepiner au plafond d'une pièce (le rectangle) des grilles de ventilation. Je peux avoir une pièce rectangulaire de 6x3m par exemple dans laquelle je veux placer 2x4 grilles. Voir image ci-joint.

[Curlygoth]

programme un réseau se sera plus facile et rapide a faire XD

[LUDWIG]

oui mais je n'arrive pas à faire un réseau paramétrique dans lequel mon nombre de division est une variable.

[nG! Hebus]

Salut, je jette un oeil à ton soucis ce midi 😉

Je te met ça ici quand c'est fait 😄 

 

 

EDIT : j'ai une solution mais pas propre, je continue ce soir 😉

[LUDWIG]

👍

2 hours ago, nG! Hebus said:

Salut, je jette un oeil à ton soucis ce midi 😉

Je te met ça ici quand c'est fait 😄 

 

 

EDIT : j'ai une solution mais pas propre, je continue ce soir 😉

 

[(gile)]

Salut,

Il me semble avoir déjà fait quelque chose en LISP, mais le refaire avec .NET m'a amusé.
Télécharger DynamicGrid.zip
Débloquer l'archive
Extraire et lancer DynamicGrid_setup.msi
Lancer la commande DYNGRID dans AutoCAD.

Un screencast.

 

[(gile)]

Pour ceux que ça intéresse(s'il y en a), le code C#.

using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.GraphicsInterface;
using Autodesk.AutoCAD.Runtime;

using System.Collections.Generic;
using System.Linq;

using AcAp = Autodesk.AutoCAD.ApplicationServices.Core.Application;

[assembly: CommandClass(typeof(Gile.AutoCAD.DynamicGrid.Commands))]

namespace Gile.AutoCAD.DynamicGrid
{
    public class Commands
    {
        static int nH = 3, nV = 3;

        [CommandMethod("DYNGRID")]
        public static void DynamicGrid()
        {
            var doc = AcAp.DocumentManager.MdiActiveDocument;
            var db = doc.Database;
            var ed = doc.Editor;

            var pio = new PromptIntegerOptions("\nNombre de lignes horizontales: ");
            pio.LowerLimit = 2;
            pio.DefaultValue = nH;
            pio.UseDefaultValue = true;
            var pir = ed.GetInteger(pio);
            if (pir.Status != PromptStatus.OK)
                return;
            nH = pir.Value;

            pio.Message = "\nNombre de lignes verticales: ";
            pio.DefaultValue = nV;
            pir = ed.GetInteger(pio);
            if (pir.Status != PromptStatus.OK)
                return;
            nV = pir.Value;

            var ppo = new PromptPointOptions("\nSpécifiez le premier coin: ");
            var ppr = ed.GetPoint(ppo);
            if (ppr.Status != PromptStatus.OK)
                return;
            var ucs = ed.CurrentUserCoordinateSystem;
            var basePt = ppr.Value.TransformBy(ucs);
            var jig = new GridJig(basePt, ucs, nH, nV);
            var pr = ed.Drag(jig);
            if (pr.Status == PromptStatus.OK)
            {
                using (var tr = db.TransactionManager.StartTransaction())
                {
                    var btr = (BlockTableRecord)tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite);
                    foreach (var line in LineSegment.ComputeGrid(basePt, jig.VectorX, jig.VectorY, nH, nV)
                                                    .Select(l => l.ToLine()))
                    {
                        btr.AppendEntity(line);
                        tr.AddNewlyCreatedDBObject(line, true);
                    }
                    tr.Commit();
                }
            }
        }

        struct LineSegment
        {
            public Point3d StartPoint { get; }

            public Point3d EndPoint { get; }

            public LineSegment(Point3d startPoint, Point3d endPoint)
            {
                StartPoint = startPoint;
                EndPoint = endPoint;
            }

            public Line ToLine() => new Line(StartPoint, EndPoint);

            public static List<LineSegment> ComputeGrid(Point3d pt, Vector3d u, Vector3d v, int nU, int nV)
            {
                var lines = new List<LineSegment>();
                double d = nU - 1.0;
                for (int i = 0; i < nU; i++)
                {
                    var p = pt + v * i / d;
                    lines.Add(new LineSegment(p, p + u));
                }
                d = nV - 1.0;
                for (int i = 0; i < nV; i++)
                {
                    var p = pt + u * i / d;
                    lines.Add(new LineSegment(p, p + v));
                }
                return lines;
            }
        }

        class GridJig : DrawJig
        {
            Point3d basePt, dragPt;
            Matrix3d ucs, wcs;
            int nH, nV;

            public Vector3d VectorX { get; private set; }

            public Vector3d VectorY { get; private set; }

            public GridJig(Point3d basePt, Matrix3d ucs, int nH, int nV)
            {
                this.basePt = basePt;
                this.ucs = ucs;
                wcs = ucs.Inverse();
                this.nH = nH;
                this.nV = nV;
            }

            protected override SamplerStatus Sampler(JigPrompts prompts)
            {
                var options = new JigPromptPointOptions("\nSpécifiez le coin opposé: ");
                options.BasePoint = basePt;
                options.UseBasePoint = true;
                options.UserInputControls =
                    UserInputControls.Accept3dCoordinates |
                    UserInputControls.UseBasePointElevation;
                var result = prompts.AcquirePoint(options);
                if (result.Value.IsEqualTo(dragPt))
                    return SamplerStatus.NoChange;
                dragPt = result.Value;
                var vector = basePt.GetVectorTo(dragPt).TransformBy(wcs);
                VectorX = new Vector3d(vector.X, 0.0, 0.0).TransformBy(ucs);
                VectorY = new Vector3d(0.0, vector.Y, 0.0).TransformBy(ucs);
                return SamplerStatus.OK;
            }

            protected override bool WorldDraw(WorldDraw draw)
            {
                var geo = draw.Geometry;
                foreach (var line in LineSegment.ComputeGrid(basePt, VectorX, VectorY, nH, nV))
                {
                    geo.WorldLine(line.StartPoint, line.EndPoint);
                }
                return true;
            }
        }
    }
}

 

[LUDWIG]

😵

Parfait ça. Merci (Gile)

Ca a l'ai si simple...