Example #1
0
        internal override bool TrySetPair(DxfCodePair pair)
        {
            switch (_readMode)
            {
            case ReadMode.BoundaryPath:
                if (pair.Code == 92)
                {
                    // new boundary path
                    var pathType = (BoundaryPathType)pair.IntegerValue;
                    BoundaryPaths.Add(BoundaryPathBase.CreateFromType(pathType));
                    return(true);
                }

                if (BoundaryPaths.Last().TrySetPair(pair))
                {
                    return(true);
                }
                else
                {
                    _readMode = ReadMode.Entity;
                    break;
                }

            case ReadMode.PatternData:
                if (pair.Code == 53)
                {
                    // new pattern definition line
                    PatternDefinitionLines.Add(new PatternDefinitionLine());
                }

                if (PatternDefinitionLines.Last().TrySetPair(pair))
                {
                    return(true);
                }
                else
                {
                    _readMode = ReadMode.Entity;
                    break;
                }

            case ReadMode.SeedPoints:
                switch (pair.Code)
                {
                case 10:
                    // new seed point
                    SeedPoints.Add(new DxfPoint(pair.DoubleValue, 0.0, 0.0));
                    return(true);

                case 20:
                    SeedPoints[SeedPoints.Count - 1] = SeedPoints.Last().WithUpdatedY(pair.DoubleValue);
                    return(true);

                default:
                    _readMode = ReadMode.Entity;
                    break;
                }
                break;
            }

            switch (pair.Code)
            {
            case 2:
                this.PatternName = pair.StringValue;
                break;

            case 10:
                this.ElevationPoint = this.ElevationPoint.WithUpdatedX(pair.DoubleValue);
                break;

            case 20:
                this.ElevationPoint = this.ElevationPoint.WithUpdatedY(pair.DoubleValue);
                break;

            case 30:
                this.ElevationPoint = this.ElevationPoint.WithUpdatedZ(pair.DoubleValue);
                break;

            case 41:
                this.PatternScale = pair.DoubleValue;
                break;

            case 47:
                this.PixelSize = pair.DoubleValue;
                break;

            case 52:
                this.PatternAngle = pair.DoubleValue;
                break;

            case 63:
                this.FillColor = DxfColor.FromRawValue(pair.ShortValue);
                break;

            case 70:
                this.FillMode = (DxfHatchPatternFillMode)pair.ShortValue;
                break;

            case 71:
                this.IsAssociative = BoolShort(pair.ShortValue);
                break;

            case 75:
                this.HatchStyle = (DxfHatchStyle)pair.ShortValue;
                break;

            case 76:
                this.PatternType = (DxfHatchPatternType)pair.ShortValue;
                break;

            case 77:
                this.IsPatternDoubled = BoolShort(pair.ShortValue);
                break;

            case 78:
                this._patternDefinitionLineCount = pair.ShortValue;
                _readMode = ReadMode.PatternData;
                break;

            case 91:
                this._boundaryPathCount = pair.IntegerValue;
                _readMode = ReadMode.BoundaryPath;
                break;

            case 98:
                this._seedPointCount = pair.IntegerValue;
                _readMode            = ReadMode.SeedPoints;
                break;

            case 210:
                this.ExtrusionDirection = this.ExtrusionDirection.WithUpdatedX(pair.DoubleValue);
                break;

            case 220:
                this.ExtrusionDirection = this.ExtrusionDirection.WithUpdatedY(pair.DoubleValue);
                break;

            case 230:
                this.ExtrusionDirection = this.ExtrusionDirection.WithUpdatedZ(pair.DoubleValue);
                break;

            case 450:
                this.IsGradient = BoolInt(pair.IntegerValue);
                break;

            case 451:
                this._zero = pair.IntegerValue;
                break;

            case 452:
                this.GradientColorMode = (DxfGradientColorMode)pair.IntegerValue;
                break;

            case 453:
                this.NumberOfColors = pair.IntegerValue;
                break;

            case 460:
                this.GradientRotationAngle = pair.DoubleValue;
                break;

            case 461:
                this.GradientDefinitionShift = pair.DoubleValue;
                break;

            case 462:
                this.ColorTint = pair.DoubleValue;
                break;

            case 463:
                this._reserved = pair.DoubleValue;
                break;

            case 470:
                this.StringValue = pair.StringValue;
                break;

            default:
                return(base.TrySetPair(pair));
            }

            return(true);
        }
Example #2
0
        /// <summary>
        /// Moves, scales, and/or rotates the current entity given a 3x3 transformation matrix and a translation vector.
        /// </summary>
        /// <param name="transformation">Transformation matrix.</param>
        /// <param name="translation">Translation vector.</param>
        public override void TransformBy(Matrix3 transformation, Vector3 translation)
        {
            Vector3 newNormal;
            double  newScale;
            double  newAngle;

            newNormal = transformation * Normal;

            Matrix3 transOW = MathHelper.ArbitraryAxis(Normal);
            Matrix3 transWO = MathHelper.ArbitraryAxis(newNormal).Transpose();

            List <HatchBoundaryPath> paths = new List <HatchBoundaryPath>();

            foreach (HatchBoundaryPath path in BoundaryPaths)
            {
                List <EntityObject> data = new List <EntityObject>();

                foreach (HatchBoundaryPath.Edge edge in path.Edges)
                {
                    EntityObject entity = edge.ConvertTo();

                    switch (entity.Type)
                    {
                    case EntityType.Arc:
                        entity = ProcessArc((Arc)entity, transOW, transOW * new Vector3(0.0, 0.0, Elevation));
                        break;

                    case EntityType.Circle:
                        entity = ProcessCircle((Circle)entity, transOW, transOW * new Vector3(0.0, 0.0, Elevation));
                        break;

                    case EntityType.Ellipse:
                        entity = ProcessEllipse((Ellipse)entity, transOW, transOW * new Vector3(0.0, 0.0, Elevation));
                        break;

                    case EntityType.Line:
                        entity = ProcessLine((Line)entity, transOW, transOW * new Vector3(0.0, 0.0, Elevation));
                        break;

                    case EntityType.LwPolyline:
                        entity = ProcessLwPolyline((LwPolyline)entity, Normal, Elevation);
                        break;

                    case EntityType.Spline:
                        entity = ProcessSpline((Spline)entity, transOW, transOW * new Vector3(0.0, 0.0, Elevation));
                        break;
                    }
                    entity.TransformBy(transformation, translation);
                    data.Add(entity);
                }
                paths.Add(new HatchBoundaryPath(data));
            }

            Vector3 position = transOW * new Vector3(0.0, 0.0, Elevation);

            position = transformation * position + translation;
            position = transWO * position;

            Vector2 refAxis = Vector2.Rotate(Vector2.UnitX, Pattern.Angle * MathHelper.DegToRad);

            refAxis = Pattern.Scale * refAxis;
            Vector3 v = transOW * new Vector3(refAxis.X, refAxis.Y, 0.0);

            v = transformation * v;
            v = transWO * v;
            Vector2 axis = new Vector2(v.X, v.Y);

            newAngle = Vector2.Angle(axis) * MathHelper.RadToDeg;

            newScale = axis.Modulus();
            newScale = MathHelper.IsZero(newScale) ? MathHelper.Epsilon : newScale;

            Pattern.Scale = newScale;
            Pattern.Angle = newAngle;
            Elevation     = position.Z;

            Normal = newNormal;
            BoundaryPaths.Clear();
            BoundaryPaths.AddRange(paths);
        }