Ejemplo n.º 1
1
        public void CreateContour(BlockTableRecord btr)
        {
            if (panelBtr.ExtentsByTile.Diagonal() < endOffset)
            {
                return;
            }

            // из всех плиток отделить торцевые плитки????
            // дерево границ плиток
            TreeTiles = new RTree<Tuple<ObjectId, Extents3d>>();
            panelBtr.Tiles.ForEach(t =>
                           {
                               try
                               {
                                   var r = new Rectangle(t.Item2.MinPoint.X, t.Item2.MinPoint.Y, t.Item2.MaxPoint.X, t.Item2.MaxPoint.Y, 0, 0);
                                   TreeTiles.Add(r, t);
                               }
                               catch { }
                           });

            // Первый угол панели - левый нижний
            var pt1 = getCoordTileNoEnd(panelBtr.ExtentsByTile.MinPoint, EnumCorner.LeftLower);
            var pt2 = getCoordTileNoEnd(new Point3d(panelBtr.ExtentsByTile.MinPoint.X, panelBtr.ExtentsByTile.MaxPoint.Y, 0), EnumCorner.LeftTop);
            var pt3 = getCoordTileNoEnd(panelBtr.ExtentsByTile.MaxPoint, EnumCorner.RightTop);
            var pt4 = getCoordTileNoEnd(new Point3d(panelBtr.ExtentsByTile.MaxPoint.X, panelBtr.ExtentsByTile.MinPoint.Y, 0), EnumCorner.RightLower);

            Extents3d extNoEnd = new Extents3d(pt1, pt2);
            extNoEnd.AddPoint(pt3);
            extNoEnd.AddPoint(pt4);
            panelBtr.ExtentsNoEnd = extNoEnd;

            Point3dCollection pts = new Point3dCollection();
            pts.Add(pt1);
            pts.Add(pt2);
            pts.Add(pt3);
            pts.Add(pt4);
            using (Polyline3d poly = new Polyline3d(Poly3dType.SimplePoly, pts, true))
            {
                poly.LayerId = panelBtr.CPS.IdLayerContour;
                btr.AppendEntity(poly);
                btr.Database.TransactionManager.TopTransaction.AddNewlyCreatedDBObject(poly, true);
            }
        }
Ejemplo n.º 2
0
        public static ObjectId?addPolyline3d(List <Point3d> plist, ObjectId layerId, bool ifClosed = false)
        {
            try
            {
                Document acDoc   = Application.DocumentManager.MdiActiveDocument;
                Database acCurDb = acDoc.Database;

                using (Transaction tran = acCurDb.TransactionManager.StartTransaction())
                {
                    BlockTable       bt         = tran.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
                    BlockTableRecord modelSpace = tran.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
                    Polyline3d       b          = new Polyline3d();
                    ObjectId         oid        = modelSpace.AppendEntity(b);
                    for (int i = 0; i < plist.Count; i++)
                    {
                        b.AppendVertex(new PolylineVertex3d(plist[i]));
                    }
                    b.Closed = ifClosed;
                    if (layerId != ObjectId.Null)
                    {
                        b.LayerId = layerId;
                    }
                    tran.AddNewlyCreatedDBObject(b, true);
                    tran.Commit();
                    return(oid);
                }
            }
            catch (System.Exception ex)
            {
            }
            return(null);
        }
Ejemplo n.º 3
0
        addPoly3d(Point3dCollection pnt3ds, string nameLayer)
        {
            ObjectId idPoly3d = ObjectId.Null;

            try
            {
                using (Transaction tr = BaseObjs.startTransactionDb())
                {
                    try
                    {
                        BlockTableRecord MS     = Blocks.getBlockTableRecordMS();
                        Polyline3d       poly3d = new Polyline3d(Poly3dType.SimplePoly, pnt3ds, false);

                        Layer.manageLayers(nameLayer);
                        poly3d.Layer = nameLayer;

                        idPoly3d = MS.AppendEntity(poly3d);
                        tr.AddNewlyCreatedDBObject(poly3d, true);
                        tr.Commit();
                    }
                    catch (System.Exception ex)
                    {
                        BaseObjs.writeDebug(ex.Message + " Draw.cs: line: 561");
                    }
                }// end using
            }
            catch (System.Exception ex)
            {
                BaseObjs.writeDebug(ex.Message + " Draw.cs: line: 567");
            }

            return(idPoly3d);
        }
Ejemplo n.º 4
0
        addPoly3d(Point3dCollection pnt3ds, string nameLayer = "0", short color = 256, LineWeight weight = LineWeight.ByLayer)
        {
            ObjectId   idPoly3d = ObjectId.Null;
            Polyline3d poly3d   = null;

            try
            {
                using (BaseObjs._acadDoc.LockDocument())
                {
                    BaseObjs._transactionManagerDoc.EnableGraphicsFlush(true);
                    using (Transaction tr = BaseObjs.startTransactionDb())
                    {
                        BlockTableRecord MS = Blocks.getBlockTableRecordMS();

                        poly3d = new Polyline3d(Poly3dType.SimplePoly, pnt3ds, false);

                        Layer.manageLayers(nameLayer);
                        poly3d.Layer      = nameLayer;
                        poly3d.Color      = Color.FromColorIndex(ColorMethod.ByLayer, color);
                        poly3d.LineWeight = weight;

                        idPoly3d = MS.AppendEntity(poly3d);
                        tr.AddNewlyCreatedDBObject(poly3d, true);
                        tr.Commit();
                    }// end using
                }
            }
            catch (System.Exception ex)
            {
                BaseObjs.writeDebug(ex.Message + " Draw.cs: line: 477");
            }
            return(idPoly3d);
        }
Ejemplo n.º 5
0
        addPoly3d(Point3d[] pnt3ds, string nameLayer = "0", short color = 256)
        {
            ObjectId   idPoly3d = ObjectId.Null;
            Polyline3d poly3d   = new Polyline3d();

            try
            {
                using (Transaction tr = BaseObjs.startTransactionDb())
                {
                    BlockTableRecord MS = Blocks.getBlockTableRecordMS();

                    idPoly3d = MS.AppendEntity(poly3d);
                    tr.AddNewlyCreatedDBObject(poly3d, true);

                    int i = -1;
                    poly3d.SetDatabaseDefaults();
                    Layer.manageLayers(nameLayer);
                    poly3d.Layer = nameLayer;
                    poly3d.Color = Color.FromColorIndex(ColorMethod.ByBlock, color);
                    foreach (Point3d pnt3d in pnt3ds)
                    {
                        i = ++i;
                        PolylineVertex3d poly3dVertex = new PolylineVertex3d(pnt3d);
                        poly3d.AppendVertex(poly3dVertex);
                        tr.AddNewlyCreatedDBObject(poly3dVertex, true);
                    }
                    tr.Commit();
                }// end using
            }
            catch (System.Exception ex)
            {
                BaseObjs.writeDebug(ex.Message + " Draw.cs: line: 443");
            }
            return(idPoly3d);
        }
Ejemplo n.º 6
0
        addPoly3d(this List <Point3d> pnt3ds, string nameLayer = "0", short color = 256)
        {
            ObjectId   idPoly3d = ObjectId.Null;
            Polyline3d poly3d   = new Polyline3d();

            try
            {
                using (Transaction tr = BaseObjs.startTransactionDb())
                {
                    BlockTable       bt = (BlockTable)BaseObjs._db.BlockTableId.GetObject(OpenMode.ForRead);
                    BlockTableRecord MS = (BlockTableRecord)bt[BlockTableRecord.ModelSpace].GetObject(OpenMode.ForWrite);

                    idPoly3d = MS.AppendEntity(poly3d);
                    tr.AddNewlyCreatedDBObject(poly3d, true);

                    poly3d.SetDatabaseDefaults();
                    Layer.manageLayers(nameLayer);
                    poly3d.Layer = nameLayer;
                    poly3d.Color = Color.FromColorIndex(ColorMethod.ByBlock, color);
                    foreach (Point3d pnt3d in pnt3ds)
                    {
                        PolylineVertex3d poly3dVertex = new PolylineVertex3d(pnt3d);
                        poly3d.AppendVertex(poly3dVertex);
                        tr.AddNewlyCreatedDBObject(poly3dVertex, true);
                    }
                    tr.Commit();
                }// end using
            }
            catch (System.Exception ex)
            {
                BaseObjs.writeDebug(ex.Message + " Draw.cs: line: 406");
            }
            return(idPoly3d);
        }
Ejemplo n.º 7
0
        public static DBObject Create(this Grevit.Types.PLine a, Transaction tr)
        {
            try
            {
                LayerTable        lt = (LayerTable)tr.GetObject(Command.Database.LayerTableId, OpenMode.ForRead);
                Point3dCollection pc = new Point3dCollection();
                foreach (Grevit.Types.Point p in a.points)
                {
                    pc.Add(p.ToPoint3d());
                }
                Polyline3d pp = new Polyline3d(Poly3dType.SimplePoly, pc, a.closed);
                pp.SetDatabaseDefaults(Command.Database);
                if (lt.Has(a.TypeOrLayer))
                {
                    pp.LayerId = lt[a.TypeOrLayer];
                }

                BlockTable       bt = (BlockTable)tr.GetObject(Command.Database.BlockTableId, OpenMode.ForRead);
                BlockTableRecord ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                ms.AppendEntity(pp);
                tr.AddNewlyCreatedDBObject(pp, true);
                return(pp);
            }
            catch (Autodesk.AutoCAD.Runtime.Exception e)
            {
            }

            return(null);
        }
        public void CDS_ExtractGrid()
        {
            ObjectId surfaceId = promptForTinSurface();

            if (surfaceId == ObjectId.Null)
            {
                write("\nNo TIN Surface selected.");
                return;
            }

            using (Transaction tr = startTransaction())
            {
                TinSurface surface = surfaceId.GetObject(OpenMode.ForRead)
                                     as TinSurface;
                ObjectIdCollection ids = surface.ExtractGridded(
                    SurfaceExtractionSettingsType.Model);

                foreach (ObjectId id in ids)
                {
                    Polyline3d polyline =
                        id.GetObject(OpenMode.ForWrite) as Polyline3d;
                    if (polyline != null)
                    {
                        using (polyline)
                        {
                            polyline.Color =
                                AutoCAD.Colors.Color.FromRgb(255, 0, 0);
                        }
                    }
                }
                tr.Commit();
            }
        }
Ejemplo n.º 9
0
        public static ObjectId?addPolyline3d(Polyline3d polyline, ObjectId layerId)
        {
            try
            {
                Document acDoc   = Application.DocumentManager.MdiActiveDocument;
                Database acCurDb = acDoc.Database;

                using (Transaction tran = acCurDb.TransactionManager.StartTransaction())
                {
                    BlockTable       bt         = tran.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
                    BlockTableRecord modelSpace = tran.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

                    ObjectId oid = modelSpace.AppendEntity(polyline);

                    //b.Closed = true;
                    if (layerId != ObjectId.Null)
                    {
                        polyline.LayerId = layerId;
                    }

                    tran.AddNewlyCreatedDBObject(polyline, true);
                    tran.Commit();
                    return(oid);
                }
            }
            catch (System.Exception ex)
            {
            }
            return(null);
        }
Ejemplo n.º 10
0
        private string selectBrkLine(string strSide, ProfileView objProfileView)
        {
            Polyline3d poly3d = null;

            string strHandle = "";

            List <int>    intXDataType  = new List <int>(1);
            List <object> varXDataValIn = new List <object>(1);

            try
            {
                Point3d pnt3d = Point3d.Origin;
                poly3d = (Polyline3d)Base_Tools45.Select.selectEntity(typeof(Polyline3d), string.Format("Select Breakline on {0} Side of Wall Alignment: ", strSide), "Breakline Selection Failed.", out pnt3d, out ps);

                if ((poly3d != null))
                {
                    TypedValue[] tvs = new TypedValue[2] {
                        new TypedValue(1001, string.Format("BRK{0}", strSide)),
                        new TypedValue(1005, poly3d.Handle),
                    };
                    poly3d.ObjectId.setXData(tvs, string.Format("BRK{0}", strSide));
                    strHandle = poly3d.Handle.ToString();
                }
            }
            catch (Autodesk.AutoCAD.Runtime.Exception)
            {
                strHandle = "";
            }

            return(strHandle);
        }
Ejemplo n.º 11
0
        void getOnePlFromDwg()
        {
            try
            {
                // Выбор  объекта, и проверка что это полилиния
                Multicad.McObjectId idSelected = McObjectManager.SelectObject("Выберите полилинию ");
                Multicad.McObject   targetPl   = idSelected.GetObject();

                Polyline3d testPL = new Polyline3d();

                if (targetPl is DbPolyline || Object.ReferenceEquals(targetPl.GetType(), testPL.GetType()))
                {
                    this.plineGetFromUser = targetPl as DbPolyline;
                    this.correctlyGet     = true;
                }
                else
                {
                    this.correctlyGet = false;
                    return;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Ошибка: " + ex.Message);
            }
        }
Ejemplo n.º 12
0
        public override void OnDraw(GeometryBuilder dc)
        {
            dc.Clear();
            dc.Color = McDbEntity.ByObject;//color will be taken from object properties and object will be redrawn after color change
            //dc.DrawPolyline(new Point3d[] { _pnt, _pnt1, _pnt2, _pnt3, _pnt });
            //dc.DrawPolyline(poly.GetTrimmedOffset(Height)[0]);

            BendingShape shape1 = new BendingShape(_pnt, _pnt1, Height, Thickness, Gap);
            BendingShape shape2 = new BendingShape(_pnt1, _pnt2, Height, Thickness);
            BendingShape shape3 = new BendingShape(_pnt2, _pnt3, Height, Thickness, Gap);
            BendingShape shape4 = new BendingShape(_pnt3, _pnt, Height, Thickness);

            Polyline3d poly = new Polyline3d(new List <Point3d> (shape1.Shape));

            poly.AddPoliline(new Polyline3d(new List <Point3d>(shape2.Shape)));
            poly.AddPoliline(new Polyline3d(new List <Point3d>(shape3.Shape)));
            poly.AddPoliline(new Polyline3d(new List <Point3d>(shape4.Shape)));
            poly.SetClosed(true);

            //CircArc3d test = new CircArc3d(_pnt1, new Vector3d(), new Vector3d(), 0.25, ((180 + _pnt.AngleTo(_pnt1)) * Math.PI / 180), (_pnt.AngleTo(_pnt1) * Math.PI / 180));
            //dc.DrawArc(test);

            //dc.DrawArc(_pnt1, 0.25, ((180+_pnt1.AngleTo(_pnt2)) * Math.PI/180), (_pnt1.AngleTo(_pnt2) * Math.PI/180));

            Polyline3d.VertexDataOfPolyline polyVertecies = poly.Vertices;
            for (int i = 0; i < polyVertecies.Count; i++)
            {
                polyVertecies.MakeFilletAtVertex(i + 1, Radius);
            }
            dc.DrawPolyline(poly);
        }
Ejemplo n.º 13
0
        public static List <Point3d> GetPointsFrom3dPolyline(Polyline3d poly3d, Document doc)
        {
            Database db = doc.Database;
            Editor   ed = doc.Editor;

            List <Point3d> pts = new List <Point3d>();

            using (Transaction tr = db.TransactionManager.StartTransaction())
            {
                if (poly3d != null)
                {
                    // Use foreach to get each contained vertex
                    foreach (ObjectId vId in poly3d)
                    {
                        PolylineVertex3d v3d = (PolylineVertex3d)tr.GetObject(vId, OpenMode.ForRead);
                        Point3d          pt  = new Point3d(v3d.Position.X, v3d.Position.Y, v3d.Position.Z);

                        pts.Add(pt);

                        ed.WriteMessage($"GetPointsFrom3dPolyline => {pt.X}, {pt.Y}, {pt.Z}\n");
                    }
                }

                tr.Commit();
            }
            return(pts);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// create the 3D polyline in specifed layer
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="pts"></param>
        /// <param name="layerName"></param>
        /// <returns></returns>
        public static Polyline3d CreatePolylineFromPoint(Document doc, List <Point3d> pts, string layerName)
        {
            Polyline3d pl = new Polyline3d();

            Database db = doc.Database;

            #region create polyline with points
            using (Transaction tr = db.TransactionManager.StartTransaction())
            {
                try
                {
                    BlockTable       bt  = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead, false);
                    BlockTableRecord btr = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite, false);

                    pl.Layer = layerName;

                    btr.AppendEntity(pl);
                    tr.AddNewlyCreatedDBObject(pl, true);


                    foreach (Point3d pt in pts)
                    {
                        PolylineVertex3d vex3d = new PolylineVertex3d(pt);
                        pl.AppendVertex(vex3d);//apdd point into 3d polyline
                        tr.AddNewlyCreatedDBObject(vex3d, true);
                    }
                }
                catch { }
                tr.Commit();
            }

            #endregion
            return(pl);
        }
Ejemplo n.º 15
0
        private DTO.DTO GetAlignmentProfileDTO(DBObject obj)
        {
            var dto     = new SpeckleAutoCAD.DTO.DTO();
            var profile = obj as ACD.Profile;

            using (var tr = obj.Database.TransactionManager.StartTransaction())
            {
                using (var alignment = tr.GetObject(profile.AlignmentId, OpenMode.ForRead) as ACD.Alignment)
                {
                    var polyLineId = alignment.GetPolyline();
                    var polyline   = polyLineId.GetObject(OpenMode.ForRead) as Polyline;
                    var points     = Get3dPath(polyline, profile);
                    var poly3d     = new Polyline3d(Poly3dType.SimplePoly, points, polyline.Closed);
                    var payload    = poly3d.ToPolylinePayload();
                    var properties = payload.Properties;

                    payload.Name = $"{alignment.Name} - {profile.Name}";
                    properties["AlignmentName"] = alignment.Name;
                    properties["ProfileName"]   = profile.Name;
                    payload.PropertySets        = GetPropertySets(alignment);
                    dto.Data = JsonConvert.SerializeObject(payload);
                }

                dto.ObjectType = Constants.Polyline3d;

                return(dto);
            }
        }
Ejemplo n.º 16
0
        public static void getPointsBetween2Point(Polyline3d pl, double startParam, double endParam, Point3dCollection vertexes)
        {
            int n = 0;

            while (true)
            {
                double nextP;
                if (Math.Ceiling(startParam) - startParam < 1e-10)
                {
                    nextP = Math.Ceiling(startParam) + (++n);
                }
                else
                {
                    nextP = Math.Ceiling(startParam) + (n++);
                }

                if (nextP - endParam > 1e-10)
                {
                    break;
                }
                else if (Math.Abs(nextP - endParam) <= 1e-10)
                {
                    break;
                }

                vertexes.Add(pl.GetPointAtParameter(nextP));
            }
        }
Ejemplo n.º 17
0
        public ILineString ReadLineString(Transaction tr, Polyline3d polyline3D)
        {
            var coordinateList = new CoordinateList();

            if (polyline3D.PolyType == Poly3dType.SimplePoly) // 0??
            {
                foreach (var v in polyline3D)
                {
                    PolylineVertex3d vertex = null;
                    if (v is ObjectId)
                    {
                        vertex = tr.GetObject((ObjectId)v, OpenMode.ForRead) as PolylineVertex3d;
                    }
                    else if (v is PolylineVertex3d)
                    {
                        vertex = (PolylineVertex3d)v;
                    }

                    if (vertex != null)
                    {
                        coordinateList.Add(this.ReadCoordinate(vertex.Position), this.AllowRepeatedCoordinates);
                    }
                }
            }
            else
            {
                var dBObjectCollection = new DBObjectCollection();
                polyline3D.Explode(dBObjectCollection);
                try
                {
                    foreach (var dBObject in dBObjectCollection)
                    {
                        var line = (Line)dBObject;
                        coordinateList.Add(this.ReadCoordinate(line.StartPoint), false);
                        coordinateList.Add(this.ReadCoordinate(line.EndPoint), false);
                    }
                }
                finally
                {
                    foreach (var dBObject in dBObjectCollection)
                    {
                        if (dBObject is IDisposable)
                        {
                            (dBObject as IDisposable).Dispose();
                        }
                    }
                }
                dBObjectCollection.Dispose();
            }

            if (polyline3D.Closed)
            {
                coordinateList.Add(coordinateList[0]);
            }
            if (coordinateList.Count > 1)
            {
                return(this.GeometryFactory.CreateLineString(coordinateList.ToCoordinateArray()));
            }
            return(LineString.Empty);
        }
Ejemplo n.º 18
0
        public static Polyline3d?GetRegionContour(this Region reg)
        {
            Polyline3d?resVal  = null;
            double     maxArea = 0;

            using var brep = new Brep(reg);
            foreach (var face in brep.Faces)
            {
                foreach (var loop in face.Loops)
                {
                    if (loop.LoopType == LoopType.LoopExterior)
                    {
                        var ptsVertex = new List <Point3d>();
                        foreach (var vert in loop.Vertices)
                        {
                            if (!ptsVertex.Any(p => p.IsEqualTo(vert.Point, Tolerance.Global)))
                            {
                                ptsVertex.Add(vert.Point);
                            }
                        }

                        var pts    = new Point3dCollection(ptsVertex.ToArray());
                        var pl     = new Polyline3d(Poly3dType.SimplePoly, pts, true);
                        var plArea = pl.Area;
                        if (plArea > maxArea)
                        {
                            resVal  = pl;
                            maxArea = plArea;
                        }
                    }
                }
            }

            return(resVal);
        }
Ejemplo n.º 19
0
        public Polyline3d polyline(int Count, bool Inside)
        {
            List <Point3d> new_shape = new List <Point3d> (_shape);
            Polyline3d     poly      = new Polyline3d(new_shape);

            if (Inside)
            {
                new_shape.RemoveAt(0);
                new_shape.RemoveAt(new_shape.Count - 1);

                if (Count > 1)
                {
                    new_shape.RemoveRange(0, Count * 4 - 4);
                }

                if (new_shape.Count > 4)
                {
                    new_shape.RemoveRange(4, new_shape.Count - 4);
                }

                poly = new Polyline3d(new_shape);
                poly.SetClosed(true);
            }

            return(poly);
        }
Ejemplo n.º 20
0
Archivo: Conv.cs Proyecto: 15831944/EM
        poly3d_pnt3dColl(Polyline3d poly3d)
        {
            Point3dCollection pnts3d = new Point3dCollection();

            try
            {
                using (Transaction tr = BaseObjs.startTransactionDb())
                {
                    foreach (ObjectId objID in poly3d)
                    {
                        PolylineVertex3d v3d   = (PolylineVertex3d)tr.GetObject(objID, OpenMode.ForRead);
                        Point3d          pnt3d = new Point3d();
                        pnt3d = v3d.Position;

                        pnts3d.Add(pnt3d);
                    }
                    tr.Commit();
                }
            }
            catch (System.Exception ex)
            {
                BaseObjs.writeDebug(ex.Message + " Conv.cs: line: 521");
            }
            return(pnts3d);
        }
Ejemplo n.º 21
0
 public Grading_JigPoly3d(Polyline3d ent, Polyline3d poly3d, int vertex)
     : base(ent)
 {
     p3d         = poly3d;
     vtx         = vertex;
     _mTempPoint = ent.StartPoint;
 }
Ejemplo n.º 22
0
        jigLine(Point3d pnt3d, Polyline3d poly3d, int vertex)
        {
            ObjectId          idPoly3d = ObjectId.Null;
            Editor            ed       = BaseObjs._editor;
            Point3dCollection pnts3d   = new Point3dCollection {
                pnt3d, pnt3d
            };
            Polyline3d ent = new Polyline3d(Poly3dType.SimplePoly, pnts3d, false);

            ent.TransformBy(ed.CurrentUserCoordinateSystem);

            Grading_JigPoly3d jig = new Grading_JigPoly3d(ent, poly3d, vertex);
            PromptResult      res = ed.Drag(jig);

            if (res.Status == PromptStatus.OK)
            {
                Transaction tr = BaseObjs.startTransactionDb();
                using (tr)
                {
                    BlockTableRecord ms = Blocks.getBlockTableRecordMS();
                    idPoly3d = ms.AppendEntity(jig.Entity);
                    tr.AddNewlyCreatedDBObject(jig.Entity, true);
                    tr.Commit();
                }
            }
            return(idPoly3d);
        }
Ejemplo n.º 23
0
    public crawlAcDbPolyline(Polyline3d polyline)
    {
        Entity ent = (Entity)polyline;

        this.ObjectId = ent.ObjectId.ToString();

        Length          = polyline.Length;
        this.Layer      = polyline.Layer;
        this.Linetype   = polyline.Linetype;
        this.LineWeight = polyline.LineWeight.ToString();
        this.Color      = polyline.Color.ToString();

        Vertixes = new List <crawlPoint3d>();

        // Use foreach to get each contained vertex
        foreach (ObjectId vId in polyline)
        {
            PolylineVertex3d v3d =
                (PolylineVertex3d)
                vId.GetObject(OpenMode.ForRead);
            double x = v3d.Position.X;
            double y = v3d.Position.Y;
            double z = v3d.Position.Z;
            Vertixes.Add(new crawlPoint3d(x, y, z));
        }
    }
Ejemplo n.º 24
0
        private static Polyline Polyline3dToPolyline(Polyline3d polyline3d)
        {
            Document doc   = DatabaseUtil.GetActiveDocument();
            Database db    = doc.Database;
            Polyline oPoly = null;

            try
            {
                using (doc.LockDocument())
                {
                    using (Transaction tr = DatabaseUtil.GetTransaction(db))
                    {
                        oPoly = new Polyline();
                        ObjectId[] idVtcies = polyline3d.Cast <ObjectId>().ToArray();

                        for (int i = 0; i < idVtcies.Length; i++)
                        {
                            PolylineVertex3d oVtx = tr.GetObject(idVtcies[i], OpenMode.ForWrite) as PolylineVertex3d;
                            oPoly.AddVertexAt(i, GeometryUtil.ToPoint2d(oVtx.Position), 0, 0, 0);
                        }

                        oPoly.Layer = polyline3d.Layer;
                        oPoly.Color = polyline3d.Color;
                    }
                }

                return(oPoly);
            }
            catch
            {
                return(null);
            }
        }
Ejemplo n.º 25
0
        /// <summary>
        /// Get Polycurve from Polybeam
        /// </summary>
        /// <param name="polyBeam"> Advance Steel polybeam</param>
        /// <returns name="polyCurve">The PolyCurve from the beam</returns>
        public static Autodesk.DesignScript.Geometry.PolyCurve GetPolyCurve(PolyBeam polyBeam)
        {
            List <Autodesk.DesignScript.Geometry.Curve> intRet = new List <Autodesk.DesignScript.Geometry.Curve>()
            {
            };

            Autodesk.DesignScript.Geometry.PolyCurve ret = null;
            using (var ctx = new SteelServices.DocContext())
            {
                if (polyBeam != null)
                {
                    FilerObject filerObj = Utils.GetObject(polyBeam.Handle);
                    if (filerObj != null)
                    {
                        if (filerObj.IsKindOf(FilerObject.eObjectType.kPolyBeam))
                        {
                            Autodesk.AdvanceSteel.Modelling.PolyBeam selectedObj = filerObj as Autodesk.AdvanceSteel.Modelling.PolyBeam;
                            Polyline3d poly = selectedObj.GetPolyline();
                            intRet = Utils.ToDynPolyCurves(poly, true);
                            ret    = Autodesk.DesignScript.Geometry.PolyCurve.ByJoinedCurves(intRet);
                        }
                        throw new System.Exception("Wrong type of Steel Object found, must be a Polybeam");
                    }
                }
                else
                {
                    throw new System.Exception("No Steel Object found or Line Object is null");
                }
            }
            return(ret);
        }
Ejemplo n.º 26
0
        private static void WritePolyline3d()
        {
            DxfDocument dxf = new DxfDocument();

            List <Polyline3dVertex> vertexes = new List <Polyline3dVertex> {
                new Polyline3dVertex(0, 0, 0),
                new Polyline3dVertex(10, 0, 10),
                new Polyline3dVertex(10, 10, 20),
                new Polyline3dVertex(0, 10, 30)
            };

            Polyline3d poly = new Polyline3d(vertexes, true);

            XData xdata = new XData(new ApplicationRegistry("netDxf"));

            xdata.XDataRecord.Add(new XDataRecord(XDataCode.String, "extended data with netDxf"));
            xdata.XDataRecord.Add(XDataRecord.OpenControlString);
            xdata.XDataRecord.Add(new XDataRecord(XDataCode.String, "netDxf polyline3d"));
            xdata.XDataRecord.Add(new XDataRecord(XDataCode.Integer, poly.Vertexes.Count));
            xdata.XDataRecord.Add(XDataRecord.CloseControlString);

            poly.XData = new Dictionary <ApplicationRegistry, XData>
            {
                { xdata.ApplicationRegistry, xdata },
            };
            dxf.AddEntity(poly);

            dxf.Save("polyline.dxf", DxfVersion.AutoCad2000);
        }
Ejemplo n.º 27
0
        public void DrawPoyLine()
        {
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            Database db  = doc.Database;

            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                BlockTable bt = trans.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
                using (BlockTableRecord btr = trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord)
                {
                    Point3dCollection p  = new Point3dCollection();
                    Point3d           p1 = new Point3d(100, 100, 100);
                    Point3d           p2 = new Point3d(150, 150, 100);
                    Point3d           p3 = new Point3d(200, 100, 100);
                    Point3d           p4 = new Point3d(200, 100, 200);
                    Point3d           p5 = new Point3d(150, 150, 200);
                    Point3d           p6 = new Point3d(100, 100, 200);
                    Point3d           p7 = new Point3d(100, 100, 150);
                    p.Add(p1); p.Add(p2); p.Add(p3); p.Add(p4); p.Add(p5); p.Add(p6); p.Add(p7);
                    Polyline3d pol = new Polyline3d(Poly3dType.SimplePoly, p, true);
                    btr.AppendEntity(pol);
                    trans.AddNewlyCreatedDBObject(pol, true);
                }

                trans.Commit();
            }
        }
Ejemplo n.º 28
0
        private void btnSelectBrklineDes_Click(object sender, EventArgs e)
        {
            ObjectId   idAlignRF = ObjectId.Null;
            Polyline3d poly3d    = default(Polyline3d);

            string strPrompt = "Select 3dPolyline Design Reference:";

            try
            {
                Point3d pnt3d = Point3d.Origin;
                poly3d = (Polyline3d)Base_Tools45.Select.selectEntity(typeof(Polyline3d), strPrompt, "3dPolyline Selection failed.", out pnt3d);
            }
            catch (Autodesk.AutoCAD.Runtime.Exception)
            {
                MessageBox.Show("Selection of Design Breakline failed. Exiting......");
                return;
            }

            BRKLINE_DESIGN_HANDLE = poly3d.Handle.ToString();

            string   strNameAlign = ACTIVEALIGN.Name.ToString() + "-REF";
            ObjectId idLayer      = Layer.manageLayers(strNameAlign);

            idAlignRF = wa1.Create_Align_Profile_By3dPoly2a(ACTIVEALIGN, "CPNT", strNameAlign, idLayer, poly3d.ObjectId);
            AlignRF   = (Alignment)idAlignRF.getEnt();
        }
Ejemplo n.º 29
0
        public static double GetElevation(this Polyline3d pl)
        {
            double?height = null;

            using (var myTrans = Application.DocumentManager.MdiActiveDocument.TransactionManager.StartTransaction())
            {
                foreach (ObjectId oid in pl)
                {
                    PolylineVertex3d v2d = myTrans.GetObject(oid, OpenMode.ForRead) as PolylineVertex3d;
                    if (v2d != null)
                    {
                        height = v2d.Position.Z;
                    }
                    break;
                }

                myTrans.Commit();
            }
            if (height.HasValue)
            {
                return(height.Value);
            }

            throw new InvalidOperationException("\nUngültige 3d-Polylinie!");
        }
Ejemplo n.º 30
0
        calcBasePntAndTargetPntElev(Point3d pnt3dTAR, double grade, Polyline3d poly3d, int vertexNo, out double elevTAR, out double station)
        {
            station   = 0.0;
            elevTAR   = 0.0;
            gp.pnt3dX = Pub.pnt3dO;

            Point3dCollection pnts3d   = poly3d.getCoordinates3d();
            Point3d           pnt3dBEG = pnts3d[vertexNo + 0];
            Point3d           pnt3dEND = pnts3d[vertexNo + 1];

            double length = pnt3dBEG.getDistance(pnt3dEND);                                     //result is 2d distance
            double slope  = (pnt3dEND.Z - pnt3dBEG.Z) / length;

            station = Math.roundDown4(pnt3dTAR.getOrthoDist(pnt3dBEG, pnt3dEND));               //result is 2d distance

            if (gp.shift)
            {
                double angle = Measure.getAzRadians(pnt3dBEG, pnt3dEND);
                gp.pnt3dX = pnt3dBEG.traverse(angle, station, slope);
                double offset = gp.pnt3dX.getDistance(pnt3dTAR);                                    //result is 2d distance
                elevTAR = gp.pnt3dX.Z + offset * grade;
            }
            else
            {
                if (station > 0 && station < length)
                {
                    double angle = Measure.getAzRadians(pnt3dBEG, pnt3dEND);
                    gp.pnt3dX = pnt3dBEG.traverse(angle, station, slope);
                    double offset = gp.pnt3dX.getDistance(pnt3dTAR);                                    //result is 2d distance
                    elevTAR = gp.pnt3dX.Z + offset * grade;
                }
            }
            return(gp.pnt3dX);
        }
        public static ObjectId Create3dPolyline(this Database database, IEnumerable <Point3d> points, string layer = null, int layerColor = 256, short entityCollor = 256)
        {
            using (var transAction = database.TransactionManager.StartOpenCloseTransaction())
            {
                // Get the layer table from the drawing
                using (var blocktable = (BlockTable)transAction.GetObject(database.BlockTableId, OpenMode.ForRead))
                {
                    var blockTableRecord = (BlockTableRecord)transAction.GetObject(blocktable[BlockTableRecord.ModelSpace], OpenMode.ForWrite);

                    ObjectId id;
                    //create the layer
                    using (var pl3d = new Polyline3d(Poly3dType.SimplePoly, new Point3dCollection(points.ToArray()), false))

                    {
                        pl3d.SetDatabaseDefaults();

                        if (layer != null)
                        {
                            database.CreateLayer(layer, (short)layerColor, "");
                            pl3d.Layer = layer;
                        }

                        pl3d.ColorIndex = entityCollor;
                        id = blockTableRecord.AppendEntity(pl3d);
                        transAction.AddNewlyCreatedDBObject(pl3d, true);
                        transAction.Commit();
                        return(id);
                    }
                }
            }
        }
Ejemplo n.º 32
0
        public void Figura2()
        {
            Database db = HostApplicationServices.WorkingDatabase;
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.GetDocument(db);
            Editor ed = doc.Editor;

            PromptDoubleOptions GetSpindulys = new PromptDoubleOptions("\nĮveskite detalės spindulį");
            double Spindulys;
            GetSpindulys.AllowNegative = false;
            GetSpindulys.AllowZero = false;
            GetSpindulys.AllowNone = false;
            PromptDoubleResult GetSpindulysRezultatas = ed.GetDouble(GetSpindulys);
            Spindulys = GetSpindulysRezultatas.Value;

            PromptPointOptions GetTaskas = new PromptPointOptions("\nPasirinkite centro tašką");
            Point3d Taskas;
            GetTaskas.AllowNone = false;
            PromptPointResult GetTaskasRezultatas = ed.GetPoint(GetTaskas);
            Taskas = GetTaskasRezultatas.Value;

            Transaction tr = db.TransactionManager.StartTransaction();
            using (tr)
            {
                BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead, false);
                BlockTableRecord btr = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite, false);

                //Apskritimas
                Circle Apskritimas = new Circle(Taskas, new Vector3d(0, 0, 1), Spindulys);
                btr.AppendEntity(Apskritimas);
                tr.AddNewlyCreatedDBObject(Apskritimas, true);

                //Linijos
                Polyline3d polyline = new Polyline3d();
                btr.AppendEntity(polyline);
                tr.AddNewlyCreatedDBObject(polyline, true);
                PolylineVertex3d vex3d = new PolylineVertex3d();

                // Linija NR1 (centrine)
                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y + Spindulys / 6, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y - Spindulys / 6, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y - Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y - Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y - Spindulys / 2 + Spindulys / 6, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y - Spindulys / 2 - Spindulys / 6, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y - Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y - Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y - Spindulys / 2 - Spindulys / 1.5, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                polyline = new Polyline3d();
                btr.AppendEntity(polyline);
                tr.AddNewlyCreatedDBObject(polyline, true);

                // Linija NR2 (virsutine)
                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y + Spindulys / 2 + Spindulys / 5, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y + Spindulys / 2 - Spindulys / 5, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y + Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y + Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y + Spindulys / 2 + Spindulys / 1.5, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                polyline = new Polyline3d();
                btr.AppendEntity(polyline);
                tr.AddNewlyCreatedDBObject(polyline, true);

                // Linija NR3 (kaire)
                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 2, Taskas.Y + Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 2, Taskas.Y - Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                vex3d = new PolylineVertex3d(new Point3d(Taskas.X - Spindulys / 2 - Spindulys / 2 - Spindulys / 4, Taskas.Y - Spindulys / 2, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                //Apskritimas FIll Viduryje
                Circle ApskritimasFillMIni = new Circle(new Point3d(Taskas.X + Spindulys / 2, Taskas.Y - Spindulys / 2, 0), new Vector3d(0, 0, 1), Spindulys / 8);
                btr.AppendEntity(ApskritimasFillMIni);
                tr.AddNewlyCreatedDBObject(ApskritimasFillMIni, true);

                Hatch hatch = new Hatch();
                btr.AppendEntity(hatch);
                tr.AddNewlyCreatedDBObject(hatch, true);

                ObjectIdCollection ID = new ObjectIdCollection();
                ID.Add(ApskritimasFillMIni.ObjectId);
                hatch.HatchStyle = HatchStyle.Ignore;
                hatch.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
                hatch.Associative = true;
                hatch.AppendLoop(HatchLoopTypes.Outermost, ID);
                hatch.EvaluateHatch(true);

                //Trikampis
                Solid trikampis = new Solid(new Point3d(Taskas.X - Spindulys / 4, Taskas.Y, 0), new Point3d(Taskas.X, Taskas.Y + Spindulys / 6, 0), new Point3d(Taskas.X, Taskas.Y - Spindulys / 6, 0));
                btr.AppendEntity(trikampis);
                tr.AddNewlyCreatedDBObject(trikampis, true);

                tr.Commit();
            }
        }
    public void AddPolylines()
    {
      ClearTransients();

      // Dispose of the database objects

      foreach (DBObject obj in _lines)
      {
        obj.Dispose();
      }
      _lines.Clear();

      // Create a true database-resident 3D polyline
      // (and let it be green)

      if (_vertices.Count > 1)
      {
        BlockTableRecord btr =
          (BlockTableRecord)_tr.GetObject(
            _doc.Database.CurrentSpaceId,
            OpenMode.ForWrite
          );

        Polyline3d pl =
          new Polyline3d(
            Poly3dType.SimplePoly, _vertices, false
          );
        pl.ColorIndex = 3;

        btr.AppendEntity(pl);
        _tr.AddNewlyCreatedDBObject(pl, true);
      }
      _vertices.Clear();
    }
Ejemplo n.º 34
0
        public static DBObject Create(this Grevit.Types.PLine a, Transaction tr)
        {
            try
            {
                LayerTable lt = (LayerTable)tr.GetObject(Command.Database.LayerTableId, OpenMode.ForRead);
                Point3dCollection pc = new Point3dCollection();
                foreach (Grevit.Types.Point p in a.points) pc.Add(p.ToPoint3d());
                Polyline3d pp = new Polyline3d(Poly3dType.SimplePoly, pc, a.closed);
                pp.SetDatabaseDefaults(Command.Database);
                if (lt.Has(a.TypeOrLayer)) pp.LayerId = lt[a.TypeOrLayer];

                BlockTable bt = (BlockTable)tr.GetObject(Command.Database.BlockTableId, OpenMode.ForRead);
                BlockTableRecord ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                ms.AppendEntity(pp);
                tr.AddNewlyCreatedDBObject(pp, true);
                return pp;
            }
            catch (Autodesk.AutoCAD.Runtime.Exception e)
            {
            }

            return null;
        }
Ejemplo n.º 35
0
        public static DBObject Create(this Grevit.Types.Slab s, Transaction tr)
        {
            try
            {
                BlockTable bt = (BlockTable)tr.GetObject(Command.Database.BlockTableId, OpenMode.ForRead);
                BlockTableRecord ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);

                // Polyline acPoly = new Polyline();
                //acPoly.SetDatabaseDefaults();

                //int i = 0;

                DBObjectCollection objColl = new DBObjectCollection();
                Point3dCollection ptcol = new Point3dCollection();
                foreach (Grevit.Types.Loop loop in s.surface.profile)
                {
                    foreach (Grevit.Types.Component p in loop.outline)
                        ptcol = p.To3dPointCollection();


                    //Curve3dCollection collt = parse3dCurve(p);
                    //acPoly.AppendVertex(new PolylineVertex3d(new Point3d(p.x, p.y, p.z)));
                    //acPoly.AddVertexAt(i, new Point2d(p.x, p.y), 0, 0, 0);
                    //i++;

                    //foreach (Curve3d curve in collt)
                    //{ 
                    //    objColl.Add(Autodesk.AutoCAD.DatabaseServices.Curve.CreateFromGeCurve(curve));
                    //}
                }

                Polyline3d face = new Polyline3d(Poly3dType.SimplePoly, ptcol, true);
                objColl.Add(face);
                //Polyline3d face = new Polyline3d();
                //ETC...
                // or from your settings
                // Polyline3d face = new Polyline3d(Poly3dType.SimplePoly, vertices, true);





                DBObjectCollection myRegionColl = new DBObjectCollection();
                // create a single region
                Autodesk.AutoCAD.DatabaseServices.Region objreg = new Autodesk.AutoCAD.DatabaseServices.Region();
                DBObjectCollection objRegions = new DBObjectCollection();
                try
                {
                    objRegions = Autodesk.AutoCAD.DatabaseServices.Region.CreateFromCurves(objColl);
                    objreg = objRegions[0] as Autodesk.AutoCAD.DatabaseServices.Region;

                }
                catch (Autodesk.AutoCAD.Runtime.Exception ex)
                {
                    // eInvalidInput exception
                    Autodesk.AutoCAD.ApplicationServices.Application.ShowAlertDialog("Error: unable to create region collection:\n" + ex.Message);

                }






                //acPoly.Closed = true;
                //ms.AppendEntity(acPoly);
                //tr.AddNewlyCreatedDBObject(acPoly, true);

                //atrix3d mm = Matrix3d.Displacement(new Vector3d(0, 0, r.outline[0].z));
                //acPoly.TransformBy(mm);


                //Autodesk.Aec.Geometry.Profile myProfile = Autodesk.Aec.Geometry.Profile.CreateFromEntity(acPoly, ed.CurrentUserCoordinateSystem);

                //Slab slab = new Slab();
                //slab.SetDatabaseDefaults(db);
                //slab.SetToStandard(db);         
                //slab.Location = new Point3d(0, 0, 0);

                //slab.SetBaseProfile(myProfile, Matrix3d.Identity);

                //DBObjectCollection col = acPoly.GetOffsetCurves(0);


                //DBObjectCollection res = Region.CreateFromCurves(coll);

                //Region reg = res[0] as Region;

                Solid3d solid = new Solid3d();
                solid.Extrude(objreg, s.height, s.slope);


                LayerTable lt = (LayerTable)tr.GetObject(Command.Database.LayerTableId, OpenMode.ForRead);
                if (s.TypeOrLayer != "") { if (lt.Has(s.TypeOrLayer)) solid.LayerId = lt[s.TypeOrLayer]; }
                //if (ss.Has(r.family, tr)) slab.StyleId = ss.GetAt(r.family);


                ms.AppendEntity(solid);
                tr.AddNewlyCreatedDBObject(solid, true);
                return solid;
            }

            catch (Autodesk.AutoCAD.Runtime.Exception e)
            {
            }

            return null;
        }
Ejemplo n.º 36
0
        public static void Create(Grevit.Types.PLine a)
        {
            Database db = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Database;
            Transaction tr = db.TransactionManager.StartTransaction();
            Editor ed = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;

            try
            {
                LayerTable lt = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
                Point3dCollection pc = new Point3dCollection();
                foreach (Grevit.Types.Point p in a.points) pc.Add(GrevitPtoPoint3d(p));
                Polyline3d pp = new Polyline3d(Poly3dType.SimplePoly, pc, a.closed);
                pp.SetDatabaseDefaults(db);
                if (lt.Has(a.TypeOrLayer)) pp.LayerId = lt[a.TypeOrLayer];

                BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                ms.AppendEntity(pp);
                tr.AddNewlyCreatedDBObject(pp, true);
                writeProperties(pp, a.parameters, tr);
                storeID(a, pp.Id);
                tr.Commit();
            }

            catch (Autodesk.AutoCAD.Runtime.Exception e)
            {
                ed.WriteMessage(e.Message);
                tr.Abort();
            }

            finally
            {
                tr.Dispose();
            }
        }
Ejemplo n.º 37
0
        public void Figura1()
        {
            Database db = HostApplicationServices.WorkingDatabase;
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.GetDocument(db);
            Editor ed = doc.Editor;

            PromptDoubleOptions GetIlgis = new PromptDoubleOptions("\nĮveskite mikroskemos ilgį");
            double Ilgis;
            GetIlgis.AllowNegative = false;
            GetIlgis.AllowZero = false;
            GetIlgis.AllowNone = false;
            PromptDoubleResult GetIlgisRezultatas = ed.GetDouble(GetIlgis);
            Ilgis = GetIlgisRezultatas.Value;

            PromptDoubleOptions GetPlotis = new PromptDoubleOptions("\nĮveskite mikroskemos plotį");
            double Plotis;
            GetPlotis.AllowNegative = false;
            GetPlotis.AllowZero = false;
            GetPlotis.AllowNone = false;
            PromptDoubleResult GetPlotisRezultatas = ed.GetDouble(GetPlotis);
            Plotis = GetPlotisRezultatas.Value;

            PromptPointOptions GetTaskas = new PromptPointOptions("\nPasirinkite tašką");
            Point3d Taskas;
            GetTaskas.AllowNone = false;
            PromptPointResult GetTaskasRezultatas = ed.GetPoint(GetTaskas);
            Taskas = GetTaskasRezultatas.Value;

            Transaction tr = db.TransactionManager.StartTransaction();
            using (tr)
            {
                BlockTable bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead, false);
                BlockTableRecord btr = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite,false);
                Polyline3d polyline = new Polyline3d();
                btr.AppendEntity(polyline);
                tr.AddNewlyCreatedDBObject(polyline, true);
                PolylineVertex3d vex3d = new PolylineVertex3d();

                //Pradinis taskas
                vex3d = new PolylineVertex3d(Taskas);
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                //Atsakos tarp pradinio ir pirmo kampo
                double betaIlgis = Ilgis / 8;
                double AtsakosIlgis = Math.Min(Ilgis / 4, Plotis / 4);
                for (int i = 1; i < 8; i++)
                {
                    // Linija iki atsakos
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X, Taskas.Y + betaIlgis * i, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos linija
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X - AtsakosIlgis, Taskas.Y + betaIlgis * i, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos grizimas atgal i kontura
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X, Taskas.Y + betaIlgis * i, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);
                }

                // Pirmas kampas
                vex3d = new PolylineVertex3d(new Point3d(Taskas.X, Taskas.Y + Ilgis, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                //Atsakos tarp pirmo ir angtro kampo
                double betaPlotis = Plotis / 2;
                for (int i = 1; i < 2; i++)
                {
                    // Linija iki atsakos
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + betaPlotis * i, Taskas.Y + Ilgis, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos linija
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + betaPlotis * i, Taskas.Y + Ilgis + AtsakosIlgis, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos grizimas atgal i kontura
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + betaPlotis * i, Taskas.Y + Ilgis, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);
                }

                //Antras kampas
                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis, Taskas.Y + Ilgis, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                //Atsakos tarp antro ir trecio kampo
                for (int i = 1; i < 8; i++)
                {
                    // Linija iki atsakos
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis, Taskas.Y + Ilgis - betaIlgis * i, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos linija
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis + AtsakosIlgis, Taskas.Y + Ilgis - betaIlgis * i, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos grizimas atgal i kontura
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis, Taskas.Y + Ilgis - betaIlgis * i, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);
                }

                //Trecias kampas
                vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis, Taskas.Y, 0));
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);

                //Atsakos tarp trecio ir pradinio kampo
                for (int i = 1; i < 2; i++)
                {
                    // Linija iki atsakos
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis - betaPlotis * i, Taskas.Y, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos linija
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis - betaPlotis * i, Taskas.Y - AtsakosIlgis, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);

                    //Atsakos grizimas atgal i kontura
                    vex3d = new PolylineVertex3d(new Point3d(Taskas.X + Plotis - betaPlotis * i, Taskas.Y, 0));
                    polyline.AppendVertex(vex3d);
                    tr.AddNewlyCreatedDBObject(vex3d, true);
                }

                //Ketvirtas kampas / Pradinis taskas
                vex3d = new PolylineVertex3d(Taskas);
                polyline.AppendVertex(vex3d);
                tr.AddNewlyCreatedDBObject(vex3d, true);
                tr.Commit();
            }
        }