How To Install New Canvas On Pop Up
node-sail
node-canvas is a Cairo-backed Canvas implementation for Node.js.
Installation
By default, binaries for macOS, Linux and Windows volition be downloaded. If you want to build from source, use npm install --build-from-source and run across the Compiling section below.
The minimum version of Node.js required is six.0.0.
Compiling
If yous don't have a supported OS or processor architecture, or you use --build-from-source, the module will exist compiled on your arrangement. This requires several dependencies, including Cairo and Pango.
For detailed installation information, see the wiki. Ane-line installation instructions for common OSes are beneath. Note that libgif/giflib, librsvg and libjpeg are optional and only required if you need GIF, SVG and JPEG support, respectively. Cairo v1.10.0 or later is required.
| Os | Command |
|---|---|
| OS X | Using Homebrew:brew install pkg-config cairo pango libpng jpeg giflib librsvg |
| Ubuntu | sudo apt-get install build-essential libcairo2-dev libpango1.0-dev libjpeg-dev libgif-dev librsvg2-dev |
| Fedora | sudo yum install gcc-c++ cairo-devel pango-devel libjpeg-turbo-devel giflib-devel |
| Solaris | pkgin install cairo pango pkg-config xproto renderproto kbproto xextproto |
| OpenBSD | doas pkg_add cairo pango png jpeg giflib |
| Windows | Run across the wiki |
| Others | Meet the wiki |
Mac Os X v10.11+: If you have recently updated to Mac OS X v10.11+ and are experiencing trouble when compiling, run the post-obit command: xcode-select --install. Read more about the problem on Stack Overflow. If you lot have xcode x.0 or college installed, in order to build from source you lot demand NPM 6.4.1 or higher.
Quick Case
const { createCanvas, loadImage } = crave ( 'sheet' ) const canvas = createCanvas ( 200 , 200 ) const ctx = canvas . getContext ( '2d' ) // Write "Crawly!" ctx . font = '30px Impact' ctx . rotate ( 0.1 ) ctx . fillText ( 'Awesome!' , 50 , 100 ) // Describe line nether text var text = ctx . measureText ( 'Awesome!' ) ctx . strokeStyle = 'rgba(0,0,0,0.five)' ctx . beginPath ( ) ctx . lineTo ( l , 102 ) ctx . lineTo ( 50 + text . width , 102 ) ctx . stroke ( ) // Draw cat with lime helmet loadImage ( 'examples/images/lime-cat.jpg' ) . and so ( ( image ) => { ctx . drawImage ( image , 50 , 0 , 70 , seventy ) console . log ( '<img src="' + canvas . toDataURL ( ) + '" />' ) } ) Upgrading from 1.x to 2.10
See the changelog for a guide to upgrading from 1.10 to 2.x.
For version 1.10 documentation, see the v1.x co-operative.
Documentation
This project is an implementation of the Web Canvas API and implements that API as closely equally possible. For API documentation, delight visit Mozilla Web Canvass API. (See Compatibility Status for the current API compliance.) All utility methods and not-standard APIs are documented below.
Utility methods
- createCanvas()
- createImageData()
- loadImage()
- registerFont()
Not-standard APIs
- Prototype#src
- Image#dataMode
- Canvas#toBuffer()
- Canvas#createPNGStream()
- Canvas#createJPEGStream()
- Canvas#createPDFStream()
- Sail#toDataURL()
- CanvasRenderingContext2D#patternQuality
- CanvasRenderingContext2D#quality
- CanvasRenderingContext2D#textDrawingMode
- CanvasRenderingContext2D#globalCompositeOperator = 'saturate'
- CanvasRenderingContext2D#antialias
createCanvas()
createCanvas ( width: number , peak: number , type?: 'PDF' | 'SVG' ) => Sheet
Creates a Canvas example. This method works in both Node.js and Web browsers, where there is no Sail constructor. (See browser.js for the implementation that runs in browsers.)
const { createCanvas } = require ( 'sail' ) const mycanvas = createCanvas ( 200 , 200 ) const myPDFcanvas = createCanvas ( 600 , 800 , 'pdf' ) // see "PDF Support" department createImageData()
createImageData ( width: number , height: number ) => ImageData createImageData ( information: Uint8ClampedArray , width: number , superlative?: number ) => ImageData // for culling pixel formats: createImageData ( data: Uint16Array , width: number , peak?: number ) => ImageData
Creates an ImageData example. This method works in both Node.js and Web browsers.
const { createImageData } = require ( 'canvas' ) const width = 20 , height = 20 const arraySize = width * height * four const mydata = createImageData ( new Uint8ClampedArray ( arraySize ) , width ) loadImage()
loadImage ( ) => Promise < Image >
Convenience method for loading images. This method works in both Node.js and Web browsers.
const { loadImage } = require ( 'canvas' ) const myimg = loadImage ( 'http://server.com/paradigm.png' ) myimg . then ( ( ) => { // do something with prototype } ) . catch ( err => { panel . log ( 'oh no!' , err ) } ) // or with async/await: const myimg = await loadImage ( 'http://server.com/image.png' ) // practice something with image registerFont()
registerFont ( path: cord , { family: string , weight?: cord , way?: string } ) => void
To use a font file that is not installed equally a organization font, use registerFont() to register the font with Sheet. This must be done before the Canvass is created.
const { registerFont, createCanvas } = crave ( 'canvas' ) registerFont ( 'comicsans.ttf' , { family: 'Comic Sans' } ) const canvas = createCanvas ( 500 , 500 ) const ctx = sail . getContext ( '2nd' ) ctx . font = '12px "Comic Sans"' ctx . fillText ( 'Everyone hates this font :(' , 250 , 10 ) The 2nd argument is an object with properties that resemble the CSS properties that are specified in @font-face rules. You must specify at least family. weight, and manner are optional and default to 'normal'.
Paradigm#src
Every bit in browsers, img.src can be ready to a data: URI or a remote URL. In addition, node-canvas allows setting src to a local file path or Buffer instance.
const { Image } = require ( 'sheet' ) // From a buffer: fs . readFile ( 'images/squid.png' , ( err , squid ) => { if ( err ) throw err const img = new Image ( ) img . onload = ( ) => ctx . drawImage ( img , 0 , 0 ) img . onerror = err => { throw err } img . src = squid } ) // From a local file path: const img = new Paradigm ( ) img . onload = ( ) => ctx . drawImage ( img , 0 , 0 ) img . onerror = err => { throw err } img . src = 'images/squid.png' // From a remote URL: img . src = 'http://picsum.photos/200/300' // ... every bit higher up // From a `information:` URI: img . src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg==' // ... equally above Note: In some cases, img.src= is currently synchronous. Still, you should always use img.onload and img.onerror, as nosotros intend to make img.src= always asynchronous as information technology is in browsers. Encounter https://github.com/Automattic/node-sheet/issues/1007.
Epitome#dataMode
Applies to JPEG images fatigued to PDF canvases only.
Setting img.dataMode = Image.MODE_MIME or Image.MODE_MIME|Prototype.MODE_IMAGE enables MIME information tracking of images. When MIME data is tracked, PDF canvases tin embed JPEGs straight into the output, rather than re-encoding into PNG. This can drastically reduce filesize and speed up rendering.
const { Image, createCanvas } = require ( 'canvas' ) const sail = createCanvas ( w , h , 'pdf' ) const img = new Image ( ) img . dataMode = Epitome . MODE_IMAGE // Merely image data tracked img . dataMode = Prototype . MODE_MIME // Simply mime data tracked img . dataMode = Image . MODE_MIME | Prototype . MODE_IMAGE // Both are tracked If working with a non-PDF sail, image data must be tracked; otherwise the output will exist junk.
Enabling mime data tracking has no benefits (only a ho-hum down) unless you lot are generating a PDF.
Canvas#toBuffer()
canvas . toBuffer ( ( err: Fault | null , result: Buffer ) => void , mimeType?: string , config?: any ) => void sheet . toBuffer ( mimeType?: cord , config?: any ) => Buffer
Creates a Buffer object representing the image contained in the canvas.
- callback If provided, the buffer will exist provided in the callback instead of being returned by the function. Invoked with an mistake as the commencement argument if encoding failed, or the resulting buffer as the 2d argument if it succeeded. Not supported for mimeType
rawor for PDF or SVG canvases. - mimeType A string indicating the paradigm format. Valid options are
image/png,image/jpeg(if node-canvas was built with JPEG support),raw(unencoded information in BGRA guild on little-endian (most) systems, ARGB on big-endian systems; height-to-bottom),application/pdf(for PDF canvases) andimage/svg+xml(for SVG canvases). Defaults toimage/pngfor image canvases, or the respective type for PDF or SVG canvas. - config
-
For
image/jpeg, an object specifying the quality (0 to 1), if progressive compression should be used and/or if chroma subsampling should be used:{quality: 0.75, progressive: false, chromaSubsampling: true}. All backdrop are optional. -
For
image/png, an object specifying the ZLIB compression level (betwixt 0 and nine), the compression filter(s), the palette (indexed PNGs only), the the background palette alphabetize (indexed PNGs merely) and/or the resolution (ppi):{compressionLevel: half-dozen, filters: canvas.PNG_ALL_FILTERS, palette: undefined, backgroundIndex: 0, resolution: undefined}. All properties are optional.Notation that the PNG format encodes the resolution in pixels per meter, so if yous specify
96, the file will encode 3780 ppm (~96.01 ppi). The resolution is undefined by default to match common browser behavior. -
For
application/pdf, an object specifying optional document metadata:{title: string, writer: string, subject field: string, keywords: string, creator: string, creationDate: Date, modDate: Date}. All properties are optional and default toundefined, except forcreationDate, which defaults to the electric current date. Adding metadata requires Cairo one.16.0 or later.For a clarification of these backdrop, see page 550 of PDF 32000-1:2008.
Note that there is no standard separator for
keywords. A infinite is recommended because information technology is in common apply by other applications, and Cairo will enclose the listing of keywords in quotes if a comma or semicolon is used.
-
Return value
If no callback is provided, a Buffer. If a callback is provided, none.
Examples
// Default: buf contains a PNG-encoded image const buf = canvass . toBuffer ( ) // PNG-encoded, zlib compression level 3 for faster compression but bigger files, no filtering const buf2 = canvass . toBuffer ( 'epitome/png' , { compressionLevel: 3 , filters: canvas . PNG_FILTER_NONE } ) // JPEG-encoded, 50% quality const buf3 = canvas . toBuffer ( 'image/jpeg' , { quality: 0.5 } ) // Asynchronous PNG canvas . toBuffer ( ( err , buf ) => { if ( err ) throw err // encoding failed // buf is PNG-encoded image } ) canvas . toBuffer ( ( err , buf ) => { if ( err ) throw err // encoding failed // buf is JPEG-encoded prototype at 95% quality } , 'epitome/jpeg' , { quality: 0.95 } ) // BGRA pixel values, native-endian const buf4 = canvas . toBuffer ( 'raw' ) const { stride, width } = canvas // In memory, this is `canvas.tiptop * canvas.pace` bytes long. // The top row of pixels, in BGRA society on fiddling-endian hardware, // left-to-right, is: const topPixelsBGRALeftToRight = buf4 . slice ( 0 , width * iv ) // And the third row is: const row3 = buf4 . slice ( 2 * stride , 2 * stride + width * 4 ) // SVG and PDF canvases const myCanvas = createCanvas ( w , h , 'pdf' ) myCanvas . toBuffer ( ) // returns a buffer containing a PDF-encoded canvas // With optional metadata: myCanvas . toBuffer ( 'application/pdf' , { title: 'my film' , keywords: 'node.js demo cairo' , creationDate: new Date ( ) } ) Canvas#createPNGStream()
canvas . createPNGStream ( config?: any ) => ReadableStream
Creates a ReadableStream that emits PNG-encoded information.
-
configAn object specifying the ZLIB compression level (between 0 and 9), the compression filter(s), the palette (indexed PNGs simply) and/or the background palette index (indexed PNGs just):{compressionLevel: 6, filters: canvas.PNG_ALL_FILTERS, palette: undefined, backgroundIndex: 0, resolution: undefined}. All backdrop are optional.
Examples
const fs = require ( 'fs' ) const out = fs . createWriteStream ( __dirname + '/test.png' ) const stream = canvas . createPNGStream ( ) stream . pipage ( out ) out . on ( 'end' , ( ) => panel . log ( 'The PNG file was created.' ) ) To encode indexed PNGs from canvases with pixelFormat: 'A8' or 'A1', provide an options object:
const palette = new Uint8ClampedArray ( [ //r k b a 0 , fifty , 50 , 255 , // index 1 ten , xc , 90 , 255 , // alphabetize 2 127 , 127 , 255 , 255 // ... ] ) sheet . createPNGStream ( { palette: palette , backgroundIndex: 0 // optional, defaults to 0 } ) Canvas#createJPEGStream()
canvass . createJPEGStream ( config?: whatsoever ) => ReadableStream
Creates a ReadableStream that emits JPEG-encoded data.
Note: At the moment, createJPEGStream() is synchronous under the hood. That is, it runs in the main thread, not in the libuv threadpool.
-
configan object specifying the quality (0 to 1), if progressive compression should be used and/or if chroma subsampling should be used:{quality: 0.75, progressive: false, chromaSubsampling: true}. All properties are optional.
Examples
const fs = require ( 'fs' ) const out = fs . createWriteStream ( __dirname + '/test.jpeg' ) const stream = canvas . createJPEGStream ( ) stream . pipe ( out ) out . on ( 'end' , ( ) => console . log ( 'The JPEG file was created.' ) ) // Disable 2x2 chromaSubsampling for deeper colors and apply a higher quality const stream = sail . createJPEGStream ( { quality: 0.95 , chromaSubsampling: false } ) Sail#createPDFStream()
canvas . createPDFStream ( config?: whatsoever ) => ReadableStream
-
configan object specifying optional document metadata:{championship: string, author: string, subject field: cord, keywords: string, creator: string, creationDate: Date, modDate: Date}. SeetoBuffer()for more data. Calculation metadata requires Cairo 1.16.0 or afterward.
Applies to PDF canvases only. Creates a ReadableStream that emits the encoded PDF. canvass.toBuffer() likewise produces an encoded PDF, merely createPDFStream() tin be used to reduce memory usage.
Canvass#toDataURL()
This is a standard API, merely several not-standard calls are supported. The full listing of supported calls is:
dataUrl = canvas . toDataURL ( ) // defaults to PNG dataUrl = canvas . toDataURL ( 'image/png' ) dataUrl = sheet . toDataURL ( 'paradigm/jpeg' ) dataUrl = sail . toDataURL ( 'paradigm/jpeg' , quality ) // quality from 0 to 1 canvas . toDataURL ( ( err , png ) => { } ) // defaults to PNG sail . toDataURL ( 'epitome/png' , ( err , png ) => { } ) canvas . toDataURL ( 'prototype/jpeg' , ( err , jpeg ) => { } ) // sync JPEG is non supported sheet . toDataURL ( 'image/jpeg' , {...opts } , ( err , jpeg ) => { } ) // see Canvas#createJPEGStream for valid options canvas . toDataURL ( 'paradigm/jpeg' , quality , ( err , jpeg ) => { } ) // spec-following; quality from 0 to 1 CanvasRenderingContext2D#patternQuality
context . patternQuality: 'fast' | 'good' | 'best' | 'nearest' | 'bilinear'
Defaults to 'good'. Affects pattern (gradient, image, etc.) rendering quality.
CanvasRenderingContext2D#quality
context . quality: 'fast' | 'good' | 'all-time' | 'nearest' | 'bilinear'
Defaults to 'good'. Like patternQuality, only applies to transformations affecting more than just patterns.
CanvasRenderingContext2D#textDrawingMode
context . textDrawingMode: 'path' | 'glyph'
Defaults to 'path'. The issue depends on the sail type:
-
Standard (paradigm)
glyphandpathboth upshot in rasterized text. Glyph mode is faster thanpath, but may result in lower-quality text, especially when rotated or translated. -
PDF
glyphwill embed text instead of paths into the PDF. This is faster to encode, faster to open with PDF viewers, yields a smaller file size and makes the text selectable. The subset of the font needed to return the glyphs volition be embedded in the PDF. This is usually the style you desire to employ with PDF canvases. -
SVG
glyphdoes not cause<text>elements to be produced as one might expect (cairo issues). Rather,glyphvolition create a<defs>department with a<symbol>for each glyph, then those glyphs be reused via<use>elements.pathstyle creates a<path>element for each text string.glyphmode is faster and yields a smaller file size.
In glyph mode, ctx.strokeText() and ctx.fillText() deport the aforementioned (aside from using the stroke and make full way, respectively).
This holding is tracked every bit role of the canvas state in save/restore.
CanvasRenderingContext2D#globalCompositeOperation = 'saturate'
In addition to all of the standard global composite operations divers by the Sail specification, the 'saturate' functioning is also available.
CanvasRenderingContext2D#antialias
context . antialias: 'default' | 'none' | 'gray' | 'subpixel'
Sets the anti-aliasing style.
PDF Output Support
node-canvas tin create PDF documents instead of images. The canvas blazon must be set when creating the canvas as follows:
const canvas = createCanvas ( 200 , 500 , 'pdf' ) An additional method .addPage() is then available to create multiple folio PDFs:
// On showtime folio ctx . font = '22px Helvetica' ctx . fillText ( 'Hello Earth' , 50 , 80 ) ctx . addPage ( ) // At present on second folio ctx . font = '22px Helvetica' ctx . fillText ( 'Hello Globe 2' , l , 80 ) sail . toBuffer ( ) // returns a PDF file canvas . createPDFStream ( ) // returns a ReadableStream that emits a PDF // With optional document metadata (requires Cairo ane.16.0): canvas . toBuffer ( 'application/pdf' , { championship: 'my picture' , keywords: 'node.js demo cairo' , creationDate: new Date ( ) } ) It is too possible to create pages with different sizes by passing width and height to the .addPage() method:
ctx . font = '22px Helvetica' ctx . fillText ( 'Hello Globe' , 50 , 80 ) ctx . addPage ( 400 , 800 ) ctx . fillText ( 'Hello Earth two' , 50 , 80 ) Meet also:
- Epitome#dataMode for embedding JPEGs in PDFs
- Canvas#createPDFStream() for creating PDF streams
- CanvasRenderingContext2D#textDrawingMode for embedding text instead of paths
SVG Output Support
node-canvass can create SVG documents instead of images. The sail blazon must be set when creating the canvas as follows:
const canvas = createCanvas ( 200 , 500 , 'svg' ) // Employ the normal primitives. fs . writeFileSync ( 'out.svg' , canvas . toBuffer ( ) ) SVG Image Support
If librsvg is available when node-canvas is installed, node-canvass can render SVG images to your canvas context. This currently works by rasterizing the SVG epitome (i.eastward. drawing an SVG image to an SVG canvas will not preserve the SVG data).
const img = new Image ( ) img . onload = ( ) => ctx . drawImage ( img , 0 , 0 ) img . onerror = err => { throw err } img . src = './example.svg' Image pixel formats (experimental)
node-canvas has experimental support for additional pixel formats, roughly following the Canvas color space proposal.
const canvas = createCanvas ( 200 , 200 ) const ctx = canvas . getContext ( '2d' , { pixelFormat: 'A8' } ) By default, canvases are created in the RGBA32 format, which corresponds to the native HTML Sheet beliefs. Each pixel is 32 $.25. The JavaScript APIs that involve pixel data (getImageData, putImageData) store the colors in the order {red, green, blue, alpha} without alpha pre-multiplication. (The C++ API stores the colors in the order {alpha, red, light-green, blue} in native-endian ordering, with alpha pre-multiplication.)
These additional pixel formats have experimental support:
-
RGB24LikeRGBA32, but the 8 alpha bits are ever opaque. This format is always used if theblastoffcontext attribute is gear up to fake (i.e.canvas.getContext('2d', {alpha: false})). This format can be faster thanRGBA32because transparency does not need to be calculated. -
A8Each pixel is eight $.25. This format can either be used for creating grayscale images (treating each byte as an alpha value), or for creating indexed PNGs (treating each byte as a palette index) (meet the example using alpha values withfillStyleand the instance usingimageData). -
RGB16_565Each pixel is 16 bits, with red in the upper 5 bits, green in the middle 6 bits, and blue in the lower five bits, in native platform endianness. Some hardware devices and frame buffers utilize this format. Notation that PNG does not support this format; when creating a PNG, the image volition be converted to 24-bit RGB. This format is thus suboptimal for generating PNGs.ImageDatainstances for this manner use aUint16Arrayinstead of aUint8ClampedArray. -
A1Each pixel is i flake, and pixels are packed together into 32-bit quantities. The ordering of the $.25 matches the endianness of the platform: on a little-endian car, the first pixel is the least-pregnant fleck. This format can be used for creating unmarried-color images. Support for this format is incomplete, run across note beneath. -
RGB30Each pixel is 30 bits, with red in the upper ten, green in the centre 10, and blue in the lower 10. (Requires Cairo 1.12 or later.) Back up for this format is incomplete, run across note below.
Notes and caveats:
-
Using a not-default format can affect the beliefs of APIs that involve pixel data:
-
context2d.createImageDataThe size of the array returned depends on the number of bit per pixel for the underlying image data format, per the to a higher place descriptions. -
context2d.getImageDataThe format of the assortment returned depends on the underlying image mode, per the higher up descriptions. Exist aware of platform endianness, which tin can exist determined using node.js'southwardos.endianness()function. -
context2d.putImageDataEvery bit above.
-
-
A1andRGB30do not yet supportgetImageDataorputImageData. Have a use case and/or stance on working with these formats? Open an issue and let us know! (See #935.) -
A1,A8,RGB30andRGB16_565with shadow blurs may crash or not render properly. -
The
ImageData(width, peak)andImageData(Uint8ClampedArray, width)constructors presume 4 bytes per pixel. To create anImageDatacase with a dissimilar number of bytes per pixel, usenew ImageData(new Uint8ClampedArray(size), width, height)ornew ImageData(new Uint16ClampedArray(size), width, height).
Testing
First make sure you've built the latest version. Get all the deps you need (see compiling above), and run:
npm install --build-from-source For visual tests: npm run test-server and point your browser to http://localhost:4000.
For unit tests: npm run test.
Benchmarks
Benchmarks live in the benchmarks directory.
Examples
Examples line in the examples directory. Nearly produce a png image of the aforementioned proper noun, and others such as alive-clock.js launch an HTTP server to be viewed in the browser.
Original Authors
- TJ Holowaychuk (tj)
- Nathan Rajlich (TooTallNate)
- Rod Vagg (rvagg)
- Juriy Zaytsev (kangax)
License
node-sheet
(The MIT License)
Copyright (c) 2022 LearnBoost, and contributors <dev@learnboost.com>
Copyright (c) 2022 Automattic, Inc and contributors <dev@automattic.com>
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to bargain in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject area to the following atmospheric condition:
The above copyright observe and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF Whatever KIND, Express OR Implied, INCLUDING Simply Not LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR Any Claim, DAMAGES OR OTHER LIABILITY, WHETHER IN AN Activity OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN Connection WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
BMP parser
Encounter license
Source: https://www.npmjs.com/package/canvas
Posted by: baileyjakfam.blogspot.com
0 Response to "How To Install New Canvas On Pop Up"
Post a Comment