Home
Manual
Packages
Global Index
Keywords
Quick Reference
|
functions in yorz.i -
jpeg_read
|
image = jpeg_read(filename)
or image = jpeg_read(filename, comments)
or shape = jpeg_read(filename, comments, [0,0,0,0])
or image = jpeg_read(filename, comments, subset)
Read jpeg file FILENAME. The returned IMAGE is 3-by-width-by-height
for rgb images (the usual case) or just width-by-height for grayscale
images. Note that the scanline order is top-to-bottom.
If COMMENTS is present, it must be a simple variable reference.
That variable will be set to either nil or a string array containing
all the descriptive comments in the file.
In the third form, the return value is [nchan,width,height] instead
of the image, where nchan=1 or nchan=3.
In the fourth form, SUBSET is [i0,i1,j0,j1] and the returned image is
the subset full_image(..,i0:i1,j0:j1) of the full image. (This is
inefficient, but, for example, some Mars Rover pictures released by
NASA are inconveniently large.)
|
SEE ALSO:
|
jpeg_write
|
jpeg_write
|
jpeg_write, filename, image
or jpeg_write, filename, image, comments, quality
Write jpeg file FILENAME containing IMAGE at the specified QUALITY.
The default QUALITY is 75; the range is from 0 to 100. The IMAGE
can be either 3-by-width-by-height for rgb or width-by-height for
grayscale. Note that scanline order is top-to-bottom.
If COMMENTS is non-nil, it is a string or an array of strings that
will be written as descriptive comments in the jpeg file.
|
SEE ALSO:
|
jpeg_read
|
mpeg_close
|
mpeg_close, mpeg
Close the mpeg file corresponding to the MPEG encoder. Actually,
this merely destroys the reference to the encoder; the file will
remain open until the final reference is destroyed.
|
SEE ALSO:
|
mpeg_create,
mpeg_write,
mpeg_movie
|
mpeg_create
|
mpeg = mpeg_create(filename)
or mpeg = mpeg_create(filename, params)
Create an mpeg-1 movie file FILENAME. Write frames with mpeg_write,
close with mpeg_close. The return value is an mpeg encoder object.
If given, PARAMS is [bit_rate, frame_rate, gop_size, max_b_frames]
which default to [ 400000, 25, 10, 1 ]
The rates are per second, the gop_size is the number of frames
before an I-frame is emitted, and max_b_frames is the largest
number of consecutive B-frames. (The third kind of frame is the
P-frame; generally, the encoder emits B-frames until it is forced
to emit a P-frame by max_b_frames, or an I-frame by gop_size. The
smaller these numbers, the higher quality the movie, but the lower
the compression.) Any of the four PARAMS values may be zero to
get the default value, except for max_b_frames, which should be <0
to get the default value.
|
SEE ALSO:
|
mpeg_write,
mpeg_close,
mpeg_movie
|
mpeg_movie
|
mpeg_movie, filename, draw_frame
or mpeg_movie, filename, draw_frame, time_limit
or mpeg_movie, filename, draw_frame, time_limit, min_interframe
An extension of the movie function (#include "movie.i") that generates
an mpeg file FILENAME. The other arguments are the same as the movie
function (which see). The draw_frame function is:
func draw_frame(i)
{
// Input argument i is the frame number.
// draw_frame should return non-zero if there are more
// frames in this movie. A zero return will stop the
// movie.
// draw_frame must NOT include any fma command if the
// making_movie variable is set (movie sets this variable
// before calling draw_frame)
}
|
SEE ALSO:
|
movie,
mpeg_create,
mpeg_write,
mpeg_close
|
mpeg_write
|
mpeg_write, mpeg, rgb
Write a frame RGB into the mpeg file corresponding to the MPEG
encoder returned by mpeg_create. RGB is a 3-by-width-by-height
array of char. Every frame must have the same width and height.
To finish the movie and close the file, call mpeg_close.
Note that you may have trouble rendering the resulting mpeg
file if the image width and height are note multiples of 8.
|
SEE ALSO:
|
mpeg_create,
mpeg_close,
mpeg_movie
|
png_map
|
image = png_map(full_image, nfo)
maps FULL_IMAGE to png-stored values, according to the
pCAL information in NFO.
The NFO parameter may be either the array of pointers as returned by
png_read, or an array of reals as for *nfo(4) (see png_read).
You can use png_pcal to compute an NFO mapping tailored to IMAGE.
|
SEE ALSO:
|
png_pcal,
png_scale,
png_read,
png_write
|
png_pcal
|
pcal = png_pcal(image)
or pcal = png_pcal(image, depth)
KEYWORDS: cmin=, cmax=, res=, log=
cmin, cmax clip image to these minimum and maximum values
res image "resolution", or minimum step size
log non-zero forces log map if image all positive
or all negative
returns 8-element pCAL png mapping for IMAGE, appropriate for
use as pcal= keyword in png_write. The png_map function applies
pcal to produce the as-stored char or short array; the png_scale
function applies pcal to recreate the original IMAGE from the
as-stored array.
There are three kinds of pCAL mappings: linear, log, and asinh.
Linear and log scales are familiar; the asinh scale is a modified
log scale that can be used for arrays that change sign:
linear: image = a*stored + b
log: image = b * exp(a*stored)
asinh: image = b * sinh(a*(stored - mx/2))
You can specify a bit DEPTH for the stored array, which can be
between 2 and 16 inclusive. For bit depth 1, just threshhold
the image (image>const_thresh). By default, for integer IMAGE,
DEPTH is the smallest depth that covers the range of IMAGE values,
but never more than 16. For float or double IMAGE, the default
DEPTH is always 16.
If IMAGE has any integer data type, the pCAL mapping will always
be linear; use IMAGE+0.0 if you want a log or asinh map.
The png pCAL definition allows b<0 in the log scale, so it can
be used for image values that are either all positive or all
negative. In either case, the integer stored values take equal
ratio steps from the minimum to the maximum image values (or
cmin and cmax). For the linear scale, of course, each step in
the stored integer represents an constant increment in the image
value. The asinh scale is a logarithmic ratio scale for stored
values near 0 or mx (the maximum stored integer value), reverting
to a linear scale near the middle of its range where the image
value passes through zero.
To get the asinh scale, you must specify the res= keyword:
You must specify the smallest step size for the asinh scale by
setting the res= keyword. For a log scale, the res= value will
replace the actual minimum array value or cmin value (or cmax if
image is all negative values), clipping any smaller absolute values.
If mx is large enough to cover the whole scale with the given res=
value in linear steps, a linear scale will be used.
You can specify log=1 to force log scaling if image is all
positive or all negative.
|
SEE ALSO:
|
png_scale,
png_write,
png_read
|
png_read
|
image = png_read(filename)
or image = png_read(filename, depth, nfo)
Read png file FILENAME. The returned IMAGE is either an array
of char or short, unless type= is specified (see below).
The IMAGE may have a leading dimension of 2 if it is gray+alpha,
3 if it is rgb, or 4 if it is rgba.
In the second form, DEPTH and NFO must be simple variable references.
NFO is set to a pointer array to descriptive information by png_read:
*nfo(1) = PLTE 3-by-N char array of palette rgb values
*nfo(2) = tRNS char array of alpha (opacity) values corresponding
to PLTE or single gray or rgb short value (transparent)
*nfo(3) = bKGD single gray or rgb short value
note that bKGD and the single value tRNS have the same
range and meaning as a pixel value, in particular,
for a pseudocolor image, they represent a palette index
*nfo(4) = pCAL [x0,x1,max,eqtype,p0,p1,p2,p3,...] physical pixel value
relation between pixel value and physical value
array of double values (see below for meaning)
*nfo(5) = pCAL [calibration_name, unit_name] string pair
*nfo(6) = sCAL [wide,high,sunit] physical scale of pixels as scanned
or printed, sunit 1.0 for meters or 2.0 for radians
*nfo(7) = pHYs long [n_xpix,n_ypix,per_meter] values
n_xpix,n_ypix are pixels per unit,
per_meter is 0 for aspect ratio only, 1 for meters
*nfo(8) = tEXt (or zTXt or iTXt) 2-by-N string array of (key,text)
*nfo(9) = tIME string value image modification time
any or all of these NFO values may be nil. The four character
designators (e.g. PLTE) are the png chunk names for the corresponding
information.
pCAL array of doubles has following meaning:
max = 2^depth-1
original = long( floor( (image(i)*(x1-x0)+long(max)/2) / max ) ) + x0
image(i) = long( floor( ((original-x0)*max+long(x1-x0)/2) / (x1-x0) ) )
eqtype = 0 physical = p0 + p1*original/(x1-x0)
eqtype = 1 physical = p0 + p1*exp(p2*original/(x1-x0))
eqtype = 2 physical = p0 + p1*p2^(original/(x1-x0))
eqtype = 3 physical = p0 + p1*sinh(p2*(original-p3)/(x1-x0))
If the type= keyword is non-nil and non-zero, the returned value
is as if png_scale(image, nfo, type=type), which scales the raw image
according to the information in pCAL, or is a no-op if pCAL does
not exist.
|
SEE ALSO:
|
png_write,
png_scale
|
png_scale
|
image = png_scale(raw_image, nfo, type=type)
scales RAW_IMAGE to type TYPE (char, short, int, long, float, or
double, according to the pCAL information in NFO. The NFO
parameter may be either the array of pointers returned by
png_read, or an array of reals as for *nfo(4) (see png_read).
|
SEE ALSO:
|
png_map,
png_read,
png_write
|
png_write
|
png_write, filename, image
or png_write, filename, image, depth, nfo
Write png file FILENAME containing IMAGE at the specified DEPTH.
The default DEPTH is 8 bits. For grayscale IMAGE, 1<=DEPTH<=16,
otherwise depth is 8 or 16. If NFO is specified, it is an
array of pointers as described in the help for png_read. You can
optionally specify the same information as keywords:
palette=[[r0,g0,b0],[r1,g1,b1],...]
alpha=[a0,a1,...] if image is simple 2D and palette specified
trns=value if image is gray (no palette)
[r,g,b] if image is color
illegal if image has alpha channel
bkgd=value or [r,g,b] suggested background color
note that bkgd and trns have the same range and meaning as a
pixel value, in particular, for a pseudocolor, a palette index
pcal=[x0,x1,max,eqtype,p0,p1,p2,p3,...]
pcals=[calibration_name, unit_name] as for pCAL (see png_read)
scal=[wide,high,sunit] as for sCAL (see png_read)
phys=[n_xpix,n_ypix,per_meter] as for pHYs (see png_read)
text=[[key1,text1],[key1,text1],...]
recognized keys are: Title, Author, Description, Copyright,
Creation Time, Software, Disclaimer, Warning, Source (a device),
and Comment
time=string modification time (timestamp() is default)
When both NFO and keywords are supplied, the keywords override any
corresponding value in nfo.
If IMAGE has a data type other than short or char, a default pCAL
will be supplied if it is a simple grayscale (2D) image. If DEPTH
is not supplied, it defaults to 8 if IMAGE is type char and/or if
a palette is supplied, or to 16 otherwise.
|
SEE ALSO:
|
png_read,
png_map
|
z_crc32
|
crc32 = z_crc32(crc32, data)
or adler32 = z_crc32(adler32, data, 1)
Compute the crc32 or adler32 checksum of DATA. The first
argument can be [] (nil) if this is the first chunk of DATA;
to checksum a long stream of data you can call z_crc32 on
a series of chunks, feeding the result of each call as input
to the following call.
|
SEE ALSO:
|
z_setdict
|
z_deflate
|
buffer = z_deflate()
or buffer = z_deflate(level)
or buffer = z_deflate(level, dictionary)
then navail = z_deflate(buffer, data)
or zdata = z_flush(buffer)
finally zdata = z_flush(buffer, data)
or zdata = z_flush(buffer, -)
In any of the first three forms, initiate a zlib deflation
BUFFER. The second two forms allow you to specify a compression
LEVEL (0-9 in increasing compression and decreasing speed), and/or
a special compression DICTIONARY (which you will need to supply
again in order to decompress the data later).
After the BUFFER has been created, use z_deflate to compress DATA,
adding it to the compressed stream in the BUFFER. After one or
several calls to z_deflate, you can call z_flush in the first form
to extract the current BUFFER contents as ZDATA, the portion of
the compressed data stream stored in BUFFER. You can alternate
calls to z_deflate and z_flush as many times as you like in order
to compress an arbitrary amount of DATA into ZDATA without filling
memory. The NAVAIL returned by z_deflate is a lower limit on the
number of bytes of compressed data a subsequent z_flush will return.
The final block of DATA must be compressed by a call to z_flush,
in the final form. This flushes all remaining data into the
resulting ZDATA and closes the BUFFER. You can call z_flush
in this form immediately after creating the buffer, so that
the tersest way to compress a single block of data is:
zdata = z_flush(z_deflate(), data)
Use - for DATA to indicate you have no more DATA, but want to
finish the compression.
|
SEE ALSO:
|
z_inflate,
z_flush,
z_crc32
|
z_flush
|
zdata_or_data = z_flush(buffer)
or zdata = z_flush(buffer, data)
or zdata = z_flush(buffer, -)
or data = z_flush(buffer, type)
Flushes all available ZDATA (if STATE is a z_deflate state) or
all available DATA (if STATE is a z_inflate state). For z_deflate
states, a second argument to z_flush is the final DATA block to
complete the ZDATA stream. For z_inflate states, you may specify
an array data TYPE so that the return DATA value will have that
data type instead of char.
|
SEE ALSO:
|
z_deflate,
z_inflate,
z_setdict
|
z_inflate
|
buffer = z_inflate()
then flag = z_inflate(buffer, zdata)
or flag = z_inflate(buffer, zdata, data)
or data = z_flush(buffer)
or data = z_flush(buffer, type)
In the first form, initiate a zlib inflation BUFFER. You use
that BUFFER in subsequent calls to z_inflate if you do not know
in advance how large the uncompressed DATA will be, or if you
want to do the decompression in chunks to conserve memory.
Use the second or third forms to actually decompress ZDATA.
After one or more calls to z_inflate, you can call z_flush in
order to extract whatever uncompressed DATA has so far been
produced. You can optionally specify a TYPE array for
z_flush, otherwise the DATA will be a 1D array of char.
Alternatively, you can supply a DATA array as the third parameter
to z_inflate, in which case z_inflate will uncompress to your DATA
array instead of to an internal array in BUFFER. You can use this
form if you already know the size and data type the data will
decompress to. If the returned flag is 3, you can call z_setdict
and repeat the call. Otherwise, a return value other than 0
probably represents an error. Note that z_flush will not return
bytes that have been written to a DATA array supplied to z_inflate.
The FLAG returned by z_inflate is
0 if the ZDATA stream is complete, in which case no
further calls to z_inflate are legal with that BUFFER
- the next call to z_flush will return all remaining
bytes of the uncompressed data
1 if the ZDATA stream is incomplete, but no additional
uncompressed data is yet available in BUFFER
2 if the ZDATA stream is incomplete, and uncompressed data
can be retrieved from BUFFER by calling z_flush
3 if a DICTIONARY is required to continue decompression
- use z_setdict to set a dictionary and call z_inflate
a second time with the same DATA
-1 if the ZDATA stream completed, but contained additional
bytes after the end
-2 if the ZDATA stream is corrupted
|
SEE ALSO:
|
z_deflate,
z_flush,
z_setdict,
z_crc32
|
z_setdict
|
adler32 = z_setdict(buffer)
or flag = z_setdict(buffer, dictionary)
In the first form, returns the adler32 checksum of the dictionary
required to continue decompressing a stream after z_inflate
returns 3, or [] (nil) if BUFFER does not need a dictionary.
You can also use this form to retrieve the adler32 checksum of
a dictionary you supplied in the call to z_deflate that
returned BUFFER.
In the second form, sets the DICTIONARY for BUFFER so that
succeeding calls to z_inflate can continue decompressing. The
return value FLAG is 1 on success, or 0 on failure.
You can compute the adler32 checksum using the z_crc32 function.
|
SEE ALSO:
|
z_inflate,
z_crc32
|
|