Exemplo n.º 1
0
        public static Hatch CreateHatch(ObjectId ID, string Type, Color C)
        {
            var Return = new Hatch();

            using (Transaction T = Doc.TransactionManager.StartTransaction())
            {
                var BT  = T.GetObject(DB.BlockTableId, OpenMode.ForRead) as BlockTable;
                var BTR = T.GetObject(BT[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;

                Return.SetDatabaseDefaults();

                var OC = new ObjectIdCollection();
                OC.Add(ID);

                Return.SetDatabaseDefaults();
                Return.SetHatchPattern(HatchPatternType.PreDefined, Type);
                Return.Associative = true;
                Return.AppendLoop(HatchLoopTypes.Default, OC);
                Return.EvaluateHatch(true);
                Return.Color = C;

                BTR.AppendEntity(Return);
                T.AddNewlyCreatedDBObject(Return, true);
                T.Commit();
            }

            return(Return);
        }
Exemplo n.º 2
0
        /// <summary>
        /// 绘制填充
        /// </summary>
        /// <param name="db">CAD数据库</param>
        /// <param name="pl">外轮廓多线</param>
        /// <param name="href">填充参考样式</param>
        /// <param name="scale">填充比例,默认=1</param>
        /// <returns>返回填充对象</returns>
        public static Hatch PlotH(Database db, Polyline pl, Hatch href, double scale = 1)
        {
            Hatch hatch1 = new Hatch();

            using (Transaction tr = db.TransactionManager.StartTransaction())
            {
                BlockTable       blockTbl   = tr.GetObject(db.BlockTableId, OpenMode.ForRead) as BlockTable;
                BlockTableRecord modelSpace = tr.GetObject(blockTbl[BlockTableRecord.ModelSpace],
                                                           OpenMode.ForWrite) as BlockTableRecord;

                hatch1.SetHatchPattern(href.PatternType, href.PatternName);
                modelSpace.AppendEntity(hatch1);
                tr.AddNewlyCreatedDBObject(hatch1, true);
                hatch1.PatternScale = href.PatternScale;
                hatch1.Layer        = "填充";
                hatch1.Associative  = true;
                hatch1.AppendLoop(HatchLoopTypes.Default, new ObjectIdCollection {
                    pl.ObjectId
                });
                hatch1.EvaluateHatch(true);


                hatch1.PatternScale = href.PatternScale;
                hatch1.SetHatchPattern(hatch1.PatternType, hatch1.PatternName);


                tr.Commit();
            }
            return(hatch1);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Overrides <see cref="CADability.Actions.ConstructAction.OnSetAction ()"/>
        /// </summary>
        public override void OnSetAction()
        {
            // die Titel Ids müssen sich unterscheiden, auch wg. der Hilfe
            string resSubId = "";

            switch (mode)
            {
            case HatchMode.simple:
                resSubId = "InnerPoint";
                break;

            case HatchMode.hull:
                resSubId = "Hull";
                break;

            case HatchMode.excludeHoles:
                resSubId = "ExcludeHoles";
                break;
            }
            base.TitleId = "Constr.Hatch." + resSubId;
            ConstructAction.GeoPointInput gpi = new GeoPointInput("Constr.Hatch.InnerPoint.Point");
            gpi.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(OnPoint);
            gpi.MouseClickEvent  += new MouseClickDelegate(OnMouseClick);
            base.UseFilter        = true;
            base.ShowAttributes   = true;
            base.ShowActiveObject = false;
            base.ActiveObject     = Hatch.Construct();
            base.SetInput(gpi);
            base.OnSetAction();
        }
Exemplo n.º 4
0
        private void AddHatchingArrow(IList <Entity> entity)
        {
            using (var transaction = CADProxy.Database.TransactionManager.StartTransaction())
            {
                var polyline = new Polyline();
                polyline.AddVertexAt(0, new Point2d(0, 0), 0, 0, 0);
                polyline.AddVertexAt(0, new Point2d(1.5, 1.5), 0, 0, 0);
                polyline.AddVertexAt(0, new Point2d(0, 1.5), 0, 0, 0);
                polyline.Closed = true;

                var blockTableRecord = transaction.GetObject(CADProxy.Database.CurrentSpaceId, OpenMode.ForWrite) as BlockTableRecord;
                var objIds           = new ObjectIdCollection()
                {
                    blockTableRecord.AppendEntity(polyline)
                };
                transaction.AddNewlyCreatedDBObject(polyline, true);

                var hatch = new Hatch();
                hatch.SetDatabaseDefaults();
                hatch.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
                hatch.Associative = false;
                hatch.AppendLoop((int)HatchLoopTypes.Default, objIds);
                hatch.EvaluateHatch(true);

                polyline.Erase();

                entity.Add(hatch);
            }
        }
Exemplo n.º 5
0
        public static void OnPatternChange(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Hatch       v = (Hatch)e.NewValue;
            HatchCanvas h = (HatchCanvas)d;

            h.Update(v, 1);
        }
Exemplo n.º 6
0
 Hatch CloneHatch(Hatch oldEnt)
 {
     try
     {
         Hatch newEnt = new Hatch();
         for (int hi = 0; hi < oldEnt.NumberOfLoops; hi++)
         {
             HatchLoop hl = oldEnt.GetLoopAt(hi);
             newEnt.AppendLoop(hl);
         }
         newEnt.Associative     = oldEnt.Associative;
         newEnt.BackgroundColor = oldEnt.BackgroundColor;
         newEnt.Elevation       = oldEnt.Elevation;
         //newEnt.GradientAngle = oldEnt.GradientAngle;
         //newEnt.GradientOneColorMode = oldEnt.GradientOneColorMode;
         //newEnt.GradientShift = oldEnt.GradientShift;
         newEnt.HatchObjectType = oldEnt.HatchObjectType;
         newEnt.HatchStyle      = oldEnt.HatchStyle;
         newEnt.Normal          = oldEnt.Normal;
         newEnt.Origin          = oldEnt.Origin;
         newEnt.PatternAngle    = oldEnt.PatternAngle;
         newEnt.PatternDouble   = oldEnt.PatternDouble;
         newEnt.PatternScale    = oldEnt.PatternScale;
         newEnt.PatternSpace    = oldEnt.PatternSpace;
         //newEnt.ShadeTintValue = oldEnt.ShadeTintValue;
         return(newEnt);
     }
     catch (Exception ex)
     {
         Logger.log("CloneHatch", ex.Message);
     }
     return(null);
 }
Exemplo n.º 7
0
            public override bool WorldDraw(AcGi.Drawable drawable, AcGi.WorldDraw wd)
            {
                var line = drawable as Line;

                if (line != null)
                {
                    //delta,这条直线所代表的三维向量
                    var vec = line.Delta.RotateBy(Math.PI / 2, Vector3d.ZAxis).GetNormal();
                    var pts = new Point3dCollection()
                    {
                        line.StartPoint + vec, line.EndPoint + vec,
                        line.EndPoint - vec, line.StartPoint - vec,
                    };
                    wd.Geometry.Polygon(pts);

                    var hatch = new Hatch();
                    var pts2d = new Point2dCollection();
                    var bulge = new DoubleCollection();

                    foreach (Point3d pt3d in pts)
                    {
                        pts2d.Add(new Point2d(pt3d.X, pt3d.Y));
                        bulge.Add(0);
                    }

                    hatch.AppendLoop(HatchLoopTypes.Default, pts2d, bulge);
                    hatch.SetHatchPattern(HatchPatternType.PreDefined, "ANGLE");

                    hatch.WorldDraw(wd);
                }

                return(base.WorldDraw(drawable, wd));
            }
Exemplo n.º 8
0
        private void Entities_AddItem(EntityCollection sender, EntityCollectionEventArgs e)
        {
            if (e.Item.Type == EntityType.Leader)
            {
                Leader leader = (Leader)e.Item;
                if (leader.Annotation != null)
                {
                    entities.Add(leader.Annotation);
                }
            }
            else if (e.Item.Type == EntityType.Hatch)
            {
                Hatch hatch = (Hatch)e.Item;
                foreach (HatchBoundaryPath path in hatch.BoundaryPaths)
                {
                    foreach (EntityObject entity in path.Entities)
                    {
                        entities.Add(entity);
                    }
                }
            }

            OnEntityAddedEvent(e.Item);
            e.Item.Owner = this;
        }
        public static Hatch FindHatchToLeft(BlockTableRecord mSpace, Transaction trans, MText text)
        {
            LineSegment3d current  = new LineSegment3d(text.Bounds.Value.MinPoint, text.Bounds.Value.MaxPoint);
            Line3d        lineUp   = new Line3d(current.MidPoint, Vector3d.XAxis);
            double        distance = double.MaxValue;
            Hatch         ret      = null;

            foreach (ObjectId entId in mSpace)
            {
                Hatch thisHatch = trans.GetObject(entId, OpenMode.ForRead) as Hatch;
                if (thisHatch == null)
                {
                    continue;
                }

                LineSegment3d thisHatchLine      = new LineSegment3d(thisHatch.Bounds.Value.MinPoint, thisHatch.Bounds.Value.MaxPoint);
                Point3d[]     intersectionPoints = lineUp.IntersectWith(thisHatchLine);
                if (intersectionPoints == null || intersectionPoints.Length != 1)
                {
                    continue;
                }
                double thisDistance = current.MidPoint.DistanceTo(intersectionPoints[0]);
                if (thisDistance < distance && !thisHatch.ObjectId.Equals(text.ObjectId) && current.MidPoint.X > intersectionPoints[0].X)
                {
                    distance = thisDistance;
                    ret      = thisHatch;
                }
            }
            return(ret);
        }
Exemplo n.º 10
0
 public string Print()
 {
     return("Name: " + Pokemon + ", National Pokedex Number: " + Per.ToString() + ", Regional Pokedex Number: " + Nat + ", Base HP: " + HP.ToString() + ", Base Attack: " + Atk.ToString() + ", Base Defense: " + Def.ToString() + ", Base Sp.Attack: "
            + SpA.ToString() + ", Base Sp.Def: " + SpD.ToString() + ", Base Speed: " + Spe.ToString() + ", Total Base Stats: " + Total.ToString() + ", Type I: " + Type_I + ", Type II: " + Type_II + ", Tier: " + Tier + ", Ability I: "
            + Ability_I + ", Ability II: " + Ability_II + ", Hidden Ability: " + Hidden_Ability + ", Mass: " + Mass + ", Low Kick/Grass Knot damage: " + LK_GK.ToString() + ", EV Worth: " + EV_Worth + ", Exp Value: " + EXPV.ToString()
            + ", Pokedex Color: " + Color + ", Hatch: " + Hatch.ToString() + ", Gender" + Gender + ", Egg Group I: " + Egg_Group_I + ", Egg Group II: " + Egg_Group_II + ", Catch Rate: " + Catch.ToString() + ", Leveling Rate: " + LevelingRate());
 }
Exemplo n.º 11
0
        /// <summary>
        /// 创建填充。
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="loops"></param>
        /// <param name="type"></param>
        /// <param name="scale"></param>
        /// <param name="otherSetting"></param>
        /// <param name="db"></param>
        /// <param name="space"></param>
        /// <returns></returns>
        public static ObjectId CreateHatch(string pattern, Polyline[] loops,
                                           HatchPatternType type       = HatchPatternType.PreDefined, double scale = 1,
                                           Action <Hatch> otherSetting = null, Database db = null, string space = null)
        {
            var hatch = new Hatch();
            var id    = hatch.ToSpace(db, space);

            using (var trans = id.Database.TransactionManager.StartTransaction())
            {
                hatch = trans.GetObject(id, OpenMode.ForWrite) as Hatch;

                hatch.PatternScale = scale;
                hatch.SetHatchPattern(type, pattern);

                foreach (var loop in loops)
                {
                    var hatchLoop = new HatchLoop(HatchLoopTypes.Polyline);
                    for (var i = 0; i < loop.NumberOfVertices; i++)
                    {
                        hatchLoop.Polyline.Add(
                            new BulgeVertex(loop.GetPoint2dAt(i), loop.GetBulgeAt(i)));
                    }
                    hatch.AppendLoop(hatchLoop);
                }

                otherSetting?.Invoke(hatch);
                trans.Commit();
            }

            return(id);
        }
Exemplo n.º 12
0
 // 由边界对象集合数组、图案填充类型、填充图案名称、填充角度和填充比例创建图案填充的函数.
 // partType:0为预定义图案;1为用户定义图案;2为自定义图案.
 public static ObjectId AddHatch(ObjectIdCollection[] objIds, HatchPatternType patType, string patName, double patternAngle, double patternScale)
 {
     try
     {
         Hatch ent = new Hatch();
         ent.HatchObjectType = HatchObjectType.HatchObject;
         Database db = HostApplicationServices.WorkingDatabase;
         using (Transaction trans = db.TransactionManager.StartTransaction())
         {
             BlockTable       bt    = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
             BlockTableRecord btr   = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
             ObjectId         entId = btr.AppendEntity(ent);
             trans.AddNewlyCreatedDBObject(ent, true);
             ent.PatternAngle = patternAngle;
             ent.PatternScale = patternScale;
             ent.SetHatchPattern(patType, patName);
             ent.Associative = true;
             for (int i = 0; i < objIds.Length; i++)
             {
                 ent.InsertLoopAt(i, HatchLoopTypes.Default, objIds[i]);
             }
             trans.Commit();
             return(entId);
         }
     }
     catch
     {
         ObjectId nullId = ObjectId.Null;
         return(nullId);
     }
 }
Exemplo n.º 13
0
        /// <since>5.0</since>
        public bool SetFromHatch(Hatch hatch)
        {
            IntPtr pThis       = NonConstPointer();
            IntPtr pConstHatch = hatch.ConstPointer();

            return(UnsafeNativeMethods.CRhinoGumball_SetFromHatch(pThis, pConstHatch));
        }
Exemplo n.º 14
0
        public void AddHatch()
        {
            Document mdiActiveDocument = Application.DocumentManager.MdiActiveDocument;
            Database database          = mdiActiveDocument.Database;

            using (Transaction transaction = database.TransactionManager.StartTransaction())
            {
                BlockTable       blockTable       = (BlockTable)transaction.GetObject(database.BlockTableId, 0);
                BlockTableRecord blockTableRecord = (BlockTableRecord)transaction.GetObject(blockTable[BlockTableRecord.ModelSpace], 1);
                Circle           circle           = new Circle();
                circle.SetDatabaseDefaults();
                Circle  circle2 = circle;
                Point3d center;
                center..ctor(3.0, 3.0, 0.0);
                circle2.Center = center;
                circle.Radius  = 10000.0;
                blockTableRecord.AppendEntity(circle);
                transaction.AddNewlyCreatedDBObject(circle, true);
                ObjectIdCollection objectIdCollection = new ObjectIdCollection();
                objectIdCollection.Add(circle.ObjectId);
                Hatch hatch = new Hatch();
                blockTableRecord.AppendEntity(hatch);
                transaction.AddNewlyCreatedDBObject(hatch, true);
                hatch.SetDatabaseDefaults();
                hatch.SetHatchPattern(1, "ANSI31");
                hatch.Associative = true;
                hatch.AppendLoop(16, objectIdCollection);
                hatch.EvaluateHatch(true);
                transaction.Commit();
            }
        }
Exemplo n.º 15
0
        private void AddHatchingArrow(IList <Entity> entityList)
        {
            var hatch = new Hatch();

            using (var tr = CADProxy.Database.TransactionManager.StartTransaction())
            {
                var bd = new Polyline();
                bd.AddVertexAt(0, new Point2d(0, 0), 0, 0, 0);
                bd.AddVertexAt(0, new Point2d(-2.5, 3), 0, 0, 0);
                bd.AddVertexAt(0, new Point2d(2.5, 3), 0, 0, 0);
                bd.Closed = true;
                BlockTable       bt  = tr.GetObject(CADProxy.Database.BlockTableId, OpenMode.ForRead) as BlockTable;
                BlockTableRecord btr = tr.GetObject(CADProxy.Database.CurrentSpaceId, OpenMode.ForWrite) as BlockTableRecord;
                var bdId             = btr.AppendEntity(bd);
                tr.AddNewlyCreatedDBObject(bd, true);
                ObjectIdCollection ObjIds = new ObjectIdCollection
                {
                    bdId
                };

                hatch.SetDatabaseDefaults();
                hatch.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
                hatch.Associative = false;
                hatch.AppendLoop((int)HatchLoopTypes.Default, ObjIds);
                hatch.EvaluateHatch(true);
                bd.Erase();
            }
            entityList.Add(hatch);
        }
        /// <summary>
        /// 图案填充 无颜色
        /// </summary>
        /// <param name="db">图形数据库</param>
        /// <param name="patternName">图案名称</param>
        /// <param name="scale">填充比例</param>
        /// <param name="degree">旋转角度</param>
        /// <param name="entid">边界图形的ObjectId</param>
        /// <returns></returns>
        public static ObjectId HatchEnity(this Database db, string patternName, double scale, double degree, ObjectId entid)
        {
            ObjectId hatchId = ObjectId.Null;

            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                // 声明一个图案填充对象
                Hatch hatch = new Hatch();
                // 设置填充比例
                hatch.PatternScale = scale;
                // 设置填充类型和图案名称
                hatch.SetHatchPattern(HatchPatternType.PreDefined, "ANGLE");
                // 加入图形数据库
                BlockTable       bt  = (BlockTable)trans.GetObject(db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                hatchId = btr.AppendEntity(hatch);
                trans.AddNewlyCreatedDBObject(hatch, true);

                // 设置填充角度
                hatch.PatternAngle = degree;
                // 设置关联
                hatch.Associative = true;
                // 设置边界图形和填充方式

                ObjectIdCollection obIds = new ObjectIdCollection();
                obIds.Add(entid);
                hatch.AppendLoop(HatchLoopTypes.Outermost, obIds);
                // 计算填充并显示
                hatch.EvaluateHatch(true);
                // 提交事务
                trans.Commit();
            }
            return(hatchId);
        }
Exemplo n.º 17
0
    public string GetProjectHatches(int ProjectID)
    {
        Project   p  = new Project();
        DataTable dt = p.GetProjectHatches(ProjectID);

        ArrayList[] myAL = new ArrayList[dt.Rows.Count];

        for (int i = 0; i < myAL.Length; i++)
        {
            myAL[i] = new ArrayList();
        }

        Hatch h = new Hatch();

        for (int i = 0; i < myAL.Length; i++)
        {
            h = new Hatch();

            h.HatchID     = Convert.ToInt32(dt.Rows[i].ItemArray[0]);
            h.HatchStatus = dt.Rows[i].ItemArray[2].ToString();
            h.FtName      = dt.Rows[i].ItemArray[5].ToString();
            h.Comments    = dt.Rows[i].ItemArray[6].ToString();

            myAL[i].Add(h);
        }

        // create a json serializer object
        JavaScriptSerializer js = new JavaScriptSerializer();
        // serialize to string
        string jsonString = js.Serialize(myAL);

        return(jsonString);
    }
Exemplo n.º 18
0
        private static void FillContour(BlockSectionKP bs, Polyline plExtern, BlockTableRecord cs, Transaction t)
        {
            var h = new Hatch();

            h.SetDatabaseDefaults();
            h.Layer      = OptionsKPBS.Instance.LayerBSContourGNS;
            h.LineWeight = LineWeight.LineWeight015;
            h.Linetype   = SymbolUtilityServices.LinetypeContinuousName;
            h.Color      = GetFillColor(bs); // Color.FromRgb(250, 250, 250);
            //h.Transparency = new Transparency(80);
            h.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
            cs.AppendEntity(h);
            t.AddNewlyCreatedDBObject(h, true);
            h.Associative = true;
            h.HatchStyle  = HatchStyle.Normal;

            // добавление контура полилинии в гштриховку
            var ids = new ObjectIdCollection();

            ids.Add(plExtern.Id);
            h.AppendLoop(HatchLoopTypes.Default, ids);
            h.EvaluateHatch(true);

            var orders = cs.DrawOrderTableId.GetObject(OpenMode.ForWrite) as DrawOrderTable;

            orders.MoveToBottom(new ObjectIdCollection(new[] { h.Id }));
        }
Exemplo n.º 19
0
    public void DrawObject()
    {
        for (int i = 0; i < DistanceCalculate.hatches.Count; i++)
        {
            //curState.text = DistanceCalculate.hatches[i].state.ToString();
            if (DistanceCalculate.hatches[i].state == State.unDrawed)
            {
                //postext.text = DistanceCalculate.hatches[i].position.ToString();

                shift = arCamera.transform.position + DistanceCalculate.hatches[i].position;
                DistanceCalculate.hatches[i].model = Instantiate(prefab, shift, Quaternion.identity);
                tempHatch                    = DistanceCalculate.hatches[i].model.GetComponent <Hatch>();
                tempHatch.description        = DistanceCalculate.hatches[i].description;
                tempHatch.location.latitude  = DistanceCalculate.hatches[i].location.latitude;
                tempHatch.location.longitude = DistanceCalculate.hatches[i].location.longitude;
                spawn.text                   = "spawned";
                //m_SessionOrigin.MakeContentAppearAt(DistanceCalculate.hatches[i].model.transform, arCamera.transform.position, Quaternion.identity); //
                //m_SessionOrigin.MakeContentAppearAt(DistanceCalculate.hatches[i].model.transform, DistanceCalculate.hatches[i].position, Quaternion.identity);//

                DistanceCalculate.hatches[i].state = State.drawed;
            }

            if (DistanceCalculate.hatches[i].state == State.toErase)
            {
                Destroy(DistanceCalculate.hatches[i].model);
                DistanceCalculate.hatches[i].state = State.toDelete;
            }
        }
    }
Exemplo n.º 20
0
        // 由图案填充类型、填充图案名称、
        // 填充角度和填充比例创建图案填充的函数.
        // partType:0为预定义图案;1为用户定义图案;2为自定义图案.
        private ObjectId AddHatch(out Hatch hatchEnt, HatchPatternType patType,
                                  String patName, Double patternAngle, Double patternScale)
        {
            Hatch ent = new Hatch();

            ent.HatchObjectType = HatchObjectType.HatchObject;
            Database db = HostApplicationServices.WorkingDatabase;

            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                BlockTable bt = (BlockTable)trans.GetObject
                                    (db.BlockTableId, OpenMode.ForRead);
                BlockTableRecord btr = (BlockTableRecord)trans.GetObject
                                           (bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
                ObjectId entId = btr.AppendEntity(ent);
                trans.AddNewlyCreatedDBObject(ent, true);
                ent.SetDatabaseDefaults();
                ent.PatternAngle = patternAngle;
                ent.PatternScale = patternScale;
                ent.SetHatchPattern(patType, patName);
                hatchEnt = ent;
                trans.Commit();
                return(entId);
            }
        }
        /*Draw Hatch*/
        public static void DrawHatch(Hatch xHatch, Canvas mainCanvas)
        {
            System.Windows.Point       p0    = new System.Windows.Point();
            System.Windows.Shapes.Path wPath = new System.Windows.Shapes.Path();

            List <PathSegment> segments = new List <PathSegment>();
            PathSegment        segment;
            List <PathFigure>  figures = new List <PathFigure>();


            int i = 0;

            foreach (netDxf.Entities.HatchBoundaryPath xPath in xHatch.BoundaryPaths)
            {
                segments = new List <PathSegment>();

                Debug.WriteLine("xpath:" + xPath.PathType);
                int j = 0;
                foreach (netDxf.Entities.HatchBoundaryPath.Edge xEdge in xPath.Edges)
                {
                    Debug.WriteLine("xEdge:" + xEdge.Type);

                    if (xEdge.Type == netDxfPath.EdgeType.Line)
                    {
                        netDxfPath.Line wLine = (netDxfPath.Line)xEdge;
                        segment = new LineSegment(TypeConverter.Vertex2ToPoint(wLine.End, mainCanvas.Height), true);
                        segments.Add(segment);
                        if (j == 0)
                        {
                            p0 = TypeConverter.Vertex2ToPoint(wLine.Start, mainCanvas.Height);
                        }
                    }
                    j++;


                    /*if(xEdge.Type==netDxf.Entities.HatchBoundaryPath.EdgeType.Line) DrawLine((netDxf.Entities.Line)xEdge.ConvertTo(),mainCanvas);
                     * if(xEdge.Type==netDxf.Entities.HatchBoundaryPath.EdgeType.Ellipse) DrawEllipse((netDxf.Entities.Ellipse)xEdge.ConvertTo(),mainCanvas);
                     * if(xEdge.Type==netDxf.Entities.HatchBoundaryPath.EdgeType.Spline) DrawSpline((netDxf.Entities.Spline)xEdge.ConvertTo(),mainCanvas);
                     * if(xEdge.Type==netDxf.Entities.HatchBoundaryPath.EdgeType.Arc) DrawArc((netDxf.Entities.Arc)xEdge.ConvertTo(),mainCanvas);
                     * if(xEdge.Type==netDxf.Entities.HatchBoundaryPath.EdgeType.Polyline) DrawLwPolyline((netDxf.Entities.LwPolyline)xEdge.ConvertTo(),mainCanvas);
                     */
                }

                PathFigure pf = new PathFigure(p0, segments, true);
                pf.IsClosed = false;
                figures.Add(pf);

                i++;
            }

            Geometry g = new PathGeometry(figures, FillRule.EvenOdd, null);

            wPath.Data = g;
            wPath.Fill = TypeConverter.PatternToBrush(xHatch.Pattern, xHatch.getColor());


            TypeConverter.Entity2Shape(xHatch, wPath);
            wPath.StrokeThickness = 0;
            mainCanvas.Children.Add(wPath);
        }
Exemplo n.º 22
0
        /// <summary>
        /// Adds the predefined hatch.
        /// </summary>
        /// <param name="trans">The trans.</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="patternName">Name of the pattern.</param>
        /// <returns></returns>
        public static ObjectId AddPredefinedHatch(Transaction trans, Point2dCollection points, string layername, bool isClosed, string patternName)
        {
            //_logger.Debug("Start AddPredefinedHatch");
            ObjectId id = ObjectId.Null;

            Autodesk.AutoCAD.DatabaseServices.Database           db = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Database;
            Autodesk.AutoCAD.DatabaseServices.TransactionManager tm = db.TransactionManager;

            using (Hatch hatch = new Hatch())
            {
                hatch.SetDatabaseDefaults();
                hatch.Layer = layername;

                id = AddToDatabase(db, hatch, trans);

                hatch.UpgradeOpen();
                //hatch.HatchStyle = HatchStyle.Outer;
                hatch.Associative  = true;
                hatch.PatternScale = 100.0;
                hatch.SetHatchPattern(HatchPatternType.PreDefined, patternName);

                double buldge = 0.0;

                HatchLoop loop = new HatchLoop(HatchLoopTypes.Polyline);
                foreach (Point2d pt in points)
                {
                    BulgeVertex bv = new BulgeVertex(pt, buldge);
                    loop.Polyline.Add(bv);
                }
                hatch.AppendLoop(loop);
                hatch.EvaluateHatch(true);
            }
            //_logger.Debug("End AddPredefinedHatch");
            return(id);
        }
Exemplo n.º 23
0
        public static bool IsPointOnHatchByRay(this Hatch hatch, Point3d pt, Tolerance tolerance, Database db)
        {
            var hId = hatch.Id;

            try
            {
                if (hatch.Id.IsNull)
                {
                    using var t = db.TransactionManager.StartTransaction();
                    var cs     = db.CurrentSpaceId.GetObjectT <BlockTableRecord>(OpenMode.ForWrite);
                    var hClone = (Hatch)hatch.Clone();
                    hId = cs.AppendEntity(hClone);
                    t.AddNewlyCreatedDBObject(hClone, true);
                    t.Commit();
                }

                using var r   = hId.CreateRegionFromHatch();
                using var ray = new Ray { BasePoint = pt, UnitDir = new Vector3d(0.235, 0.7458, 0) };
                var pts = new Point3dCollection();
                ray.IntersectWith(r, Intersect.OnBothOperands, new Plane(), pts, IntPtr.Zero, IntPtr.Zero);
                return(pts.Count > 0 && (pts.Count.IsOdd() || pts.Cast <Point3d>().Any(p => p.IsEqualTo(pt))));
            }
            finally
            {
                if (!hId.IsNull)
                {
#pragma warning disable 618
                    using var h = hId.Open(OpenMode.ForWrite, false, true) as Hatch;
#pragma warning restore 618
                    h?.Erase();
                }
            }
        }
Exemplo n.º 24
0
        public void AddGradientHatch()
        {
            Database db = HostApplicationServices.WorkingDatabase;
            //创建一个三角形
            Polyline triangle = new Polyline();

            triangle.CreatePolygon(new Point2d(550, 200), 3, 30);
            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                //将三角形添加到模型空间中
                ObjectId triangleId = db.AddToModelSpace(triangle);
                //创建一个ObjectId集合类对象,用于存储填充边界的ObjectId
                ObjectIdCollection ids = new ObjectIdCollection
                {
                    triangleId             //将三角形的ObjectId添加到边界集合中
                };
                Hatch hatch = new Hatch(); //创建填充对象
                //创建两个Color类变量,分别表示填充的起始颜色(红)和结束颜色(蓝)
                Color color1 = Color.FromColorIndex(ColorMethod.ByLayer, 1);
                Color color2 = Color.FromColor(System.Drawing.Color.Blue);
                //创建渐变填充,与边界无关联
                hatch.CreateGradientHatch(HatchGradientName.Cylinder, color1, color2, false);
                //为填充添加边界(三角形)
                hatch.AppendLoop(HatchLoopTypes.Default, ids);
                hatch.EvaluateHatch(true); //计算并显示填充对象
                trans.Commit();            //提交更改
            }
        }
Exemplo n.º 25
0
        private void FillRectangle(DxfDocument dxf, Layer layer, double x, double y, double width, double height, ArgbColor color)
        {
            var fill             = ToColor(color);
            var fillTransparency = ToTransparency(color);

            var bounds =
                new List <HatchBoundaryPath>
            {
                new HatchBoundaryPath(
                    new List <EntityObject>
                {
                    CreateLine(x, y, x + width, y),
                    CreateLine(x + width, y, x + width, y + height),
                    CreateLine(x + width, y + height, x, y + height),
                    CreateLine(x, y + height, x, y)
                })
            };

            var hatch = new Hatch(HatchPattern.Solid, bounds, false);

            hatch.Layer = layer;
            hatch.Color = fill;
            hatch.Transparency.Value = fillTransparency;

            dxf.AddEntity(hatch);
        }
Exemplo n.º 26
0
        /// <summary>
        /// 创建填充。
        /// </summary>
        /// <param name="pattern"></param>
        /// <param name="loops"></param>
        /// <param name="type"></param>
        /// <param name="scale"></param>
        /// <param name="otherSetting"></param>
        /// <param name="db"></param>
        /// <param name="space"></param>
        /// <returns></returns>
        public static ObjectId CreateHatch(string pattern, ObjectIdCollection loops,
                                           HatchPatternType type       = HatchPatternType.PreDefined, double scale = 1,
                                           Action <Hatch> otherSetting = null, string space = null)
        {
            var hatch = new Hatch();
            var id    = hatch.ToSpace(loops[0].Database, space);

            using (var trans = id.Database.TransactionManager.StartTransaction())
            {
                hatch = trans.GetObject(id, OpenMode.ForWrite) as Hatch;

                hatch.PatternScale = scale;
                hatch.SetHatchPattern(type, pattern);

                foreach (ObjectId loopId in loops)
                {
                    hatch.AppendLoop(HatchLoopTypes.Default, new ObjectIdCollection()
                    {
                        loopId
                    });
                }

                otherSetting?.Invoke(hatch);
                trans.Commit();
            }

            return(id);
        }
Exemplo n.º 27
0
        public void AddHatch()
        {
            Database db = HostApplicationServices.WorkingDatabase;

            using (Transaction trans = db.TransactionManager.StartTransaction())
            {
                Hatch hatch = new Hatch(); //创建填充对象
                hatch.ToSpace();
                hatch.PatternScale = 0.5;  //设置填充图案的比例
                string patterName = DBHelper.CurrentPattern;
                //根据上面的填充图案名创建图案填充,类型为预定义,与边界关联
                hatch.CreateHatch(HatchPatternType.PreDefined, patterName, true);
                for (int i = 0; i < this.objco.Count; i++)
                {
                    if (i == 0)
                    {
                        //为填充添加外边界(正六边形)
                        hatch.AppendLoop(HatchLoopTypes.Outermost, objco[i]);
                    }
                    else
                    {
                        //为填充添加外边界(正六边形)
                        hatch.AppendLoop(HatchLoopTypes.Default, objco[i]);
                    }
                }
                hatch.EvaluateHatch(true); //计算并显示填充对象
                trans.Commit();            //提交更改
            }
        }
Exemplo n.º 28
0
 private void OnMouseClick(bool up, GeoPoint MousePosition, IView View)
 {
     if (up)
     {
         if (base.ShowActiveObject)
         {
             Plane      pln     = Frame.ActiveView.Projection.DrawingPlane;
             GeoPoint2D onPlane = pln.Project(MousePosition);
             Hatch      h       = ActiveObject as Hatch;
             // GeoObjectVisualizer.TestShowVisualizer(h);
             if (!h.CompoundShape.Contains(onPlane, true))
             {
                 base.ShowActiveObject = false;
             }
             else
             {   // das ActiveObject wird ja eingefügt, wenn die Aktion zu Ende ist
             }
         }
         else
         {
             if (debug)
             {
                 FindShape();
                 if (base.ShowActiveObject)
                 {
                     // System.Diagnostics.Trace.WriteLine("Schraffur wird zugefügt: " + (base.ActiveObject as Hatch).CompoundShape.Area.ToString());
                     base.OnDone(); // ActiveObject ist OK
                 }
             }
         }
     }
 }
Exemplo n.º 29
0
        public HatchDrawingObject CreateHatch(string patternName)
        {
            Transaction      trans = _database.TransactionManager.TopTransaction;
            BlockTableRecord btr   = _database.GetModelSpace(true);

            Hatch    oHatch = new Hatch();
            Vector3d normal = Vector3d.ZAxis;

            oHatch.Normal       = normal;
            oHatch.Elevation    = 0.0;
            oHatch.PatternScale = 1.0;
            oHatch.SetHatchPattern(HatchPatternType.PreDefined, patternName);

            btr.AppendEntity(oHatch);
            trans.AddNewlyCreatedDBObject(oHatch, true);

            oHatch.Associative = true;
            ObjectIdCollection acObjIdColl = new ObjectIdCollection();

            acObjIdColl.Add(BaseObject);
            oHatch.AppendLoop(HatchLoopTypes.Default, acObjIdColl);
            oHatch.EvaluateHatch(true);

            return(new HatchDrawingObject(oHatch));
        }
Exemplo n.º 30
0
        protected override void AcceptTextInput(InputArgs <string, CPSelectionSet> args)
        {
            args.InputValid = Point2D.TryParse(args.Input, out Point2D pt);
            if (args.InputValid)
            {
                if (!getFirstPoint)
                {
                    firstPoint          = pt;
                    getFirstPoint       = true;
                    args.InputCompleted = false;

                    consHatch = new Hatch(firstPoint, firstPoint, firstPoint, firstPoint);
                    Editor.Document.Transients.Add(consHatch);
                    consLine = new Polygon(firstPoint, firstPoint, firstPoint, firstPoint);
                    Editor.Document.Transients.Add(consLine);
                }
                else
                {
                    args.Value          = GetSelectionFromWindow();
                    args.InputCompleted = true;

                    Editor.Document.Transients.Remove(consHatch);
                    Editor.Document.Transients.Remove(consLine);
                }
            }
        }
Exemplo n.º 31
0
 private void AutoClose(MudObject Player, Hatch Hatch)
 {
     if (Hatch.GetBooleanProperty("open?"))
     {
         Hatch.SetProperty("open?", false);
         var otherSide = Portal.FindOppositeSide(Hatch);
         if (otherSide != null) otherSide.SetProperty("open?", false);
         MudObject.SendMessage(Player, "^<the0> closes.", Hatch);
     }
 }
Exemplo n.º 32
0
 public static Hatch CreateHatch(this List<Point2d> pts)
 {
     pts = pts.DistinctPoints();
     var ptCol = new Point2dCollection(pts.ToArray());
     ptCol.Add(pts[0]);
     var dCol = new DoubleCollection(new double[pts.Count]);
     var h = new Hatch();
     h.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
     h.AppendLoop(HatchLoopTypes.Default, ptCol, dCol);
     h.EvaluateHatch(false);
     return h;
 }
Exemplo n.º 33
0
 public HatchInfo(Hatch h)
 {
     Id = h.Id;
      if (h.Associative)
      {
     IdsAssociate = h.GetAssociatedObjectIds();
      }
      PatternName = h.PatternName;
      PatternScale = h.PatternScale;
      PatternAngle = h.PatternAngle;
      PatternType = h.PatternType;
      Layer = h.Layer;
      Color = h.Color;
      Lineweight = h.LineWeight;
 }
Exemplo n.º 34
0
        public void Create(Point2d ptCell, BlockTableRecord cs, Transaction t)
        {
            var cellWidth = ColorBookHelper.CellWidth;
            var cellHeight = ColorBookHelper.CellHeight;
            var margin = ColorBookHelper.Margin;
            var marginHalf = margin * 0.5;

            Point3d ptText = new Point3d(ptCell.X + cellWidth * 0.5, ptCell.Y - ColorBookHelper.TextHeight-margin, 0);

            Polyline pl = new Polyline(4);
            pl.AddVertexAt(0, new Point2d(ptCell.X+margin, ptText.Y- marginHalf), 0, 0, 0);
            pl.AddVertexAt(1, new Point2d(ptCell.X+cellWidth- margin, ptText.Y- marginHalf), 0, 0, 0);
            pl.AddVertexAt(2, new Point2d(ptCell.X + cellWidth-margin, ptCell.Y-cellHeight+margin), 0, 0, 0);
            pl.AddVertexAt(3, new Point2d(ptCell.X+margin, ptCell.Y - cellHeight+margin), 0, 0, 0);
            pl.Closed = true;
            pl.SetDatabaseDefaults();
            pl.Color = Color;

            cs.AppendEntity(pl);
            t.AddNewlyCreatedDBObject(pl, true);

            Hatch h = new Hatch();
            h.SetDatabaseDefaults();
            h.SetHatchPattern(HatchPatternType.PreDefined, "Solid");
            h.Annotative = AnnotativeStates.False;

            cs.AppendEntity(h);
            t.AddNewlyCreatedDBObject(h, true);

            h.Associative = true;
            h.AppendLoop(HatchLoopTypes.Default, new ObjectIdCollection(new[] { pl.Id }));
            h.Color = Color;
            h.EvaluateHatch(true);

            DBText text = new DBText();
            text.SetDatabaseDefaults();
            text.HorizontalMode = TextHorizontalMode.TextCenter;
            text.Annotative = AnnotativeStates.False;
            text.Height = ColorBookHelper.TextHeight;
            text.AlignmentPoint = ptText;
            text.AdjustAlignment(cs.Database);
            text.TextStyleId = ColorBookHelper.IdTextStylePik;
            text.TextString = Name;

            cs.AppendEntity(text);
            t.AddNewlyCreatedDBObject(text, true);
        }
Exemplo n.º 35
0
        /// <summary>
        /// Создание ассоциативной штриховки по полилинии
        /// Полилиния должна быть в базе чертежа
        /// </summary>        
        public static Hatch CreateAssociativeHatch(Curve loop, BlockTableRecord cs, Transaction t,
            string pattern = "SOLID", string layer = null, LineWeight lw = LineWeight.LineWeight015)
        {
            var h = new Hatch();
            h.SetDatabaseDefaults();
            if (layer != null)
            {
                Layers.LayerExt.CheckLayerState(layer);
                h.Layer = layer;
            }
            h.LineWeight = lw;
            h.Linetype = SymbolUtilityServices.LinetypeContinuousName;
            h.SetHatchPattern(HatchPatternType.PreDefined, pattern);
            cs.AppendEntity(h);
            t.AddNewlyCreatedDBObject(h, true);
            h.Associative = true;
            h.HatchStyle = HatchStyle.Normal;

            // добавление контура полилинии в гштриховку
            var ids = new ObjectIdCollection();
            ids.Add(loop.Id);
            try
            {
                h.AppendLoop(HatchLoopTypes.Default, ids);
            }
            catch (Exception ex)
            {
                Logger.Log.Error(ex, $"CreateAssociativeHatch");
                h.Erase();
                return null;
            }
            h.EvaluateHatch(true);

            var orders = cs.DrawOrderTableId.GetObject(OpenMode.ForWrite) as DrawOrderTable;
            orders.MoveToBottom(new ObjectIdCollection(new[] { h.Id }));

            return h;
        }
Exemplo n.º 36
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();
            }
        }
Exemplo n.º 37
0
        /// <summary>
        /// Generates and adds a series of <see cref="Hatch"/> objects to the supplied <see cref="BlockTableRecord"/>
        /// </summary>
        /// <returns>The selected color as a<see cref="Autodesk.AutoCAD.Colors.Color"/></returns>
        private static void CreateHatchesForConcentricCircles(BlockTableRecord blockTableRecord, ObjectIdCollection objectIdCollection, Transaction transaction)
        {
            var rand = new Random();
            var previousPattern = string.Empty;

            for (var i = 0; i < objectIdCollection.Count - 1; i++)
            {
                var r = Convert.ToByte((i + 1)*rand.Next(0, 25));
                var g = Convert.ToByte((i + 1)*rand.Next(0, 25));
                var b = Convert.ToByte((i + 1)*rand.Next(0, 25));

                using (var hatch = new Hatch())
                {
                    blockTableRecord.AppendEntity(hatch);
                    transaction.AddNewlyCreatedDBObject(hatch, true);

                    var pattern = GetRandomHatchPatternName();

                    //ensure pattern isn't repeated by from previous hatch
                    // in production quality code I would move this behavior to avoid violating SRP/SoC
                    while (pattern.Equals(previousPattern, StringComparison.InvariantCultureIgnoreCase))
                    {
                        pattern = GetRandomHatchPatternName();
                    }

                    previousPattern = pattern;

                    hatch.SetHatchPattern(HatchPatternType.PreDefined, pattern);
                    hatch.Color = Color.FromRgb(r, g, b);

                    // Associative must be set after the hatch object is appended to the block table record and before AppendLoop
                    hatch.Associative = true;

                    // Take the current circle and the next to create a HatchLoop
                    hatch.AppendLoop(HatchLoopTypes.Outermost, new ObjectIdCollection {objectIdCollection[i]});
                    hatch.AppendLoop(HatchLoopTypes.Default, new ObjectIdCollection {objectIdCollection[i + 1]});
                    hatch.EvaluateHatch(true);
                }
            }
        }
Exemplo n.º 38
0
        public void CreateNewHatch(BlockTableRecord btr)
        {
            var h = new Hatch();

             h.Annotative = AnnotativeStates.False;
             h.Layer = Layer;
             h.Color = Color;
             h.LineWeight = Lineweight;
             h.SetHatchPattern(PatternType, PatternName);
             h.PatternAngle = PatternAngle;
             h.PatternScale = PatternScale;
             h.SetHatchPattern(PatternType, PatternName);

             Id = btr.AppendEntity(h);
             btr.Database.TransactionManager.TopTransaction.AddNewlyCreatedDBObject(h, true);

             if (IdsAssociate != null && IdsAssociate.Count > 0)
             {
            h.Associative = true;
            h.AppendLoop(HatchLoopTypes.Default, IdsAssociate);
            h.EvaluateHatch(false);
             }
        }
Exemplo n.º 39
0
        private Hatch ParseHatch(ConfigNode node)
        {
            Vector3 position = Vector3.zero;
            Vector3 scale = Vector3.one;
            if (!node.HasValue("attachNodeId"))
            {
                Debug.LogWarning("[FreeIVA] Hatch attachNodeId not found: Skipping hatch.");
                return null;
            }
            Hatch hatch = new Hatch();

            hatch.AttachNodeId = node.GetValue("attachNodeId");

            if (node.HasValue("position"))
            {
                string posString = node.GetValue("position");
                string[] p = posString.Split(_splitChars, StringSplitOptions.RemoveEmptyEntries);
                if (p.Length != 3)
                {
                    Debug.LogWarning("[FreeIVA] Invalid hatch position definition \"" + posString + "\": Must be in the form x, y, z.");
                    return null;
                }
                else
                    hatch.LocalPosition = new Vector3(float.Parse(p[0]), float.Parse(p[1]), float.Parse(p[2]));
            }
            else
            {
                Debug.LogWarning("[FreeIVA] Hatch position not found: Skipping hatch.");
                return null;
            }

            if (node.HasValue("scale"))
            {
                string scaleString = node.GetValue("scale");
                string[] s = scaleString.Split(_splitChars, StringSplitOptions.RemoveEmptyEntries);
                if (s.Length != 3)
                {
                    Debug.LogWarning("[FreeIVA] Invalid hatch scale definition \"" + scaleString + "\": Must be in the form x, y, z.");
                    return null;
                }
                else
                    hatch.Scale = new Vector3(float.Parse(s[0]), float.Parse(s[1]), float.Parse(s[2]));
            }
            else
            {
                Debug.LogWarning("[FreeIVA] Hatch scale not found: Skipping hatch.");
                return null;
            }

            if (node.HasValue("rotation"))
            {
                string rotationString = node.GetValue("rotation");
                string[] s = rotationString.Split(_splitChars, StringSplitOptions.RemoveEmptyEntries);
                if (s.Length != 3)
                {
                    Debug.LogWarning("[FreeIVA] Invalid hatch rotation definition \"" + rotationString + "\": Must be in the form x, y, z.");
                    return null;
                }
                else
                    hatch.Rotation = Quaternion.Euler(float.Parse(s[0]), float.Parse(s[1]), float.Parse(s[2]));
            }
            else
            {
                Debug.LogWarning("[FreeIVA] Hatch rotation not found: Skipping hatch.");
                return null;
            }

            if (node.HasNode("HideWhenOpen"))
            {
                ConfigNode[] hideNodes = node.GetNodes("HideWhenOpen");
                foreach (var hideNode in hideNodes)
                {
                    if (!hideNode.HasValue("name"))
                    {
                        Debug.LogWarning("[FreeIVA] HideWhenOpen name not found.");
                        continue;
                    }
                    string propName = hideNode.GetValue("name");
                    Vector3 propPos;

                    if (hideNode.HasValue("position"))
                    {
                        string posString = hideNode.GetValue("position");
                        string[] p = posString.Split(_splitChars, StringSplitOptions.RemoveEmptyEntries);
                        if (p.Length != 3)
                        {
                            Debug.LogWarning("[FreeIVA] Invalid HideWhenOpen position definition \"" + posString + "\": Must be in the form x, y, z.");
                            continue;
                        }
                        else
                        {
                            propPos = new Vector3(float.Parse(p[0]), float.Parse(p[1]), float.Parse(p[2]));
                        }
                    }
                    else
                    {
                        Debug.LogWarning("[FreeIVA] Hatch position not found: Skipping hatch.");
                        continue;
                    }

                    hatch.HideWhenOpen.Add(new KeyValuePair<Vector3, string>(propPos, propName));
                }
            }

            if (node.HasNode("InternalCollider"))
            {
                ConfigNode hatchColliderNode = node.GetNode("InternalCollider");
                if (hatchColliderNode != null)
                    hatch.Collider = ParseInternalCollider(hatchColliderNode);
            }
            return hatch;
        }
Exemplo n.º 40
0
        public void Figura4()
        {
            Database db = HostApplicationServices.WorkingDatabase;
            Document doc = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.GetDocument(db);
            Editor ed = doc.Editor;

            PromptDoubleOptions GetSpindulys = new PromptDoubleOptions("\nĮveskite didžiausio apskritimo spindulį");
            double Spindulys;
            GetSpindulys.AllowNegative = false;
            GetSpindulys.AllowZero = false;
            GetSpindulys.AllowZero = false;
            PromptDoubleResult GetSpindulysRezultatas = ed.GetDouble(GetSpindulys);
            Spindulys = GetSpindulysRezultatas.Value;

            PromptDoubleOptions GetPlotis = new PromptDoubleOptions("\nĮveskite apskirtimo spindulio mažėjimą");
            double Plotis;
            GetPlotis.AllowNegative = false;
            GetPlotis.AllowZero = false;
            GetPlotis.AllowZero = false;
            PromptDoubleResult GetPlotisRezultatas = ed.GetDouble(GetPlotis);
            Plotis = GetPlotisRezultatas.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);
                int i = 1;
                while(Spindulys > 0)
                {
                    Circle Apskritimas = new Circle(Taskas, new Vector3d(0, 0, 1), Spindulys);
                    btr.AppendEntity(Apskritimas);
                    tr.AddNewlyCreatedDBObject(Apskritimas, true);

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

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

                    Spindulys -= Plotis;
                }
                tr.Commit();
            }
        }
Exemplo n.º 41
0
        private void сreateHatch(Extents3d extText, BlockTableRecord btr)
        {
            if (extText.Diagonal() < 100)
            {
                return;
            }
            // Отступ контура штриховки от границ текста
            Extents3d ext = new Extents3d(new Point3d(extText.MinPoint.X - 10, extText.MinPoint.Y - 10, 0),
                                          new Point3d(extText.MaxPoint.X + 10, extText.MaxPoint.Y + 10, 0));
            var h = new Hatch();
            h.SetDatabaseDefaults(btr.Database);
            if (!panelBtr.CaptionLayerId.IsNull)
                h.LayerId = panelBtr.CaptionLayerId;
            h.LineWeight = LineWeight.LineWeight015;
            h.Linetype = SymbolUtilityServices.LinetypeContinuousName;
            h.Color = Color.FromRgb(250, 250, 250);
            h.Transparency = new Transparency(80);
            h.SetHatchPattern(HatchPatternType.PreDefined, "ANGLE");
            h.PatternScale = 25.0;
            btr.AppendEntity(h);
            var t = btr.Database.TransactionManager.TopTransaction;
            t.AddNewlyCreatedDBObject(h, true);
            h.Associative = true;
            h.HatchStyle = HatchStyle.Normal;

            // Полилиния по контуру текста
            Polyline pl = new Polyline();
            pl.SetDatabaseDefaults(btr.Database);
            pl.LineWeight = LineWeight.LineWeight015;
            pl.Linetype = SymbolUtilityServices.LinetypeContinuousName;
            pl.ColorIndex = 256; // ПоСлою
            if (!panelBtr.CaptionLayerId.IsNull)
                pl.LayerId = panelBtr.CaptionLayerId;
            pl.AddVertexAt(0, ext.MinPoint.Convert2d(), 0, 0, 0);
            pl.AddVertexAt(0, new Point2d(ext.MaxPoint.X, ext.MinPoint.Y), 0, 0, 0);
            pl.AddVertexAt(0, ext.MaxPoint.Convert2d(), 0, 0, 0);
            pl.AddVertexAt(0, new Point2d(ext.MinPoint.X, ext.MaxPoint.Y), 0, 0, 0);
            pl.Closed = true;

            ObjectId idPl = btr.AppendEntity(pl);
            t.AddNewlyCreatedDBObject(pl, true);

            // добавление контура полилинии в гштриховку
            var ids = new ObjectIdCollection();
            ids.Add(idPl);
            h.AppendLoop(HatchLoopTypes.Default, ids);
            h.EvaluateHatch(true);

            // Замена текстов - чтобы они стали поверх штриховки.
            panelBtr.IdCaptionMarkSb = replaceText(panelBtr.IdCaptionMarkSb, btr);
            panelBtr.IdCaptionPaint = replaceText(panelBtr.IdCaptionPaint, btr);
        }