Пример #1
0
        private void MyMirror(List <Entity> listEnt, Line line, string xY)
        {
            if (listEnt == null || line == null)
            {
                return;
            }

            Line3d line3d = new Line3d(line.StartPoint, line.EndPoint);

            for (int i = 0; i < listEnt.Count; i++)
            {
                var entity = listEnt[i];

                Entity ent = entity;

                //if((ent as Dimension) != null)
                //{
                //    continue;
                //}


                if (ent is DBText || ent is MText)
                {
                    listOId.Add(ent.ToSpace(blkRef.Database));
                }
                else
                {
                    ent = entity.GetTransformedCopy(Matrix3d.Mirroring(line3d));

                    if ((ent as Dimension) == null)
                    {
                        list.Add(ent);
                    }

                    //continue;
                }

                /* var ptMin = ent.Bounds.Value.MinPoint;
                 *
                 * var ptMax = ent.Bounds.Value.MaxPoint;
                 *
                 * var w = Math.Abs(ptMax.X - ptMin.X);
                 * var h = Math.Abs(ptMax.Y - ptMin.Y);
                 *
                 * var ptCenter = new Point3d((ptMin.X + ptMax.X) / 2, (ptMin.Y + ptMax.Y) / 2, 0);*/
                if (ent is DBText)
                {
                    var a = ent as DBText;
                    MirrorText(a, line3d);
                }
                else if (ent is MText)
                {
                    var a = ent as MText;

                    MirrorText(a, line3d);
                }
                else if ((ent as Dimension) != null)
                {
                    var dim = ent as Dimension;



                    Plane p = null;

                    if (xY == "X")
                    {
                        p   = new Plane(dim.TextPosition, dim.Normal);
                        ent = dim.GetTransformedCopy(Matrix3d.Mirroring(p));
                    }
                    else if (xY == "Y")
                    {
                        p = new Plane(dim.TextPosition, dim.Normal);

                        ent = dim.GetTransformedCopy(Matrix3d.Mirroring(p));
                    }
                    if (ent is RotatedDimension)
                    {
                        var rDim = ent as RotatedDimension;

                        var rDim1 = new RotatedDimension(rDim.Rotation, rDim.XLine1Point, rDim.XLine2Point, rDim.DimLinePoint, rDim.DimensionText, rDim.DimensionStyle);
                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }

                    else if (ent is AlignedDimension)
                    {
                        var rDim = ent as AlignedDimension;

                        var rDim1 = new AlignedDimension(rDim.XLine1Point, rDim.XLine2Point, rDim.DimLinePoint, rDim.DimensionText, rDim.DimensionStyle);
                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                    else if (ent is ArcDimension)
                    {
                        var rDim = ent as ArcDimension;

                        var rDim1 = new ArcDimension(rDim.CenterPoint, rDim.XLine1Point, rDim.XLine2Point, rDim.ArcPoint, rDim.DimensionText, rDim.DimensionStyle);

                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                    else if (ent is DiametricDimension)
                    {
                        var rDim = ent as DiametricDimension;

                        var rDim1 = new DiametricDimension(rDim.ChordPoint, rDim.FarChordPoint, rDim.LeaderLength, rDim.DimensionText, rDim.DimensionStyle);

                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                    else if (ent is LineAngularDimension2)
                    {
                        var rDim = ent as LineAngularDimension2;

                        var rDim1 = new LineAngularDimension2(rDim.XLine1Start, rDim.XLine1End, rDim.XLine2Start, rDim.XLine2End, rDim.ArcPoint, rDim.DimensionText, rDim.DimensionStyle);

                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                    else if (ent is Point3AngularDimension)
                    {
                        var rDim = ent as Point3AngularDimension;

                        var rDim1 = new Point3AngularDimension(rDim.CenterPoint, rDim.XLine1Point, rDim.XLine2Point, rDim.ArcPoint, rDim.DimensionText, rDim.DimensionStyle);

                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                    else if (ent is RadialDimension)
                    {
                        var rDim = ent as RadialDimension;

                        var rDim1 = new RadialDimension(rDim.Center, rDim.ChordPoint, rDim.LeaderLength, rDim.DimensionText, rDim.DimensionStyle);


                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                    else if (ent is RadialDimensionLarge)
                    {
                        var rDim = ent as RadialDimensionLarge;

                        var rDim1 = new RadialDimensionLarge(rDim.Center, rDim.ChordPoint, rDim.OverrideCenter, rDim.JogPoint, rDim.JogAngle, rDim.DimensionText, rDim.DimensionStyle);

                        Dim2Dim(rDim1, rDim);
                        list.Add(rDim1);
                    }
                }
            }



            listEnt.ForEach(ent => ent.Dispose());
        }
Пример #2
0
        public static bool Clear(this Dimension obj)
        {
            bool myFlag = false;

            if (Math.Abs(obj.Elevation) >= TOLERANCE)
            {
                obj.Elevation = 0.0;
                myFlag        = true;
            }
            if (obj is AlignedDimension)
            {
                AlignedDimension myDimension = obj as AlignedDimension;
                if (Math.Abs(myDimension.XLine1Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine1Point = myDimension.XLine1Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine2Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine2Point = myDimension.XLine2Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.DimLinePoint.Z) >= TOLERANCE)
                {
                    myDimension.DimLinePoint = myDimension.DimLinePoint.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is ArcDimension)
            {
                ArcDimension myDimension = obj as ArcDimension;
                if (Math.Abs(myDimension.XLine1Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine1Point = myDimension.XLine1Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine2Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine2Point = myDimension.XLine2Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.Leader1Point.Z) >= TOLERANCE)
                {
                    myDimension.Leader1Point = myDimension.Leader1Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.Leader2Point.Z) >= TOLERANCE)
                {
                    myDimension.Leader2Point = myDimension.Leader2Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.ArcPoint.Z) >= TOLERANCE)
                {
                    myDimension.ArcPoint = myDimension.ArcPoint.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is DiametricDimension)
            {
                DiametricDimension myDimension = obj as DiametricDimension;
                if (Math.Abs(myDimension.ChordPoint.Z) >= TOLERANCE)
                {
                    myDimension.ChordPoint = myDimension.ChordPoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.FarChordPoint.Z) >= TOLERANCE)
                {
                    myDimension.FarChordPoint = myDimension.FarChordPoint.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is LineAngularDimension2)
            {
                LineAngularDimension2 myDimension = obj as LineAngularDimension2;
                if (Math.Abs(myDimension.ArcPoint.Z) >= TOLERANCE)
                {
                    myDimension.ArcPoint = myDimension.ArcPoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine1End.Z) >= TOLERANCE)
                {
                    myDimension.XLine1End = myDimension.XLine1End.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine1Start.Z) >= TOLERANCE)
                {
                    myDimension.XLine1Start = myDimension.XLine1Start.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine2End.Z) >= TOLERANCE)
                {
                    myDimension.XLine2End = myDimension.XLine2End.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine2Start.Z) >= TOLERANCE)
                {
                    myDimension.XLine2Start = myDimension.XLine2Start.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is Point3AngularDimension)
            {
                Point3AngularDimension myDimension = obj as Point3AngularDimension;
                if (Math.Abs(myDimension.ArcPoint.Z) >= TOLERANCE)
                {
                    myDimension.ArcPoint = myDimension.ArcPoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.CenterPoint.Z) >= TOLERANCE)
                {
                    myDimension.CenterPoint = myDimension.CenterPoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine1Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine1Point = myDimension.XLine1Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine2Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine2Point = myDimension.XLine2Point.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is RadialDimension)
            {
                RadialDimension myDimension = obj as RadialDimension;
                if (Math.Abs(myDimension.Center.Z) >= TOLERANCE)
                {
                    myDimension.Center = myDimension.Center.ClearZ();
                    myFlag             = true;
                }
                if (Math.Abs(myDimension.ChordPoint.Z) >= TOLERANCE)
                {
                    myDimension.ChordPoint = myDimension.ChordPoint.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is RadialDimensionLarge)
            {
                RadialDimensionLarge myDimension = obj as RadialDimensionLarge;
                if (Math.Abs(myDimension.Center.Z) >= TOLERANCE)
                {
                    myDimension.Center = myDimension.Center.ClearZ();
                    myFlag             = true;
                }
                if (Math.Abs(myDimension.ChordPoint.Z) >= TOLERANCE)
                {
                    myDimension.ChordPoint = myDimension.ChordPoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.JogPoint.Z) >= TOLERANCE)
                {
                    myDimension.JogPoint = myDimension.JogPoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.OverrideCenter.Z) >= TOLERANCE)
                {
                    myDimension.OverrideCenter = myDimension.OverrideCenter.ClearZ();
                    myFlag = true;
                }
            }
            else if (obj is RotatedDimension)
            {
                RotatedDimension myDimension = obj as RotatedDimension;
                if (Math.Abs(myDimension.DimLinePoint.Z) >= TOLERANCE)
                {
                    myDimension.DimLinePoint = myDimension.DimLinePoint.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine1Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine1Point = myDimension.XLine1Point.ClearZ();
                    myFlag = true;
                }
                if (Math.Abs(myDimension.XLine2Point.Z) >= TOLERANCE)
                {
                    myDimension.XLine2Point = myDimension.XLine2Point.ClearZ();
                    myFlag = true;
                }
            }
            return(myFlag);
        }