internal TexturePaintContext(ColorModel cm, AffineTransform xform, int bWidth, int bHeight, int maxw)
        {
            this.ColorModel_Renamed = GetInternedColorModel(cm);
            this.BWidth             = bWidth;
            this.BHeight            = bHeight;
            this.MaxWidth           = maxw;

            try
            {
                xform = xform.CreateInverse();
            }
            catch (NoninvertibleTransformException)
            {
                xform.SetToScale(0, 0);
            }
            this.IncXAcross = Mod(xform.ScaleX, bWidth);
            this.IncYAcross = Mod(xform.ShearY, bHeight);
            this.IncXDown   = Mod(xform.ShearX, bWidth);
            this.IncYDown   = Mod(xform.ScaleY, bHeight);
            this.XOrg       = xform.TranslateX;
            this.YOrg       = xform.TranslateY;
            this.Colincx    = (int)IncXAcross;
            this.Colincy    = (int)IncYAcross;
            this.Colincxerr = FractAsInt(IncXAcross);
            this.Colincyerr = FractAsInt(IncYAcross);
            this.Rowincx    = (int)IncXDown;
            this.Rowincy    = (int)IncYDown;
            this.Rowincxerr = FractAsInt(IncXDown);
            this.Rowincyerr = FractAsInt(IncYDown);
        }
示例#2
0
        public override void DrawBackground(DrawContext drawContext)
        {
            PdfCanvas canvas = drawContext.GetCanvas();
            Matrix    ctm    = canvas.GetGraphicsState().GetCtm();
            // Avoid rotation
            float?angle         = this.GetPropertyAsFloat(Property.ROTATION_ANGLE);
            bool  avoidRotation = null != angle && null != this.GetProperty <Background>(Property.BACKGROUND);

            if (avoidRotation)
            {
                AffineTransform transform = new AffineTransform(ctm.Get(0), ctm.Get(1), ctm.Get(3), ctm.Get(4), ctm.Get(6)
                                                                , ctm.Get(7));
                try {
                    transform = transform.CreateInverse();
                }
                catch (NoninvertibleTransformException e) {
                    throw new Exception(e.Message, e);
                }
                transform.Concatenate(new AffineTransform());
                canvas.ConcatMatrix(transform);
                DeleteProperty(Property.ROTATION_ANGLE);
            }
            base.DrawBackground(drawContext);
            // restore concat matrix and rotation angle
            if (avoidRotation)
            {
                SetProperty(Property.ROTATION_ANGLE, angle);
                canvas.ConcatMatrix(new AffineTransform(ctm.Get(0), ctm.Get(1), ctm.Get(3), ctm.Get(4), ctm.Get(6), ctm.Get
                                                            (7)));
            }
        }
示例#3
0
 private Point[] TransformPoints(Matrix transformationMatrix, params Point[] points)
 {
     try {
         AffineTransform t = new AffineTransform(transformationMatrix.Get(Matrix.I11), transformationMatrix.Get(Matrix
                                                                                                                .I12), transformationMatrix.Get(Matrix.I21), transformationMatrix.Get(Matrix.I22), transformationMatrix
                                                 .Get(Matrix.I31), transformationMatrix.Get(Matrix.I32));
         t = t.CreateInverse();
         Point[] transformed = new Point[points.Length];
         t.Transform(points, 0, transformed, 0, points.Length);
         return(transformed);
     }
     catch (NoninvertibleTransformException e) {
         throw new Exception(e.Message, e);
     }
 }
        private Point2D[] TransformPoints(Matrix transormationMatrix, bool inverse, params Point2D[] points)
        {
            AffineTransform t = new AffineTransform(transormationMatrix[Matrix.I11], transormationMatrix[Matrix.I12],
                                                    transormationMatrix[Matrix.I21], transormationMatrix[Matrix.I22],
                                                    transormationMatrix[Matrix.I31], transormationMatrix[Matrix.I32]);

            Point2D[] transformed = new Point2D[points.Length];

            if (inverse)
            {
                t = t.CreateInverse();
            }

            t.Transform(points, 0, transformed, 0, points.Length);

            return(transformed);
        }
            private Point[] TransformPoints(Matrix transformationMatrix, bool inverse, params Point[] points)
            {
                AffineTransform t = new AffineTransform(transformationMatrix.Get(Matrix.I11), transformationMatrix.Get(Matrix
                                                                                                                       .I12), transformationMatrix.Get(Matrix.I21), transformationMatrix.Get(Matrix.I22), transformationMatrix
                                                        .Get(Matrix.I31), transformationMatrix.Get(Matrix.I32));

                Point[] transformed = new Point[points.Length];
                if (inverse)
                {
                    try {
                        t = t.CreateInverse();
                    }
                    catch (NoninvertibleTransformException e) {
                        throw new PdfException(CleanupExceptionMessageConstant.NONINVERTIBLE_MATRIX_CANNOT_BE_PROCESSED, e);
                    }
                }
                t.Transform(points, 0, transformed, 0, points.Length);
                return(transformed);
            }
示例#6
0
        /// <summary>
        /// When in the svg element
        /// <c>overflow</c>
        /// is
        /// <c>visible</c>
        /// the corresponding formXObject
        /// should have a BBox (form XObject’s bounding box; see PDF 32000-1:2008 - 8.10.2 Form Dictionaries)
        /// that should cover the entire svg space (page in pdf) in order to be able to show parts of the element which are outside the current element viewPort.
        /// </summary>
        /// <remarks>
        /// When in the svg element
        /// <c>overflow</c>
        /// is
        /// <c>visible</c>
        /// the corresponding formXObject
        /// should have a BBox (form XObject’s bounding box; see PDF 32000-1:2008 - 8.10.2 Form Dictionaries)
        /// that should cover the entire svg space (page in pdf) in order to be able to show parts of the element which are outside the current element viewPort.
        /// To do this, we get the inverse matrix of all the current transformation matrix changes and apply it to the root viewPort.
        /// This allows you to get the root rectangle in the final coordinate system.
        /// </remarks>
        /// <param name="context">current context to get canvases and view ports</param>
        /// <param name="stream">stream to write a BBox</param>
        private static void WriteBBoxAccordingToVisibleOverflow(SvgDrawContext context, PdfStream stream)
        {
            IList <PdfCanvas> canvases = new List <PdfCanvas>();
            int canvasesSize           = context.Size();

            for (int i = 0; i < canvasesSize; i++)
            {
                canvases.Add(context.PopCanvas());
            }
            AffineTransform transform = new AffineTransform();

            for (int i = canvases.Count - 1; i >= 0; i--)
            {
                PdfCanvas canvas = canvases[i];
                Matrix    matrix = canvas.GetGraphicsState().GetCtm();
                transform.Concatenate(new AffineTransform(matrix.Get(0), matrix.Get(1), matrix.Get(3), matrix.Get(4), matrix
                                                          .Get(6), matrix.Get(7)));
                context.PushCanvas(canvas);
            }
            try {
                transform = transform.CreateInverse();
            }
            catch (NoninvertibleTransformException) {
                // Case with zero determiner (see PDF 32000-1:2008 - 8.3.4 Transformation Matrices - NOTE 3)
                // for example with a, b, c, d in cm equal to 0
                stream.Put(PdfName.BBox, new PdfArray(new Rectangle(0, 0, 0, 0)));
                ILog logger = LogManager.GetLogger(typeof(AbstractBranchSvgNodeRenderer));
                logger.Warn(SvgLogMessageConstant.UNABLE_TO_GET_INVERSE_MATRIX_DUE_TO_ZERO_DETERMINANT);
                return;
            }
            Point[] points = context.GetRootViewPort().ToPointsArray();
            transform.Transform(points, 0, points, 0, points.Length);
            Rectangle bbox = Rectangle.CalculateBBox(JavaUtil.ArraysAsList(points));

            stream.Put(PdfName.BBox, new PdfArray(bbox));
        }
示例#7
0
 protected internal override void DoDraw(SvgDrawContext context)
 {
     if (this.attributesAndStyles != null)
     {
         String elementToReUse = this.attributesAndStyles.Get(SvgConstants.Attributes.XLINK_HREF);
         if (elementToReUse == null)
         {
             elementToReUse = this.attributesAndStyles.Get(SvgConstants.Attributes.HREF);
         }
         if (elementToReUse != null && !String.IsNullOrEmpty(elementToReUse) && IsValidHref(elementToReUse))
         {
             String normalizedName = SvgTextUtil.FilterReferenceValue(elementToReUse);
             if (!context.IsIdUsedByUseTagBefore(normalizedName))
             {
                 ISvgNodeRenderer template = context.GetNamedObject(normalizedName);
                 //Clone template
                 ISvgNodeRenderer namedObject = template == null ? null : template.CreateDeepCopy();
                 //Resolve parent inheritance
                 SvgNodeRendererInheritanceResolver iresolver = new SvgNodeRendererInheritanceResolver();
                 iresolver.ApplyInheritanceToSubTree(this, namedObject);
                 if (namedObject != null)
                 {
                     if (namedObject is AbstractSvgNodeRenderer)
                     {
                         ((AbstractSvgNodeRenderer)namedObject).SetPartOfClipPath(partOfClipPath);
                     }
                     PdfCanvas currentCanvas = context.GetCurrentCanvas();
                     float     x             = 0f;
                     float     y             = 0f;
                     if (this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.X))
                     {
                         x = CssUtils.ParseAbsoluteLength(this.attributesAndStyles.Get(SvgConstants.Attributes.X));
                     }
                     if (this.attributesAndStyles.ContainsKey(SvgConstants.Attributes.Y))
                     {
                         y = CssUtils.ParseAbsoluteLength(this.attributesAndStyles.Get(SvgConstants.Attributes.Y));
                     }
                     AffineTransform inverseMatrix = null;
                     if (!CssUtils.CompareFloats(x, 0) || !CssUtils.CompareFloats(y, 0))
                     {
                         AffineTransform translation = AffineTransform.GetTranslateInstance(x, y);
                         currentCanvas.ConcatMatrix(translation);
                         if (partOfClipPath)
                         {
                             try {
                                 inverseMatrix = translation.CreateInverse();
                             }
                             catch (NoninvertibleTransformException ex) {
                                 LogManager.GetLogger(typeof(UseSvgNodeRenderer)).Warn(SvgLogMessageConstant.NONINVERTIBLE_TRANSFORMATION_MATRIX_USED_IN_CLIP_PATH
                                                                                       , ex);
                             }
                         }
                     }
                     // setting the parent of the referenced element to this instance
                     namedObject.SetParent(this);
                     namedObject.Draw(context);
                     // unsetting the parent of the referenced element
                     namedObject.SetParent(null);
                     if (inverseMatrix != null)
                     {
                         currentCanvas.ConcatMatrix(inverseMatrix);
                     }
                 }
             }
         }
     }
 }
        public GradientPaintContext(ColorModel cm, Point2D p1, Point2D p2, AffineTransform xform, Color c1, Color c2, bool cyclic)
        {
            // First calculate the distance moved in user space when
            // we move a single unit along the X & Y axes in device space.
            Point2D xvec = new Point2D.Double(1, 0);
            Point2D yvec = new Point2D.Double(0, 1);

            try
            {
                AffineTransform inverse = xform.CreateInverse();
                inverse.DeltaTransform(xvec, xvec);
                inverse.DeltaTransform(yvec, yvec);
            }
            catch (NoninvertibleTransformException)
            {
                xvec.SetLocation(0, 0);
                yvec.SetLocation(0, 0);
            }

            // Now calculate the (square of the) user space distance
            // between the anchor points. This value equals:
            //     (UserVec . UserVec)
            double udx    = p2.X - p1.X;
            double udy    = p2.Y - p1.Y;
            double ulenSq = udx * udx + udy * udy;

            if (ulenSq <= Double.Epsilon)
            {
                Dx = 0;
                Dy = 0;
            }
            else
            {
                // Now calculate the proportional distance moved along the
                // vector from p1 to p2 when we move a unit along X & Y in
                // device space.
                //
                // The length of the projection of the Device Axis Vector is
                // its dot product with the Unit User Vector:
                //     (DevAxisVec . (UserVec / Len(UserVec))
                //
                // The "proportional" length is that length divided again
                // by the length of the User Vector:
                //     (DevAxisVec . (UserVec / Len(UserVec))) / Len(UserVec)
                // which simplifies to:
                //     ((DevAxisVec . UserVec) / Len(UserVec)) / Len(UserVec)
                // which simplifies to:
                //     (DevAxisVec . UserVec) / LenSquared(UserVec)
                Dx = (xvec.X * udx + xvec.Y * udy) / ulenSq;
                Dy = (yvec.X * udx + yvec.Y * udy) / ulenSq;

                if (cyclic)
                {
                    Dx = Dx % 1.0;
                    Dy = Dy % 1.0;
                }
                else
                {
                    // We are acyclic
                    if (Dx < 0)
                    {
                        // If we are using the acyclic form below, we need
                        // dx to be non-negative for simplicity of scanning
                        // across the scan lines for the transition points.
                        // To ensure that constraint, we negate the dx/dy
                        // values and swap the points and colors.
                        Point2D p = p1;
                        p1 = p2;
                        p2 = p;
                        Color c = c1;
                        c1 = c2;
                        c2 = c;
                        Dx = -Dx;
                        Dy = -Dy;
                    }
                }
            }

            Point2D dp1 = xform.Transform(p1, null);

            this.X1 = dp1.X;
            this.Y1 = dp1.Y;

            this.Cyclic = cyclic;
            int rgb1 = c1.RGB;
            int rgb2 = c2.RGB;
            int a1   = (rgb1 >> 24) & 0xff;
            int r1   = (rgb1 >> 16) & 0xff;
            int g1   = (rgb1 >> 8) & 0xff;
            int b1   = (rgb1) & 0xff;
            int da   = ((rgb2 >> 24) & 0xff) - a1;
            int dr   = ((rgb2 >> 16) & 0xff) - r1;
            int dg   = ((rgb2 >> 8) & 0xff) - g1;
            int db   = ((rgb2) & 0xff) - b1;

            if (a1 == 0xff && da == 0)
            {
                Model = Xrgbmodel;
                if (cm is DirectColorModel)
                {
                    DirectColorModel dcm = (DirectColorModel)cm;
                    int tmp = dcm.AlphaMask;
                    if ((tmp == 0 || tmp == 0xff) && dcm.RedMask == 0xff && dcm.GreenMask == 0xff00 && dcm.BlueMask == 0xff0000)
                    {
                        Model = Xbgrmodel;
                        tmp   = r1;
                        r1    = b1;
                        b1    = tmp;
                        tmp   = dr;
                        dr    = db;
                        db    = tmp;
                    }
                }
            }
            else
            {
                Model = ColorModel.RGBdefault;
            }
            Interp = new int[cyclic ? 513 : 257];
            for (int i = 0; i <= 256; i++)
            {
                float rel = i / 256.0f;
                int   rgb = (((int)(a1 + da * rel)) << 24) | (((int)(r1 + dr * rel)) << 16) | (((int)(g1 + dg * rel)) << 8) | (((int)(b1 + db * rel)));
                Interp[i] = rgb;
                if (cyclic)
                {
                    Interp[512 - i] = rgb;
                }
            }
        }