Beispiel #1
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);
        }
Beispiel #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);
        }
Beispiel #3
0
        updatePoly3dCoordinates(this ObjectId idPoly3dOrg, List <Point3d> pnts3d)
        {
            ObjectId   idPoly3dNew = ObjectId.Null;
            Polyline3d poly3dNew   = new Polyline3d();

            using (Transaction tr = BaseObjs.startTransactionDb())
            {
                BlockTableRecord ms = Blocks.getBlockTableRecordMS();
                idPoly3dNew = ms.AppendEntity(poly3dNew);

                poly3dNew.SetDatabaseDefaults();
                poly3dNew.Layer = idPoly3dOrg.getLayer();
                foreach (Point3d pnt3dX in pnts3d)
                {
                    PolylineVertex3d v3d = new PolylineVertex3d(pnt3dX);
                    poly3dNew.AppendVertex(v3d);
                    tr.AddNewlyCreatedDBObject(v3d, true);
                }
                tr.AddNewlyCreatedDBObject(poly3dNew, true);
                tr.Commit();
            }

            using (Transaction tr1 = BaseObjs.startTransactionDb())
            {
                DBObject dbObjOrg = tr1.GetObject(idPoly3dOrg, OpenMode.ForRead);
                DBObject dbObjNew = tr1.GetObject(idPoly3dNew, OpenMode.ForRead);

                dbObjNew.UpgradeOpen();
                dbObjNew.SwapIdWith(dbObjOrg.ObjectId, true, true);

                idPoly3dNew.delete();
                tr1.Commit();
            }
        }
Beispiel #4
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);
        }
        /// <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);
        }
Beispiel #6
0
        addVertexToPoly3d(this ObjectId idPoly3dOrg, Point3d pnt3d, int pos, Handle hCgPNt)
        {
            List <Point3d> pnts3d      = idPoly3dOrg.getCoordinates3dList();
            ObjectId       idPoly3dNew = ObjectId.Null;
            Polyline3d     poly3dNew   = new Polyline3d();

            using (Transaction tr = BaseObjs.startTransactionDb())
            {
                BlockTableRecord ms = Blocks.getBlockTableRecordMS();
                idPoly3dNew = ms.AppendEntity(poly3dNew);

                poly3dNew.SetDatabaseDefaults();
                poly3dNew.Layer = idPoly3dOrg.getLayer();
                pnts3d.Insert(pos + 1, pnt3d);
                foreach (Point3d pnt3dX in pnts3d)
                {
                    PolylineVertex3d v3d = new PolylineVertex3d(pnt3dX);
                    poly3dNew.AppendVertex(v3d);
                    tr.AddNewlyCreatedDBObject(v3d, true);
                }
                tr.AddNewlyCreatedDBObject(poly3dNew, true);
                tr.Commit();
            }

            using (Transaction tr1 = BaseObjs.startTransactionDb())
            {
                DBObject dbObjOrg = tr1.GetObject(idPoly3dOrg, OpenMode.ForRead);
                DBObject dbObjNew = tr1.GetObject(idPoly3dNew, OpenMode.ForRead);

                dbObjNew.UpgradeOpen();
                dbObjNew.SwapIdWith(dbObjOrg.ObjectId, true, true);

                idPoly3dNew.delete();
                tr1.Commit();
            }

            ResultBuffer rb = idPoly3dOrg.getXData(apps.lnkBrks);

            TypedValue[] tvs = rb.AsArray();

            TypedValue[] tvsNew = new TypedValue[tvs.Length + 1];
            for (int i = 0; i < pos + 2; i++)
            {
                tvsNew[i] = tvs[i];
            }
            tvsNew.SetValue(new TypedValue(1005, hCgPNt), pos + 2);

            for (int i = pos + 2; i < tvs.Length; i++)
            {
                tvsNew[i + 1] = tvs[i];
            }

            idPoly3dOrg.clearXData(apps.lnkBrks);
            idPoly3dOrg.setXData(tvsNew, apps.lnkBrks);
        }
Beispiel #7
0
        private void CreatePolyline(List <SimplePoint3d> points)
        {
            Polyline3d polyline = new Polyline3d();

            _transaction.AddObjectToActiveModelSpace(polyline);
            foreach (SimplePoint3d point in points)
            {
                var point3d = new Point3d(point.X, point.Y, point.Z);
                using (PolylineVertex3d vertex = new PolylineVertex3d(point3d)) {
                    polyline.AppendVertex(vertex);
                }
            }
        }
Beispiel #8
0
        /// <summary>
        ///  Adds vertices to a polyline and adds it to a transaction.
        /// </summary>
        /// <param name="polyLine"></param>
        /// <param name="pointCollection"></param>
        public static void AddVertices(this Polyline3d polyLine, Point3dCollection pointCollection)
        {
            AutoCadHelper.AppendAndAddToTransaction(polyLine);

            foreach (Point3d point in pointCollection)
            {
                var vertex = new PolylineVertex3d(point);
                polyLine.AppendVertex(vertex);
                AutoCadHelper.AddToTransaction(vertex);
            }

            // Erase the polyline before commiting so it's not drawn.
            polyLine.Erase();
        }
        private static Entity Draw3dPline(Point[] points, bool closePart)
        {
            Document   document           = AfaDocData.ActiveDocData.Document;
            Database   database           = document.Database;
            var        transactionManager = document.TransactionManager;
            Polyline3d polyline3d         = new Polyline3d();

            using (document.LockDocument())
            {
                using (Transaction transaction = transactionManager.StartTransaction())
                {
                    BlockTable       blockTable       = (BlockTable)transaction.GetObject(database.BlockTableId, 0);
                    BlockTableRecord blockTableRecord = (BlockTableRecord)transaction.GetObject(blockTable[(BlockTableRecord.ModelSpace)], (OpenMode)1);
                    polyline3d.ColorIndex = (256);
                    blockTableRecord.AppendEntity(polyline3d);
                    transaction.AddNewlyCreatedDBObject(polyline3d, true);
                    int num = 0;
                    if (points != null && points.Length > 0)
                    {
                        for (int i = 0; i < points.Length; i++)
                        {
                            Point            point            = points[i];
                            PointN           pointN           = (PointN)point;
                            PolylineVertex3d polylineVertex3d = new PolylineVertex3d(new Point3d(pointN.X, pointN.Y, pointN.Z));
                            polyline3d.AppendVertex(polylineVertex3d);
                            num++;
                        }
                    }
                    if (num == 0)
                    {
                        return(null);
                    }
                    if (closePart)
                    {
                        polyline3d.Closed = (true);
                    }
                    polyline3d.ColorIndex = (256);
                    document.TransactionManager.QueueForGraphicsFlush();
                    document.TransactionManager.FlushGraphics();
                    document.Editor.UpdateScreen();
                    transaction.Commit();
                }
            }
            return(polyline3d);
        }
Beispiel #10
0
        //convert parts to splines (works for line and arcs*Not arcs yet)
        static private Spline convertSpline(DBObject dbo)
        {
            if (dbo is Spline)
            {
                return(dbo as Spline);
            }
            if (dbo is Arc)
            {
                Arc    arcDat = dbo as Arc;
                Spline seg    = new Spline();
                //whatever that is
                return(seg);
            }
            else if (dbo is Line)
            {
                Line lDat = dbo as Line;
                Point3dCollection vertices = new Point3dCollection();
                vertices.Add(lDat.StartPoint);
                vertices.Add(lDat.EndPoint);
                Polyline3d tempPline = new Polyline3d();
                //polyine 3D has to be in btr before adding vertices
                Database db = HostApplicationServices.WorkingDatabase;
                using (Transaction trans = db.TransactionManager.StartTransaction())
                {
                    BlockTableRecord btr = (BlockTableRecord)(trans.GetObject(db.CurrentSpaceId, OpenMode.ForWrite));
                    btr.AppendEntity(tempPline);
                    foreach (Point3d pnt in vertices)
                    {
                        using (PolylineVertex3d poly3dVert = new PolylineVertex3d(pnt))
                        {
                            tempPline.AppendVertex(poly3dVert);
                        }
                    }
                    trans.Commit();
                }

                Spline seg = tempPline.Spline;
                tempPline.Erase(true);
                return(seg);
            }
            return(null);
        }
Beispiel #11
0
        private static void CreatePolyline3dFromPoints(Database db, IEnumerable <Point3d> points, bool shouldClose)
        {
            var trans = db.TransactionManager.TopTransaction;

            var acBlkTbl    = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
            var acBlkTblRec = (BlockTableRecord)trans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite);

            var poly3d = new Polyline3d();

            acBlkTblRec.AppendEntity(poly3d);
            trans.AddNewlyCreatedDBObject(poly3d, true);

            foreach (var point in points)
            {
                using (var poly3dVertex = new PolylineVertex3d(point))
                {
                    poly3d.AppendVertex(poly3dVertex);
                }
            }

            poly3d.Closed = shouldClose;
        }
        /// <summary>
        /// Adds the polyline3d.
        /// </summary>
        /// <param name="sidedb">The sidedb.</param>
        /// <param name="points">The points.</param>
        /// <param name="layername">The layername.</param>
        /// <param name="isClosed">if set to <c>true</c> [is closed].</param>
        /// <param name="colorIndex">Index of the color.</param>
        /// <returns>ObjectId.</returns>
        public static ObjectId AddPolyline3d(Autodesk.AutoCAD.DatabaseServices.Database sidedb, Point3dCollection points, string layername, bool isClosed, int colorIndex)
        {
            //_logger.Debug("Start AddPolyline");
            ObjectId id = ObjectId.Null;

            Autodesk.AutoCAD.DatabaseServices.Database db = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Database;
            HostApplicationServices.WorkingDatabase = sidedb;

            using (Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = sidedb.TransactionManager)
            {
                using (Transaction tr = tm.StartTransaction())
                {
                    Polyline3d pline = new Polyline3d();

                    pline.SetDatabaseDefaults();
                    pline.Layer = layername;
                    if ((colorIndex > 0) && (colorIndex < 256))
                    {
                        pline.ColorIndex = colorIndex;
                    }
                    // int index = 0;
                    // double width = 0.0;

                    foreach (PolylineVertex3d pt in points)
                    {
                        pline.AppendVertex(pt);
                    }

                    pline.Closed = isClosed;
                    id           = AddToDatabase(db, pline, tr);

                    tr.Commit();
                }
            }
            //_logger.Debug("End AddPolyline");
            return(id);
        }
Beispiel #13
0
        /// <summary>
        /// project 3d polyline in XY plane, return a flattened polyline on XY plane and orignal 3d polyline
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="id">ObjectId of the 3d Polyline</param>
        /// <param name="originalPoly3d"></param>
        /// <returns></returns>
        public static Polyline3d CreatePolylineOnXYPlane(Document doc, ObjectId id, ref Polyline3d originalPoly3d)
        {
            Polyline3d pl = new Polyline3d();

            Database db = doc.Database;

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

                DBObject obj       = tr.GetObject(id, OpenMode.ForRead);
                Entity   ent       = obj as Entity;
                string   layerName = ent.Layer.ToString();

                pl.Layer = layerName;
                btr.AppendEntity(pl);
                tr.AddNewlyCreatedDBObject(pl, true);

                Polyline3d p3d = obj as Polyline3d;
                if (p3d != null)
                {
                    originalPoly3d = p3d;
                    foreach (ObjectId vId in p3d)
                    {
                        PolylineVertex3d v3d     = (PolylineVertex3d)tr.GetObject(vId, OpenMode.ForRead);
                        PolylineVertex3d v3d_new = new PolylineVertex3d(new Point3d(v3d.Position.X, v3d.Position.Y, 0));
                        pl.AppendVertex(v3d_new);//apdd point into 3d polyline
                        tr.AddNewlyCreatedDBObject(v3d_new, true);
                    }
                }

                tr.Commit();
            }

            return(pl);
        }
Beispiel #14
0
        public void ExtractSpillwayPositions()
        {
            Document adoc = Application.DocumentManager.MdiActiveDocument;

            if (adoc == null)
            {
                return;
            }

            Database db = adoc.Database;

            Editor ed = adoc.Editor;

            List <Polyline3d> highlighted = new List <Polyline3d>();

            try
            {
                Plane horizontalPlane = new Plane(Point3d.Origin, Vector3d.ZAxis);


                //Указать линию КПЧ и линии перелома откоса (они должны быть в соответствующих слоях)
                TypedValue[]           tv   = new TypedValue[] { new TypedValue(0, "POLYLINE"), new TypedValue(8, "КПЧ,ОТК") };//ограничение по слоям
                SelectionFilter        flt  = new SelectionFilter(tv);
                PromptSelectionOptions opts = new PromptSelectionOptions();
                opts.MessageForAdding = "\nВыберите 3d-полилинии, обозначающие край проезжей части"
                                        + "и переломы откоса (только с одной стороны дороги). Линии должны быть в слоях КПЧ и ОТК";
                PromptSelectionResult res = ed.GetSelection(opts, flt);
                if (res.Status == PromptStatus.OK)
                {
                    SelectionSet sset = res.Value;
                    //Отобрать только полилинии в нужных слоях
                    Dictionary <string, List <Polyline3dInfo> > slopeLines = new Dictionary <string, List <Polyline3dInfo> >();



                    //Считать направление полилинии соответствующим направлению дороги
                    bool?          toTheRight = null;//водосброс справа от КПЧ
                    Polyline3dInfo baseLine   = null;
                    using (Transaction tr = db.TransactionManager.StartTransaction())
                    {
                        WrongPolylinesException wrongPolylinesException = new WrongPolylinesException();



                        //Отбор линий в служебных слоях
                        foreach (SelectedObject acSSObj in sset)
                        {
                            Polyline3d currPoly = tr.GetObject(acSSObj.ObjectId, OpenMode.ForRead) as Polyline3d;
                            if (currPoly != null)
                            {
                                if (currPoly.Layer.Equals("КПЧ") || currPoly.Layer.Equals("ОТК"))
                                {
                                    List <Polyline3dInfo> polylines = null;
                                    slopeLines.TryGetValue(currPoly.Layer, out polylines);
                                    if (polylines == null)
                                    {
                                        polylines = new List <Polyline3dInfo>();
                                        slopeLines.Add(currPoly.Layer, polylines);
                                    }
                                    polylines.Add(new Polyline3dInfo(currPoly.Layer, currPoly));
                                }
                            }
                        }

                        //Проверить, что есть весь набор слоев - КПЧ, ОТК
                        if (!slopeLines.ContainsKey("КПЧ") || !slopeLines.ContainsKey("ОТК"))
                        {
                            wrongPolylinesException.Mistakes = wrongPolylinesException.Mistakes | Mistake.NotEnoughLayers;
                        }

                        //Проверить, что в слое КПЧ находится только 1 полилиния
                        List <Polyline3dInfo> checkList1 = null;
                        slopeLines.TryGetValue("КПЧ", out checkList1);
                        if (checkList1 == null || checkList1.Count != 1)
                        {
                            wrongPolylinesException.Mistakes = wrongPolylinesException.Mistakes | Mistake.TooManyLinesInOneLayer;
                        }

                        #region Проперка непересечения линий
                        //Проверить что линии откоса не пересекают друг друга в плане
                        //TODO: ВРЕМЕННО отказался от проверки взаимного пересечения линий откоса. Нужно учесть возможность частичного совпадения линий

                        /*
                         * List<Polyline3dInfo> slopeLinesList = slopeLines.Values.ToList().Aggregate((l1, l2) =>
                         * {
                         *  return l1.Concat(l2).ToList();
                         * });
                         * bool exitLoop = false;
                         * for (int i = 0; i < slopeLinesList.Count; i++)
                         * {
                         *  for (int j = i + 1; j < slopeLinesList.Count; j++)
                         *  {
                         *      Polyline3d poly1 = slopeLinesList[i].Poly3d;
                         *      Polyline3d poly2 = slopeLinesList[j].Poly3d;
                         *      Point3dCollection intersectPts = new Point3dCollection();
                         *      poly1.IntersectWith(poly2, Intersect.OnBothOperands,
                         *          horizontalPlane, intersectPts,
                         *          new IntPtr(0), new IntPtr(0));
                         *
                         *      //TODO!!!!! Не считать точки пересечения если в точках пересечения происходит полное совпадение вершин двух полилиний
                         *      //В это случае скорее всего полилинии просто сливаются в одну. Это допустимо для коридора
                         *
                         *
                         *
                         *      if (intersectPts.Count > 0)
                         *      {
                         *
                         *
                         *
                         *          wrongPolylinesException.Mistakes = wrongPolylinesException.Mistakes | Mistake.LinesAreIntersecting;
                         *          exitLoop = true;
                         *          break;
                         *      }
                         *  }
                         *  if (exitLoop)
                         *      break;
                         * }
                         */
                        #endregion

                        //Проверить, что все точки откоса расположены с одной стороны от КПЧ
                        //Определить водосброс направо или налево
                        //TODO: Проверить сонаправленность линий! (низкий приоритет)



                        //Для всех кодов определить участки КПЧ. Параметры взаимного расположения расчитываются в горизонтальной проекции
                        //По начальным точкам линий определить расположение линии справа или слева от КПЧ

                        //базовая линия - КПЧ
                        List <Polyline3dInfo> list = null;
                        slopeLines.TryGetValue("КПЧ", out list);

                        if (list != null && list.Count > 0)
                        {
                            baseLine = list.First();

                            foreach (KeyValuePair <string, List <Polyline3dInfo> > kvp in slopeLines)
                            {
                                if (!kvp.Key.Equals("КПЧ"))
                                {
                                    foreach (Polyline3dInfo poly3dInfo in kvp.Value)
                                    {
                                        poly3dInfo.BaseLine = baseLine.Poly2d;
                                        poly3dInfo.ComputeParameters();
                                        poly3dInfo.ComputeOrientation();
                                        //проверка, что все линии с одной стороны от базовой
                                        if (toTheRight != null)
                                        {
                                            if (toTheRight != poly3dInfo.ToTheRightOfBaseLine)
                                            {
                                                wrongPolylinesException.Mistakes = wrongPolylinesException.Mistakes | Mistake.WrongOrientation;
                                            }
                                        }
                                        else
                                        {
                                            toTheRight = poly3dInfo.ToTheRightOfBaseLine;
                                        }
                                    }
                                }
                            }
                        }


                        if (wrongPolylinesException.Mistakes != Mistake.None)
                        {
                            throw wrongPolylinesException;
                        }

                        #region Test
                        //ed.WriteMessage("\nОшибок нет\ntoTheRight = " + toTheRight);
                        ////Начертить круги в точках начала и конца полилиний
                        //BlockTable bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
                        //BlockTableRecord ms
                        //        = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                        //foreach (KeyValuePair<string, List<Polyline3dInfo>> kvp in slopeLines)
                        //{
                        //    if (!kvp.Key.Equals("КПЧ"))
                        //    {
                        //        foreach (Polyline3dInfo poly3dInfo in kvp.Value)
                        //        {
                        //            Point3d pt1 = poly3dInfo.Poly3d.GetPointAtParameter(poly3dInfo.StartParameter);
                        //            Point3d pt2 = poly3dInfo.Poly3d.GetPointAtParameter(poly3dInfo.EndParameter);
                        //            Point3d pt3 = baseLine.Poly3d.GetPointAtParameter(poly3dInfo.StartParameterBase);
                        //            Point3d pt4 = baseLine.Poly3d.GetPointAtParameter(poly3dInfo.EndParameterBase);

                        //            foreach (Point3d pt in new Point3d[] { pt1, pt2, pt3, pt4 })
                        //            {
                        //                using (Circle circle = new Circle(pt, Vector3d.ZAxis, 1))
                        //                {
                        //                    circle.Color = Color.FromColorIndex(ColorMethod.ByAci, 1);
                        //                    ms.AppendEntity(circle);
                        //                    tr.AddNewlyCreatedDBObject(circle, true);
                        //                }
                        //            }
                        //            using (Line line = new Line(pt1, pt3))
                        //            {
                        //                line.Color = Color.FromColorIndex(ColorMethod.ByAci, 1);
                        //                ms.AppendEntity(line);
                        //                tr.AddNewlyCreatedDBObject(line, true);
                        //            }
                        //            using (Line line = new Line(pt2, pt4))
                        //            {
                        //                line.Color = Color.FromColorIndex(ColorMethod.ByAci, 1);
                        //                ms.AppendEntity(line);
                        //                tr.AddNewlyCreatedDBObject(line, true);
                        //            }


                        //        }
                        //    }
                        //}
                        #endregion

                        tr.Commit();
                    }

                    //Включать подсветку 3d полилиний, которые участвуют в расчете
                    highlighted.Clear();
                    foreach (KeyValuePair <string, List <Polyline3dInfo> > kvp in slopeLines)
                    {
                        foreach (Polyline3dInfo p3dI in kvp.Value)
                        {
                            p3dI.Poly3d.Highlight();
                            highlighted.Add(p3dI.Poly3d);
                        }
                    }

                    int          spillwayNum  = 1;
                    PositionData positionData = new PositionData();
                    while (true)
                    {
                        //Указать точку расположения водосброса
                        PromptPointResult  pPtRes;
                        PromptPointOptions pPtOpts = new PromptPointOptions("");
                        pPtOpts.Message = "\nУкажите точку расположения водосброса: ";
                        pPtRes          = adoc.Editor.GetPoint(pPtOpts);
                        if (pPtRes.Status == PromptStatus.OK)
                        {
                            Point3d pickedPt = new Point3d(pPtRes.Value.X, pPtRes.Value.Y, 0);

                            Point3d nearestPtOnBase = baseLine.Poly2d.GetClosestPointTo(pickedPt, true);       //найти ближайшую точку базовой линии

                            double pickedParameterBase = baseLine.Poly2d.GetParameterAtPoint(nearestPtOnBase); //параметр базовой линии в этой точке
                            //Найти все линии откоса, которые расположены в районе данного параметра
                            //Предполагается, что для каждого кода есть только одна такая
                            List <Polyline3dInfo> pickedPtSlopeLines =
                                slopeLines["ОТК"].FindAll(l => l.StartParameterBase <= pickedParameterBase && l.EndParameterBase >= pickedParameterBase);


                            if (pickedPtSlopeLines.Count > 1)//Проверить, что найдены минимум 2 линии перелома откоса
                            {
                                //Найти ближайшую линию к базовой линии - это бровка
                                Polyline3dInfo edgeLine = null;
                                double         minDist  = double.MaxValue;
                                foreach (Polyline3dInfo p3dI in pickedPtSlopeLines)
                                {
                                    Point3d ptOnLine = p3dI.Poly2d.GetClosestPointTo(nearestPtOnBase, false);
                                    double  distance = ptOnLine.DistanceTo(nearestPtOnBase);
                                    if (distance < minDist)
                                    {
                                        minDist  = distance;
                                        edgeLine = p3dI;
                                    }
                                }



                                Point3d nearestPtOnEdge = edgeLine.Poly2d.GetClosestPointTo(pickedPt, true);       //найти ближайшую точку бровки

                                double pickedParameterEdge = edgeLine.Poly2d.GetParameterAtPoint(nearestPtOnEdge); //параметр бровки в этой точке

                                //Найти касательную к бровке
                                Vector3d tangentVector = edgeLine.Poly2d.GetFirstDerivative(pickedParameterEdge);

                                double rotateAngle = toTheRight.Value ? -Math.PI / 2 : Math.PI / 2;

                                Vector3d          spillWayVector = tangentVector.RotateBy(rotateAngle, Vector3d.ZAxis).GetNormal();//вектор водосброса, перпендикулярный бровке
                                Line              spillWayAxis   = new Line(nearestPtOnEdge, nearestPtOnEdge + spillWayVector);
                                Point3dCollection intersections  = new Point3dCollection();
                                baseLine.Poly2d.IntersectWith(spillWayAxis, Intersect.ExtendArgument,
                                                              horizontalPlane, intersections,
                                                              new IntPtr(0), new IntPtr(0));
                                if (intersections.Count > 0)
                                {
                                    Point3d basePt = intersections[0];//Точка пересечения оси водосброса с КПЧ
                                    //Найти точки пересечения перпендикуляра к ОТК0 и остальными линиями откоса
                                    //Отсортировать все линии по удаленности от КПЧ в этой точке
                                    SortedDictionary <Point3d, Polyline3dInfo> intersectionPts
                                        = new SortedDictionary <Point3d, Polyline3dInfo>(new PtsSortComparer(basePt));
                                    pickedPtSlopeLines.Add(baseLine);
                                    foreach (Polyline3dInfo p3dI in pickedPtSlopeLines)
                                    {
                                        intersections.Clear();
                                        p3dI.Poly2d.IntersectWith(spillWayAxis, Intersect.ExtendArgument,
                                                                  horizontalPlane, intersections,
                                                                  new IntPtr(0), new IntPtr(0));
                                        if (intersections.Count > 0)
                                        {
                                            intersectionPts.Add(intersections[0], p3dI);
                                        }
                                    }

                                    if (intersectionPts.Count == pickedPtSlopeLines.Count)//Проверить, что все пересечения найдены
                                    {
                                        //intersectionPts содержит все линии с точками пересечения в нужном порядке,
                                        //но все точки пересечения лежат на плоскости XY
                                        //Расчитать трехмерные точки
                                        Point3dCollection pts = new Point3dCollection();
                                        foreach (KeyValuePair <Point3d, Polyline3dInfo> kvp in intersectionPts)
                                        {
                                            Point3d pt2d = kvp.Key;
                                            pt2d = kvp.Value.Poly2d.GetClosestPointTo(pt2d, false);//по какой-то причине в некоторых случаях без этой строки вылетала ошибка при получении параметра
                                            double  param = kvp.Value.Poly2d.GetParameterAtPoint(pt2d);
                                            Point3d pt3d  = kvp.Value.Poly3d.GetPointAtParameter(param);
                                            pts.Add(pt3d);
                                        }


                                        using (Transaction tr = db.TransactionManager.StartTransaction())
                                        {
                                            //Регистрация приложения
                                            Utils.RegisterApp(db, tr);


                                            ObjectId layerId = Utils.CreateLayerIfNotExists("ВОДОСБРОС", db, tr, null,
                                                                                            Color.FromColorIndex(ColorMethod.ByAci, 150), LineWeight.LineWeight030);


                                            BlockTable       bt = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
                                            BlockTableRecord ms
                                                = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);

                                            //Вычерчивание 3d полилинии по линии водосброса
                                            using (Polyline3d poly3d = new Polyline3d())
                                            {
                                                poly3d.LayerId  = layerId;
                                                poly3d.PolyType = Poly3dType.SimplePoly;
                                                ms.AppendEntity(poly3d);
                                                tr.AddNewlyCreatedDBObject(poly3d, true);

                                                foreach (Point3d pt in pts)
                                                {
                                                    PolylineVertex3d vertex = new PolylineVertex3d(pt);
                                                    poly3d.AppendVertex(vertex);
                                                    tr.AddNewlyCreatedDBObject(vertex, true);
                                                }


                                                //В расширенные данные записать название водосброса
                                                poly3d.XData = new ResultBuffer(
                                                    new TypedValue(1001, Constants.AppName),
                                                    new TypedValue(1000, spillwayNum.ToString()));
                                            }

                                            tr.Commit();
                                        }


                                        Vector3d baseVector = Vector3d.YAxis;
                                        int      sign       = Math.Sign(baseVector.CrossProduct(spillWayVector).Z);
                                        double   rotation   = spillWayVector.GetAngleTo(baseVector) * sign; //в радианах
                                        rotation = rotation * 180 / (Math.PI);                              //в градусах
                                        List <Slope> slopes = new List <Slope>();
                                        //Сохраниение расположения водосброса и всех уклонов
                                        for (int i = 0; i < pts.Count - 1; i++)
                                        {
                                            Point3d pt1    = pts[i];
                                            Point3d pt2    = pts[i + 1];
                                            Point2d pt1_2d = new Point2d(pt1.X, pt1.Y);
                                            Point2d pt2_2d = new Point2d(pt2.X, pt2.Y);

                                            double len = pt1_2d.GetDistanceTo(pt2_2d);
                                            if (len > 0)
                                            {
                                                double s = (pt2.Z - pt1.Z) / len;
                                                slopes.Add(new Slope()
                                                {
                                                    S = s, Len = len
                                                });
                                            }
                                        }

                                        SpillwayPosition spillwayPosition = new SpillwayPosition()
                                        {
                                            Name       = spillwayNum.ToString(),
                                            X          = pts[0].X,
                                            Y          = pts[0].Y,
                                            Z          = pts[0].Z,
                                            Z_Rotation = rotation,
                                            ToTheRight = toTheRight.Value,
                                            Slopes     = slopes
                                        };
                                        spillwayNum++;
                                        positionData.SpillwayPositions.Add(spillwayPosition);
                                    }
                                }
                            }
                        }
                        else
                        {
                            //ed.WriteMessage("\nвыбор закончен");

                            break;
                        }
                    }



                    //ed.WriteMessage("\nпродолжение выполнения");
                    //Сериализация расположений. Сохранить xml в папку рядом с файлом
                    if (positionData.SpillwayPositions.Count > 0)
                    {
                        //TODO: Учесть возможные ошибки из-за отсутствия прав
                        string filename = null;
                        int    n        = 0;
                        do
                        {
                            filename = Path.Combine(Path.GetDirectoryName(adoc.Name),
                                                    Path.GetFileNameWithoutExtension(adoc.Name) /*"SpillwayPositions"*/ + "_" + n + ".xml");
                            n++;
                        } while (File.Exists(filename));


                        XmlSerializer xmlSerializer = new XmlSerializer(typeof(PositionData));
                        using (StreamWriter sw = new StreamWriter(filename))
                        {
                            xmlSerializer.Serialize(sw, positionData);
                        }
                        //Cообщение о том, что все выполнено
                        ed.WriteMessage("\nПоложение водосбросов сохранено в файле " + filename);
                    }
                }
            }
            catch (System.Exception ex)
            {
                //Utils.ErrorToCommandLine(ed, "Ошибка при извлечении расположений водосбросов", ex);
                CommonException(ex, "Ошибка при извлечении расположений водосбросов");
            }
            finally
            {
                foreach (Polyline3d p3d in highlighted)
                {
                    p3d.Unhighlight();
                }
            }
        }
        private static Entity DrawPart(Segment[] segs, Point[] points, Point[] densifiedPoints, bool closePart, bool hasZ, double defaultElevation)
        {
            double num = 0.0;

            if (segs != null)
            {
                if (segs.Length == 1)
                {
                    CircularArc        circularArc = segs[0] as CircularArc;
                    EllipticArc        ellipticArc = segs[0] as EllipticArc;
                    BezierCurve        bezierCurve = segs[0] as BezierCurve;
                    ArcGIS10Types.Line line        = segs[0] as ArcGIS10Types.Line;
                    if (circularArc != null)
                    {
                        if (((PointN)circularArc.FromPoint).X == ((PointN)circularArc.ToPoint).X && ((PointN)circularArc.FromPoint).Y == ((PointN)circularArc.ToPoint).Y)
                        {
                            return(GIS2CAD.DrawCircle(circularArc, defaultElevation));
                        }
                        return(GIS2CAD.DrawCircularArc(circularArc, defaultElevation, densifiedPoints));
                    }
                    else if (ellipticArc != null)
                    {
                        if (!ellipticArc.IsCounterClockwise)
                        {
                            return(AGSEllipticalArc.ToCadSpline(ellipticArc, defaultElevation));
                        }
                        return(AGSEllipticalArc.ToCadEllipse(ellipticArc, defaultElevation));
                    }
                    else
                    {
                        if (line != null)
                        {
                            return(GIS2CAD.DrawPolyline(densifiedPoints, false));
                        }
                        if (bezierCurve != null)
                        {
                            return(GIS2CAD.DrawPolyline(densifiedPoints, closePart));
                        }
                    }
                }
                else if (segs.Length > 1)
                {
                    PointN pointN = segs[0].FromPoint as PointN;
                    num = pointN.Z;
                    if (num == 0.0)
                    {
                        num = defaultElevation;
                    }
                    if (GIS2CAD.CanBeDrawnAsPolyline(segs))
                    {
                        var polyline = new Autodesk.AutoCAD.DatabaseServices.Polyline();
                        polyline.ColorIndex = (256);
                        int    num2    = 0;
                        PointN pointN2 = (PointN)segs[0].ToPoint;
                        for (int i = 0; i < segs.Length; i++)
                        {
                            Segment     segment      = segs[i];
                            CircularArc circularArc2 = segment as CircularArc;
                            var         line2        = segment as ArcGIS10Types.Line;
                            if (line2 != null)
                            {
                                PointN pointN3 = (PointN)line2.FromPoint;
                                polyline.AddVertexAt(num2++, new Point2d(pointN3.X, pointN3.Y), 0.0, -1.0, -1.0);
                                pointN2 = (PointN)line2.ToPoint;
                            }
                            else if (circularArc2 != null)
                            {
                                PointN pointN4 = (PointN)circularArc2.CenterPoint;
                                PointN pointN5 = (PointN)circularArc2.FromPoint;
                                PointN pointN6 = (PointN)circularArc2.ToPoint;
                                new Point2d(pointN5.X - pointN4.X, pointN5.Y - pointN4.Y);
                                new Point2d(pointN6.X - pointN4.X, pointN6.Y - pointN4.Y);
                                Point2d point2d     = new Point2d(pointN5.X, pointN5.Y);
                                Point2d centerPoint = new Point2d(pointN4.X, pointN4.Y);
                                Point2d point2d2    = new Point2d(pointN6.X, pointN6.Y);
                                double  num3        = Math.Abs(centerPoint.GetDistanceTo(point2d));
                                double  num4        = Math.Abs(point2d.GetDistanceTo(point2d2));
                                double  num5        = num3;
                                double  num6        = num3;
                                double  d           = (num5 * num5 + num6 * num6 - num4 * num4) / (2.0 * num5 * num6);
                                double  num7        = Math.Acos(d);
                                num7 = GIS2CAD.CalcThetaFromVectors(point2d, point2d2, centerPoint, circularArc2.IsCounterClockwise);
                                double num8 = Math.Tan(num7 / 4.0);
                                if (!circularArc2.IsCounterClockwise)
                                {
                                    num8 *= -1.0;
                                }
                                polyline.AddVertexAt(num2++, point2d, num8, -1.0, -1.0);
                                pointN2 = pointN6;
                            }
                        }
                        polyline.AddVertexAt(num2, new Point2d(pointN2.X, pointN2.Y), 0.0, -1.0, -1.0);
                        if (closePart)
                        {
                            polyline.Closed = (true);
                        }
                        return(polyline);
                    }
                    return(GIS2CAD.Draw3dPline(densifiedPoints, closePart));
                }
            }
            else if (points != null)
            {
                if (points.Length == 2)
                {
                    var line3 = new Autodesk.AutoCAD.DatabaseServices.Line();
                    line3.ColorIndex = (256);
                    GIS2CAD.AdjustZ(ref points, defaultElevation);
                    Point3d startPoint = GIS2CAD.ToCadPoint3d((PointN)points[0]);
                    Point3d endPoint   = GIS2CAD.ToCadPoint3d((PointN)points[1]);
                    line3.StartPoint = (startPoint);
                    line3.EndPoint   = (endPoint);
                    return(line3);
                }
                if (points.Length > 0)
                {
                    if (!GIS2CAD.IsPlanar(points))
                    {
                        try
                        {
                            Document document           = AfaDocData.ActiveDocData.Document;
                            var      database           = document.Database;
                            var      transactionManager = document.TransactionManager;
                            using (document.LockDocument())
                            {
                                using (Transaction transaction = transactionManager.StartTransaction())
                                {
                                    BlockTable       blockTable       = (BlockTable)transaction.GetObject(database.BlockTableId, 0);
                                    BlockTableRecord blockTableRecord = (BlockTableRecord)transaction.GetObject(blockTable[(BlockTableRecord.ModelSpace)], (OpenMode)1);
                                    Polyline3d       polyline3d       = new Polyline3d();
                                    polyline3d.ColorIndex = (256);
                                    blockTableRecord.AppendEntity(polyline3d);
                                    transaction.AddNewlyCreatedDBObject(polyline3d, true);
                                    Point[] array = points;
                                    for (int j = 0; j < array.Length; j++)
                                    {
                                        PointN           srcPt            = (PointN)array[j];
                                        PolylineVertex3d polylineVertex3d = new PolylineVertex3d(GIS2CAD.ToCadPoint3d(srcPt));
                                        polyline3d.AppendVertex(polylineVertex3d);
                                        transaction.AddNewlyCreatedDBObject(polylineVertex3d, true);
                                    }
                                    if (closePart)
                                    {
                                        polyline3d.Closed = (true);
                                    }
                                    document.TransactionManager.QueueForGraphicsFlush();
                                    document.TransactionManager.FlushGraphics();
                                    document.Editor.UpdateScreen();
                                    transaction.Commit();
                                    return(polyline3d);
                                }
                            }
                        }
                        catch (System.Exception ex)
                        {
                            string arg_526_0 = ex.Message;
                        }
                    }
                    var polyline2 = new Autodesk.AutoCAD.DatabaseServices.Polyline();
                    polyline2.ColorIndex = (256);
                    polyline2.Elevation  = (num);
                    num = ((PointN)points[0]).Z;
                    if (num == 0.0)
                    {
                        num = defaultElevation;
                    }
                    int     num9   = 0;
                    Point[] array2 = points;
                    for (int k = 0; k < array2.Length; k++)
                    {
                        PointN pointN7 = (PointN)array2[k];
                        polyline2.AddVertexAt(num9++, new Point2d(pointN7.X, pointN7.Y), 0.0, -1.0, -1.0);
                    }
                    if (closePart)
                    {
                        polyline2.Closed = (true);
                    }
                    return(polyline2);
                }
            }
            return(null);
        }
Beispiel #16
0
        public static void UpdateSurface(ObjectId objectId, dynamic xb)
        {
            Editor   ed      = acApp.DocumentManager.MdiActiveDocument.Editor;
            Document acDoc   = acApp.DocumentManager.MdiActiveDocument;
            Database acCurDb = acDoc.Database;

            Point3d minPoint = new Point3d(Convert.ToDouble(xb.x1), Convert.ToDouble(xb.y1), Convert.ToDouble(xb.z1));
            Point3d maxPoint = new Point3d(Convert.ToDouble(xb.x2), Convert.ToDouble(xb.y2), Convert.ToDouble(xb.z2));

            using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
            {
                // Open the Block table record for read
                BlockTable acBlkTbl;
                acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId,
                                             OpenMode.ForRead) as BlockTable;

                // Open the Block table record Model space for write
                BlockTableRecord acBlkTblRec;
                acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace],
                                                OpenMode.ForWrite) as BlockTableRecord;

                Point3d  pStart = minPoint;
                Point3d  pEnd   = new Point3d(maxPoint.X, maxPoint.Y, minPoint.Z);
                Vector3d vec    = new Vector3d(0, 0, maxPoint.Z - minPoint.Z);

                if (minPoint.Z == maxPoint.Z)
                {
                    pStart = minPoint;
                    pEnd   = new Point3d(maxPoint.X, minPoint.Y, maxPoint.Z);
                    vec    = new Vector3d(0, maxPoint.Y - minPoint.Y, 0);
                }

                // Create polyline
                Polyline3d poly = new Polyline3d();
                acBlkTblRec.AppendEntity(poly);
                acTrans.AddNewlyCreatedDBObject(poly, true);
                // Add vertex
                foreach (Point3d pnt in new List <Point3d>()
                {
                    pStart, pEnd
                })
                {
                    PolylineVertex3d vex3d = new PolylineVertex3d(pnt);
                    poly.AppendVertex(vex3d);
                    acTrans.AddNewlyCreatedDBObject(vex3d, true);
                }
                poly.Closed = false;
#if BRX_APP
                ExtrudedSurface extrSurf = (Teigha.DatabaseServices.ExtrudedSurface)acTrans.GetObject(objectId, OpenMode.ForWrite);
#elif ARX_APP
                ExtrudedSurface extrSurf = (Autodesk.AutoCAD.DatabaseServices.ExtrudedSurface)acTrans.GetObject(objectId, OpenMode.ForWrite);
#endif
                extrSurf.SetDatabaseDefaults();
                SweepOptions sweepOpts = new SweepOptions();
                extrSurf.CreateExtrudedSurface(poly, vec, sweepOpts);
                extrSurf.UIsoLineDensity = 0;
                extrSurf.VIsoLineDensity = 0;
                extrSurf.Draw();
                poly.Erase();
                acTrans.Commit();
                ed.UpdateScreen();
            }
        }
Beispiel #17
0
        public static void Lay()
        {
            bool promptGradient = false;
            int  gradient       = 0;

            Document acDoc   = Application.DocumentManager.MdiActiveDocument;
            Database acCurDb = acDoc.Database;

            PromptKeywordOptions pKeyOpts = new PromptKeywordOptions("");

            pKeyOpts.Message = "\nPlease enter mode";
            pKeyOpts.Keywords.Add("Gradient");
            pKeyOpts.Keywords.Add("Storm");
            pKeyOpts.Keywords.Add("Foul");
            pKeyOpts.Keywords.Default = "Storm";
            pKeyOpts.AllowNone        = true;
            PromptResult pKeyRes = acDoc.Editor.GetKeywords(pKeyOpts);

            switch (pKeyRes.StringResult)
            {
            case "Gradient":
                promptGradient = true;
                break;

            case "Storm":
                gradient = 100;
                break;

            case "Foul":
                gradient = 80;
                break;
            }

            PromptStringOptions pStrOpts;
            PromptResult        pStrRes;
            bool run = true;

            while (run)
            {
                if (promptGradient)
                {
                    //Prompt for the gradient
                    pStrOpts = new PromptStringOptions("\nEnter gradient: ");
                    pStrRes  = acDoc.Editor.GetString(pStrOpts);
                    gradient = Int32.Parse(pStrRes.StringResult);
                }

                PromptPointResult  pPtRes;
                PromptPointOptions pPtOpts = new PromptPointOptions("");

                // Prompt for the start point
                pPtOpts.Message = "\nEnter the start point of the line: ";
                pPtRes          = acDoc.Editor.GetPoint(pPtOpts);
                if (pPtRes.Status == PromptStatus.Cancel)
                {
                    run = false;
                    break;
                }
                Point3d ptStart = pPtRes.Value;

                //Prompt for the starting IL
                pStrOpts              = new PromptStringOptions("\nEnter starting IL: ");
                pStrOpts.AllowSpaces  = true;
                pStrOpts.DefaultValue = ptStart.Z.ToString();
                pStrRes = acDoc.Editor.GetString(pStrOpts);
                if (pStrRes.Status == PromptStatus.Cancel)
                {
                    run = false;
                    break;
                }
                double invert = double.Parse(pStrRes.StringResult);

                // Prompt for the end point
                pPtOpts.Message = "\nEnter the end point of the line: ";
                pPtRes          = acDoc.Editor.GetPoint(pPtOpts);
                if (pPtRes.Status == PromptStatus.Cancel)
                {
                    run = false;
                    break;
                }
                Point3d ptEnd = pPtRes.Value;

                //Adjust start coordinate IL
                ptStart = new Point3d(ptStart.X, ptStart.Y, invert); //Set to plane for accurate distance measure

                //Adjust end coordinate to gradient
                Point3d temp     = new Point3d(ptEnd.X, ptEnd.Y, ptStart.Z); //Set to plane for accurate distance measure
                double  distance = Math.Abs(temp.DistanceTo(ptStart));
                double  fall     = distance / gradient;
                fall  = Math.Round(fall, 3);
                ptEnd = new Point3d(temp.X, temp.Y, temp.Z - fall);

                using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
                {
                    // Open the Block table record for read
                    BlockTable acBlkTbl;
                    acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;

                    // Open the Block table record M odel space for write
                    BlockTableRecord acBlkTblRec;
                    acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

                    // Create a 3D polyline
                    using (Polyline3d acPoly3d = new Polyline3d())
                    {
                        // Add the new object to the block table record and the transaction
                        acBlkTblRec.AppendEntity(acPoly3d);
                        acTrans.AddNewlyCreatedDBObject(acPoly3d, true);

                        // Before adding vertexes, the polyline must be in the drawing
                        Point3dCollection acPts3dPoly = new Point3dCollection();
                        acPts3dPoly.Add(ptStart);
                        acPts3dPoly.Add(ptEnd);

                        foreach (Point3d acPt3d in acPts3dPoly)
                        {
                            using (PolylineVertex3d acPolVer3d = new PolylineVertex3d(acPt3d))
                            {
                                acPoly3d.AppendVertex(acPolVer3d);
                                acTrans.AddNewlyCreatedDBObject(acPolVer3d, true);
                            }
                        }

                        Annotate(acPoly3d);
                    }

                    // Save the new object to the database
                    acTrans.Commit();
                }
            }
        }
Beispiel #18
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();
            }
        }
Beispiel #19
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();
            }
        }
Beispiel #20
0
        public static void Polyline_2D_3D()
        {
            // 获取当前文档和数据库,启动事务
            var acDoc   = Autodesk.AutoCAD.ApplicationServices.Core.Application.DocumentManager.MdiActiveDocument;
            var acCurDb = acDoc.Database;

            using (var acTrans = acCurDb.TransactionManager.StartTransaction())
            {
                // Open the Block table record for read
                BlockTable acBlkTbl;
                acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId,
                                             OpenMode.ForRead) as BlockTable;

                // 以写模式打开块表记录模型空间
                BlockTableRecord acBlkTblRec;
                acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace],
                                                OpenMode.ForWrite) as BlockTableRecord;

                // 用2条线段(3个点)创建一条多段线
                var acPoly = new Polyline();
                acPoly.AddVertexAt(0, new Point2d(1, 1), 0, 0, 0);
                acPoly.AddVertexAt(1, new Point2d(1, 2), 0, 0, 0);
                acPoly.AddVertexAt(2, new Point2d(2, 2), 0, 0, 0);
                acPoly.ColorIndex = 1;

                // 将新对象添加到块表记录和事务
                acBlkTblRec.AppendEntity(acPoly);
                acTrans.AddNewlyCreatedDBObject(acPoly, true);

                // 用2条线段(3个点)创建一条3D多段线
                var acPoly3d = new Polyline3d();
                acPoly3d.ColorIndex = 5;

                // 将新对象添加到块表记录和事务
                acBlkTblRec.AppendEntity(acPoly3d);
                acTrans.AddNewlyCreatedDBObject(acPoly3d, true);

                // Before adding vertexes, the polyline must be in the drawing
                // 先创建多段线对象,然后才能给它添加顶点
                var acPts3dPoly = new Point3dCollection();
                acPts3dPoly.Add(new Point3d(1, 1, 0));
                acPts3dPoly.Add(new Point3d(2, 1, 0));
                acPts3dPoly.Add(new Point3d(2, 2, 0));

                foreach (Point3d acPt3d in acPts3dPoly)
                {
                    var acPolVer3d = new PolylineVertex3d(acPt3d);
                    acPoly3d.AppendVertex(acPolVer3d);
                    acTrans.AddNewlyCreatedDBObject(acPolVer3d, true);
                }

                // 获取多段线的顶点坐标
                var acPts2d = new Point2dCollection();
                for (var nCnt = 0; nCnt < acPoly.NumberOfVertices; nCnt++)
                {
                    acPts2d.Add(acPoly.GetPoint2dAt(nCnt));
                }

                // 获取3D多段线的顶点坐标
                var acPts3d = new Point3dCollection();
                foreach (ObjectId acObjIdVert in acPoly3d)
                {
                    PolylineVertex3d acPolVer3d;
                    acPolVer3d = acTrans.GetObject(acObjIdVert,
                                                   OpenMode.ForRead) as PolylineVertex3d;

                    acPts3d.Add(acPolVer3d.Position);
                }

                // 显示坐标
                Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog("2D polyline (red): \n" +
                                                                                      acPts2d[0] + "\n" +
                                                                                      acPts2d[1] + "\n" +
                                                                                      acPts2d[2]);

                Autodesk.AutoCAD.ApplicationServices.Core.Application.ShowAlertDialog("3D polyline (blue): \n" +
                                                                                      acPts3d[0] + "\n" +
                                                                                      acPts3d[1] + "\n" +
                                                                                      acPts3d[2]);

                //提交事务
                acTrans.Commit();
            }
        }
Beispiel #21
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();
            }
        }
        public void LandXmlHandling()
        {
            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;
            settings.IgnoreComments   = true;
            int pntListCount = 0;
            int profileCount = 0;
            int pviCount     = 0;

            string[] fileNames = OpenFiles();
            foreach (string fileName in fileNames)
            {
                XmlReader             reader = XmlReader.Create(fileName, settings);
                List <string>         alignmentCollection = new List <string>();
                List <List <double> > pntListCollection   = new List <List <double> >();
                List <double>         pviList             = new List <double>();
                try
                {
                    while (reader.Read())
                    {
                        if (reader.IsStartElement() == true)
                        {
                            switch (reader.Name)
                            {
                            case "PntList2D":
                                pntListCount++;
                                reader.Read();
                                Console.WriteLine("{0}.PntList", pntListCount);
                                Console.WriteLine(reader.Value);
                                Console.ReadLine();
                                List <double> pntList    = new List <double>();
                                string[]      pntListStr = reader.Value.Split(' ');
                                for (int i = 0; i < pntListStr.Length; i += 2)
                                {
                                    pntList.Add(Convert.ToDouble(pntListStr[i + 1]));
                                    pntList.Add(Convert.ToDouble(pntListStr[i]));
                                    Console.WriteLine("{0}", pntList[i]);
                                }
                                pntListCollection.Add(pntList);
                                break;


                            case "ProfAlign":
                                if (pntListCollection.Count == 0)
                                {
                                    break;
                                }
                                profileCount++;
                                Console.WriteLine("{0}.Profile", profileCount);
                                Console.WriteLine(reader.Value);
                                Console.ReadLine();
                                alignmentCollection.Add(reader.GetAttribute("name"));
                                break;

                            case "PVI":
                                if (pntListCollection.Count == 0)
                                {
                                    break;
                                }

                                pviCount++;
                                reader.Read();
                                Console.WriteLine(reader.Value);
                                Console.ReadLine();
                                string[] pviListStr = reader.Value.Split(' ');
                                pviList.Add(Convert.ToDouble(pviListStr[1]));
                                break;

                            default:
                                break;
                            }
                        }
                    }
                }
                catch (Exception)
                {
                    throw;
                }
                //----------------------------------------------------------//
                //---------------MERGING PVI LIST TO THE POINT LIST---------//
                //----------------------------------------------------------//
                int k = 0;
                while (k < pviList.Count)
                {
                    foreach (List <double> item in pntListCollection)
                    {
                        int i = 2;
                        do
                        {
                            item.Insert(i, pviList[k]);
                            i += 3;
                            k++;
                        } while (i <= item.Count);
                    }
                }

                //----------------------------------------------------------//
                //---------------CREEATING LAYERS----------------------------//
                //----------------------------------------------------------//
                foreach (string alignment in alignmentCollection)
                {
                    CreateLayer(alignment);
                }


                //---------------CREATING 3DPOLYLINE-----------//
                using (Transaction ts = Application.DocumentManager.MdiActiveDocument.Database.TransactionManager.StartTransaction())
                {
                    BlockTable acBlkTbl;
                    acBlkTbl = ts.GetObject(Db.BlockTableId, OpenMode.ForRead) as BlockTable;
                    BlockTableRecord acBlkTblRec;
                    acBlkTblRec = ts.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
                    int sayac = 0;
                    foreach (List <double> item in pntListCollection)
                    {
                        Polyline3d poly = new Polyline3d();
                        acBlkTblRec.AppendEntity(poly);

                        for (int i = 0; i < item.Count; i += 3)
                        {
                            Point3d          pnt    = new Point3d(item[i], item[i + 1], item[i + 2]);
                            PolylineVertex3d vertex = new PolylineVertex3d(pnt);
                            poly.AppendVertex(vertex);
                            ts.AddNewlyCreatedDBObject(vertex, true);
                        }
                        poly.Layer = alignmentCollection[sayac];
                        sayac++;
                        ts.AddNewlyCreatedDBObject(poly, true);
                    }

                    ts.Commit();
                }
            }
        }
Beispiel #23
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();
            }
        }