internal Matrix4D method_14() { Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(this.vector3D_0); toWcsTransform.Transpose(); Matrix4D matrix4D1 = Transformation4D.RotateZ(this.double_6) * toWcsTransform; Matrix4D matrix4D2; Matrix4D matrix4D3; Matrix4D matrix4D4; if (this.PerspectiveMode) { double num1 = Class484.smethod_0(this.size2D_0, this.double_1, this.double_4); matrix4D2 = this.method_24(); matrix4D3 = new Matrix4D(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0 / this.double_1, 0.0, 0.0, -1.0 / this.double_1, 0.0) * Transformation4D.Translation(0.0, 0.0, -num1); double num2 = System.Math.Sqrt(this.size2D_0.X * this.size2D_0.X + this.size2D_0.Y * this.size2D_0.Y) / 42.0; matrix4D4 = Transformation4D.Scaling(num2, num2, 1.0); } else { matrix4D2 = this.method_25(); matrix4D3 = Matrix4D.Identity; double num = this.size2D_0.Y / this.double_4; matrix4D4 = Transformation4D.Scaling(num, num, 1.0); } Matrix4D matrix4D5 = Transformation4D.Translation(-this.point2D_0.X, -this.point2D_0.Y, 0.0); return(matrix4D2 * matrix4D4 * matrix4D5 * matrix4D3 * matrix4D1 * Transformation4D.Translation(-(WW.Math.Vector3D) this.point3D_1)); }
public Matrix4D GetTransform(Size2D targetSize) { Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(this.vector3D_0); toWcsTransform.Transpose(); Matrix4D matrix4D = Transformation4D.RotateZ(this.double_6) * toWcsTransform; return(Transformation4D.Translation(this.point2D_2.X, this.point2D_2.Y, 0.0) * (!this.PerspectiveMode ? Matrix4D.Identity : new Matrix4D(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0 / this.double_2, 0.0, 0.0, -1.0 / this.double_2, 0.0) * Transformation4D.Translation(0.0, 0.0, -Class484.smethod_0(new Size2D(targetSize.X * this.double_1, targetSize.Y), this.double_2, this.double_0))) * matrix4D * Transformation4D.Translation(-this.point3D_0.X, -this.point3D_0.Y, -this.point3D_0.Z)); }
public Matrix4D GetTransform() { Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(this.vector3D_0); toWcsTransform.Transpose(); Matrix4D matrix4D = Transformation4D.RotateZ(this.double_3) * toWcsTransform; return((!this.PerspectiveMode ? Matrix4D.Identity : new Matrix4D(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.0 / this.double_0, 0.0, 0.0, -1.0 / this.double_0, 0.0) * Transformation4D.Translation(0.0, 0.0, -this.vector3D_0.GetLength())) * Transformation4D.Translation(-this.point2D_0.X, -this.point2D_0.Y, 0.0) * matrix4D * Transformation4D.Translation(-(Vector3D)this.point3D_0)); }
private void DrawInternal(DxfInsert.Interface46 drawHandler, bool drawBlock) { Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(this.ZAxis); Matrix4D matrix4D1 = Transformation4D.Translation((WW.Math.Vector3D) this.InsertionPoint); Matrix4D matrix4D2 = Transformation4D.RotateZ(this.Rotation); Matrix4D matrix4D3 = Transformation4D.Scaling(this.ScaleFactor); ushort num1 = this.RowCount; if (num1 < (ushort)1) { num1 = (ushort)1; } ushort num2 = this.ColumnCount; if (num2 < (ushort)1) { num2 = (ushort)1; } for (int row = 0; row < (int)num1; ++row) { for (int column = 0; column < (int)num2; ++column) { if (drawBlock) { Matrix4D matrix4D4 = toWcsTransform * matrix4D1 * matrix4D2 * Transformation4D.Translation((double)column * this.ColumnSpacing, (double)row * this.RowSpacing, 0.0) * matrix4D3; drawHandler.imethod_0(row, column, matrix4D4); if (this.Block != null) { switch (this.method_16(matrix4D4, drawHandler)) { case DxfInsert.Enum44.const_1: case DxfInsert.Enum44.const_2: drawHandler.Draw(this.Block, true); break; case DxfInsert.Enum44.const_3: drawHandler.Draw(this.Block, true); drawHandler.InsertCellDrawContext.vmethod_1(); break; } } } if (this.Attributes.Count > 0) { WW.Math.Vector3D vector = new WW.Math.Vector3D((double)column * this.ColumnSpacing, (double)row * this.RowSpacing, 0.0); vector = (toWcsTransform * matrix4D2).Transform(vector); Matrix4D instanceTransform = Transformation4D.Translation(vector.X, vector.Y, vector.Z); drawHandler.imethod_1(row, column, instanceTransform); foreach (DxfAttribute attribute in (IEnumerable <DxfAttribute>) this.Attributes) { drawHandler.Draw(attribute); } } } } }
private DxfLayout.PlotInfo GetPlotInfo( bool invertY, DxfLayout.BasicLayoutRenderInfo layoutRenderInfo) { Size2D plotPaperSize = this.PlotPaperSize; if (plotPaperSize.X == 0.0 || plotPaperSize.Y == 0.0) { return((DxfLayout.PlotInfo)null); } double y = invertY ? this.UnprintableMarginBottom : plotPaperSize.Y - this.UnprintableMarginTop; WW.Math.Point3D toPoint1 = new WW.Math.Point3D(this.UnprintableMarginLeft, invertY ? plotPaperSize.Y - this.UnprintableMarginTop : this.UnprintableMarginBottom, 0.0); WW.Math.Point3D toPoint2 = new WW.Math.Point3D(plotPaperSize.X - this.UnprintableMarginRight, y, 0.0); WW.Math.Point3D toReferencePoint = new WW.Math.Point3D(0.5 * (toPoint1.X + toPoint2.X), 0.5 * (toPoint1.Y + toPoint2.Y), 0.0); Matrix4D matrix4D1 = Matrix4D.Identity; switch (this.PlotRotation) { case PlotRotation.QuarterCounterClockwise: matrix4D1 = Transformation4D.RotateZ(System.Math.PI / 2.0); break; case PlotRotation.Half: matrix4D1 = Transformation4D.RotateZ(System.Math.PI); break; case PlotRotation.QuarterClockwise: matrix4D1 = Transformation4D.RotateZ(-1.0 * System.Math.PI / 2.0); break; } if (invertY) { matrix4D1 *= Transformation4D.Scaling(1.0, -1.0, 1.0); } WW.Math.Point3D point3D1 = new WW.Math.Point3D(layoutRenderInfo.LayoutViewport.Min, 0.0); WW.Math.Point3D point3D2 = new WW.Math.Point3D(layoutRenderInfo.LayoutViewport.Max, 0.0); WW.Math.Point3D fromReferencePoint = new WW.Math.Point3D(layoutRenderInfo.LayoutViewport.Center, 0.0); Matrix4D matrix4D2 = Transformation4D.Translation((WW.Math.Vector3D)fromReferencePoint) * matrix4D1 * Transformation4D.Translation(-(WW.Math.Vector3D)fromReferencePoint); WW.Math.Point3D point3D3 = matrix4D2 * point3D1; point3D2 = matrix4D2 * point3D2; double scaling; Matrix4D toPaperTransform = DxfUtil.GetScaleTransform(new WW.Math.Point3D(System.Math.Min(point3D3.X, point3D2.X), System.Math.Min(point3D3.Y, point3D2.Y), 0.0), new WW.Math.Point3D(System.Math.Max(point3D3.X, point3D2.X), System.Math.Max(point3D3.Y, point3D2.Y), 0.0), fromReferencePoint, toPoint1, toPoint2, toReferencePoint, out scaling) * matrix4D2; return(new DxfLayout.PlotInfo(this, plotPaperSize, new Rectangle2D(toPoint1.X, System.Math.Min(toPoint1.Y, toPoint2.Y), toPoint2.X, System.Math.Max(toPoint1.Y, toPoint2.Y)), toPaperTransform, scaling)); }
internal static Matrix4D smethod_6( ILeader leader, IList <WW.Math.Point3D> vertices, Vector3D zaxis) { WW.Math.Point3D vertex1 = vertices[0]; WW.Math.Point3D vertex2 = vertices[1]; Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(zaxis); Vector3D v1 = new Vector3D(toWcsTransform.M00, toWcsTransform.M10, toWcsTransform.M20); Vector3D v2 = new Vector3D(toWcsTransform.M01, toWcsTransform.M11, toWcsTransform.M21); Vector3D u = vertex1 - vertex2; double angle = System.Math.Atan2(Vector3D.DotProduct(u, v2), Vector3D.DotProduct(u, v1)); double effectiveArrowSize = leader.GetEffectiveArrowSize(); return(Transformation4D.Translation((Vector3D)vertex1) * toWcsTransform * Transformation4D.RotateZ(angle) * Transformation4D.Scaling(effectiveArrowSize, effectiveArrowSize, effectiveArrowSize)); }
public static Matrix4D GetBasicModelToViewportTransform(IViewDescription view) { Matrix4D matrix4D1 = view.IsTargetPaper ? Transformation4D.Translation(-view.ViewCenter.X, -view.ViewCenter.Y, 0.0) : Transformation4D.Translation(-view.ViewCenter.X, -view.ViewCenter.Y, -view.ViewDirection.GetLength()) * Transformation4D.RotateZ(view.ViewTwistAngle) * DxfUtil.GetToWCSTransform(view.ViewDirection).GetTranspose() * Transformation4D.Translation(-(Vector3D)view.ViewTarget); if ((view.ViewModeFlags & ViewportStatusFlags.PerspectiveMode) != ViewportStatusFlags.None) { double num1 = 1.0 / System.Math.Tan(0.5 * (2.0 * System.Math.Atan(18.0 / view.FocalLength))); double num2 = 0.5 * view.ViewWidth; Matrix4D matrix4D2 = new Matrix4D(num2, 0.0, 0.0, 0.0, 0.0, num2, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0); matrix4D1 = Transformation4D.Scaling(num1, num1, 1.0) * matrix4D2 * matrix4D1; } return(matrix4D1); }
public DxfLayout.PlotInfo GetPlotInfo( double paperWidth, double paperHeight, Rectangle2D printArea, bool autoRotate, bool invertY) { DxfLayout.BasicLayoutRenderInfo layoutRenderInfo = this.method_8(); if (!layoutRenderInfo.LayoutViewport.Initialized) { return((DxfLayout.PlotInfo)null); } Bounds2D layoutViewport = layoutRenderInfo.LayoutViewport; Matrix4D matrix4D1 = Matrix4D.Identity; double num1 = layoutViewport.Delta.X; double num2 = layoutViewport.Delta.Y; if (autoRotate && (printArea.Width > printArea.Height && num1 < num2 || printArea.Width < printArea.Height && num1 > num2)) { PlotRotation plotRotation1 = PlotRotation.None; PlotRotation plotRotation2; PlotRotation plotRotation3; switch (this.PlotRotation) { case PlotRotation.None: plotRotation2 = PlotRotation.QuarterCounterClockwise; plotRotation3 = PlotRotation.QuarterCounterClockwise; goto label_10; case PlotRotation.QuarterCounterClockwise: plotRotation2 = PlotRotation.QuarterClockwise; plotRotation3 = PlotRotation.QuarterClockwise; break; case PlotRotation.Half: plotRotation2 = PlotRotation.QuarterClockwise; plotRotation3 = PlotRotation.QuarterClockwise; break; case PlotRotation.QuarterClockwise: plotRotation2 = PlotRotation.QuarterCounterClockwise; plotRotation3 = PlotRotation.QuarterCounterClockwise; goto label_10; default: switch (plotRotation1) { case PlotRotation.QuarterCounterClockwise: goto label_10; case PlotRotation.QuarterClockwise: break; default: goto label_11; } } matrix4D1 = Transformation4D.RotateZ(invertY ? System.Math.PI / 2.0 : -1.0 * System.Math.PI / 2.0); goto label_11; label_10: matrix4D1 = Transformation4D.RotateZ(invertY ? -1.0 * System.Math.PI / 2.0 : System.Math.PI / 2.0); label_11: num1 = layoutViewport.Delta.Y; num2 = layoutViewport.Delta.X; } double s = System.Math.Min(printArea.Width / num1, printArea.Height / num2); if (!DxfUtil.IsSaneNotZero(s)) { return((DxfLayout.PlotInfo)null); } Matrix4D matrix4D2 = Transformation4D.Translation(printArea.Center.X, printArea.Center.Y, 0.0) * Transformation4D.Scaling(s) * matrix4D1 * Transformation4D.Translation(-layoutViewport.Center.X, -layoutViewport.Center.Y, 0.0); WW.Math.Point3D point3D1 = matrix4D2.Transform(new WW.Math.Point3D(layoutViewport.Corner1, 0.0)); WW.Math.Point3D point3D2 = matrix4D2.Transform(new WW.Math.Point3D(layoutViewport.Corner2, 0.0)); return(new DxfLayout.PlotInfo(this, new Size2D(paperWidth, paperHeight), new Rectangle2D(System.Math.Min(point3D1.X, point3D2.X), System.Math.Min(point3D1.Y, point3D2.Y), System.Math.Max(point3D1.X, point3D2.X), System.Math.Max(point3D1.Y, point3D2.Y)), matrix4D2 * layoutRenderInfo.ModelToLayoutTransform, s * layoutRenderInfo.ModelToLayoutScaling)); }
public override void TransformMe( TransformConfig config, Matrix4D matrix, CommandGroup undoGroup) { // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type DxfInsertBase.Class476 class476 = new DxfInsertBase.Class476(); // ISSUE: reference to a compiler-generated field class476.dxfInsertBase_0 = this; // ISSUE: reference to a compiler-generated field class476.vector3D_0 = this.vector3D_0; // ISSUE: reference to a compiler-generated field class476.point3D_0 = this.insertionPoint; // ISSUE: reference to a compiler-generated field class476.double_0 = this.rotation; // ISSUE: reference to a compiler-generated field class476.vector3D_1 = this.scaleFactor; this.vector3D_0 = matrix.Transform(this.ZAxis).GetUnit(); Matrix4D inverse = DxfUtil.GetToWCSTransform(this.ZAxis).GetInverse(); // ISSUE: reference to a compiler-generated field Matrix4D toWcsTransform = DxfUtil.GetToWCSTransform(class476.vector3D_0); // ISSUE: reference to a compiler-generated field this.insertionPoint = inverse.Transform(matrix.Transform(toWcsTransform.Transform(class476.point3D_0))); // ISSUE: reference to a compiler-generated field Vector3D vector3D = inverse.Transform(matrix.Transform(toWcsTransform.Transform(Transformation4D.RotateZ(class476.double_0).Transform(Vector3D.XAxis)))); this.rotation = System.Math.Atan2(vector3D.Y, vector3D.X); if (this.Rotation < 0.0) { this.Rotation += 2.0 * System.Math.PI; } // ISSUE: reference to a compiler-generated field // ISSUE: reference to a compiler-generated field this.scaleFactor = Transformation4D.RotateZ(-this.Rotation).Transform(inverse.Transform(matrix.Transform(toWcsTransform.Transform(Transformation4D.RotateZ(class476.double_0).Transform(class476.vector3D_1))))); CommandGroup undoGroup1 = (CommandGroup)null; if (undoGroup != null) { // ISSUE: object of a compiler-generated type is created // ISSUE: variable of a compiler-generated type DxfInsertBase.Class477 class477 = new DxfInsertBase.Class477(); // ISSUE: reference to a compiler-generated field class477.class476_0 = class476; undoGroup1 = new CommandGroup((object)this); undoGroup.UndoStack.Push((ICommand)undoGroup1); // ISSUE: reference to a compiler-generated field class477.vector3D_0 = this.vector3D_0; // ISSUE: reference to a compiler-generated field class477.point3D_0 = this.insertionPoint; // ISSUE: reference to a compiler-generated field class477.double_0 = this.rotation; // ISSUE: reference to a compiler-generated field class477.vector3D_1 = this.scaleFactor; // ISSUE: reference to a compiler-generated method // ISSUE: reference to a compiler-generated method undoGroup1.UndoStack.Push((ICommand) new Command((object)this, new System.Action(class477.method_0), new System.Action(class476.method_0))); } foreach (DxfEntity dxfEntity in (DxfHandledObjectCollection <DxfAttribute>) this.activeDxfHandledObjectCollection_0) { dxfEntity.TransformMe(config, matrix, undoGroup1); } }
internal Bounds3D method_1(DxfTable table) { DxfBlock valueObject = this.ValueObject as DxfBlock; if (valueObject == null) { return((Bounds3D)null); } DxfInsert dxfInsert = new DxfInsert(valueObject); foreach (DxfTableAttribute dxfTableAttribute in (List <DxfTableAttribute>) this.dxfTableAttributeCollection_0) { if (dxfTableAttribute.AttributeDefinition != null) { DxfAttribute dxfAttribute1 = new DxfAttribute(dxfTableAttribute.AttributeDefinition); dxfAttribute1.Text = dxfTableAttribute.Value; DxfAttribute dxfAttribute2 = dxfAttribute1; dxfAttribute2.AlignmentPoint1 = dxfAttribute2.AlignmentPoint1 - valueObject.BasePoint; if (dxfAttribute1.AlignmentPoint2.HasValue) { DxfAttribute dxfAttribute3 = dxfAttribute1; WW.Math.Point3D? alignmentPoint2 = dxfAttribute3.AlignmentPoint2; WW.Math.Vector3D basePoint = valueObject.BasePoint; dxfAttribute3.AlignmentPoint2 = alignmentPoint2.HasValue ? new WW.Math.Point3D?(alignmentPoint2.GetValueOrDefault() - basePoint) : new WW.Math.Point3D?(); } } } BoundsCalculator boundsCalculator = new BoundsCalculator(); boundsCalculator.GetBounds(table.Content.Model, (DxfEntity)dxfInsert); Bounds3D bounds = boundsCalculator.Bounds; Matrix4D transform = Transformation4D.Translation(valueObject.BasePoint) * Transformation4D.RotateZ(this.dxfContentFormat_0.Rotation) * Transformation4D.Translation(-valueObject.BasePoint); bounds.Transform(transform); return(bounds); }
internal void method_0( DxfTableContent tableContent, double width, double height, double rotation, double horizontalMargin, double verticalMargin) { DxfBlock valueObject = this.ValueObject as DxfBlock; if (valueObject == null) { this.dxfContentFormat_0.method_6(1.0); } else { DxfInsert dxfInsert = new DxfInsert(valueObject); foreach (DxfTableAttribute dxfTableAttribute in (List <DxfTableAttribute>) this.dxfTableAttributeCollection_0) { if (dxfTableAttribute.AttributeDefinition != null) { DxfAttribute dxfAttribute1 = new DxfAttribute(dxfTableAttribute.AttributeDefinition); dxfAttribute1.Text = dxfTableAttribute.Value; DxfAttribute dxfAttribute2 = dxfAttribute1; dxfAttribute2.AlignmentPoint1 = dxfAttribute2.AlignmentPoint1 - valueObject.BasePoint; if (dxfAttribute1.AlignmentPoint2.HasValue) { DxfAttribute dxfAttribute3 = dxfAttribute1; WW.Math.Point3D? alignmentPoint2 = dxfAttribute3.AlignmentPoint2; WW.Math.Vector3D basePoint = valueObject.BasePoint; dxfAttribute3.AlignmentPoint2 = alignmentPoint2.HasValue ? new WW.Math.Point3D?(alignmentPoint2.GetValueOrDefault() - basePoint) : new WW.Math.Point3D?(); } } } BoundsCalculator boundsCalculator = new BoundsCalculator(); boundsCalculator.GetBounds(tableContent.Model, (DxfEntity)dxfInsert); Bounds3D bounds = boundsCalculator.Bounds; Matrix4D transform = Transformation4D.Translation(valueObject.BasePoint) * Transformation4D.RotateZ(rotation) * Transformation4D.Translation(-valueObject.BasePoint); bounds.Transform(transform); Vector2D vector2D = new Vector2D((width - 2.0 * horizontalMargin) / bounds.Delta.X, (height - 2.0 * verticalMargin) / bounds.Delta.Y); this.dxfContentFormat_0.BlockScale = System.Math.Min(vector2D.X, vector2D.Y); } }