|
| (&) [Util] |
|
| (<<!) [Util] |
equivalent with Bytes.unsafe_set
|
| (<<) [Util] |
equivalent with Bytes.set
|
| (>@!) [Util] |
equivalent with Array.unsafe.get
|
A |
| access [Bitmap.Make] |
|
| add_color [Color.Cmyk] |
|
| add_color [Color.Rgba] |
|
| add_color [Color.Rgb] |
|
| add_color [Color] |
Add a new color into the given colormap and return its index.
|
| add_colors [Color.Cmyk] |
|
| add_colors [Color.Rgba] |
|
| add_colors [Color.Rgb] |
|
| add_colors [Color] |
Add the list of new colors into the given colormap and return
their indices.
|
| add_methods [Images] |
If you write new drivers for some image format, use this function
to register their loading/saving functions into the libaray
|
| analyze_exif [Exif.Analyze] |
|
| analyze_gps [Exif.Analyze] |
|
| analyze_ifd [Exif.Analyze] |
|
| array_of_image [Graphic_image] |
Convert an Images.t value to an array of colors.
|
B |
| blend [Blend] |
|
| blit [Rgba32] |
|
| blit [Rgb24] |
|
| blit [Index8] |
|
| blit [Index16] |
|
| blit [Images] |
blit src sx sy dst dx dy width height copies the rectangle
region of src at (sx, sy) - (sx + width - 1, sy + height - 1) to dst, at
(dx, dy) - (dx + width - 1, dy + height - 1).
|
| blit [Image_intf.IMAGE] |
blit src x y dst x' y' w h copies rectangular area of src at
x,y with size wxh, to an image dst.
|
| blit [Image_intf.RAWIMAGE] |
|
| blit [Cmyk32] |
|
| blit [Bitmap.Make] |
|
| blocks [Rgba32] |
|
| blocks [Rgb24] |
|
| blocks [Index8] |
|
| blocks [Index16] |
|
| blocks [Images] |
|
| blocks [Image_intf.IMAGE] |
|
| blocks [Image_intf.RAWIMAGE] |
|
| blocks [Cmyk32] |
|
| blocks [Bitmap.Make] |
|
| brightness [Color] |
|
| bytes_per_pixel [Image_intf.ENCODE] |
|
| bytes_per_pixel [Bitmap.Bitdepth] |
|
C |
| catenate_sep [Mstring] |
|
| char_index_of_int [Freetype] |
|
| check [Region] |
check width height x y checks whether the point (x,y) is in the
region of (0, 0) - (width - 1, height - 1).
|
| check_header [Xpm] |
Checks the file header
|
| check_header [Tiff] |
Checks the file header
|
| check_header [Png] |
Checks the file header of a png image.
|
| check_header [Jpeg] |
Checks the file header
|
| check_header [Gif] |
Checks the file header
|
| check_header [Bmp] |
Checks the file header
|
| close [Ftlow] |
|
| close_in [Tiff] |
|
| close_in [Jpeg] |
|
| close_out [Tiff] |
|
| close_out [Jpeg] |
|
| cmyk32 [OImages] |
|
| color_creator [Ximage.Truecolor] |
|
| color_parse [Color] |
|
| color_parser [Ximage.Truecolor] |
|
| colormap [Image_intf.CONTAINER_INDEXED] |
|
| colormap_parse [Color] |
|
| compute [Geometry] |
|
| contents [Exif.Data] |
|
| copy [Rgba32] |
|
| copy [Rgb24] |
|
| copy [Index8] |
|
| copy [Index16] |
|
| copy [Image_intf.IMAGE] |
copy t duplicates the image t.
|
| copy [Image_intf.RAWIMAGE] |
|
| copy [Color] |
Copy a colormap
|
| copy [Cmyk32] |
|
| copy [Bitmap.Make] |
|
| create [Xvthumb] |
|
| create [Ximage] |
Same as Gdk.Image.create, but with size info
|
| create [Rgba32] |
|
| create [Rgb24] |
|
| create [OXvthumb] |
|
| create [OXimage] |
|
| create [Index8] |
|
| create [Index16] |
|
| create [Image_intf.IMAGE] |
create w h creates an image with a size wxh.
|
| create [Image_intf.RAWIMAGE] |
|
| create [Fttext.T] |
|
| create [Colorhist] |
|
| create [Cmyk32] |
|
| create [Bitmap.Make] |
|
| create_default [Image_intf.CONTAINER_INDEXED] |
|
| create_default [Image_intf.CONTAINER] |
|
| create_duplicate [Image_intf.CONTAINER_INDEXED] |
|
| create_duplicate [Image_intf.CONTAINER] |
|
| create_with [Rgba32] |
|
| create_with [Rgb24] |
|
| create_with [Index8] |
|
| create_with [Index16] |
|
| create_with [Image_intf.RAWIMAGE] |
|
| create_with [Cmyk32] |
|
| create_with [Bitmap.Make] |
|
| create_with_scanlines [Rgba32] |
|
| create_with_scanlines [Rgb24] |
|
| create_with_scanlines [Index8] |
|
| create_with_scanlines [Index16] |
|
| create_with_scanlines [Image_intf.RAWIMAGE] |
|
| create_with_scanlines [Cmyk32] |
|
| create_with_scanlines [Bitmap.Make] |
|
D |
| dGifCloseFile [Gif] |
|
| dGifGetExtension [Gif] |
|
| dGifGetImageDesc [Gif] |
|
| dGifGetLine [Gif] |
|
| dGifGetRecordType [Gif] |
|
| dGifOpenFileName [Gif] |
|
| datetime [Exif.Analyze] |
Get one of the first finding of the followings:
exif DateTimeOriginal
ifd_0 DateTime
|
| debug [Bitmap] |
|
| dec_to_hex [Mstring] |
|
| decode [Exif.Entry] |
|
| destroy [Ximage] |
You need manual destroy
|
| destroy [Rgba32] |
|
| destroy [Rgb24] |
|
| destroy [Index8] |
|
| destroy [Index16] |
|
| destroy [Images] |
Free the image.
|
| destroy [Image_intf.IMAGE] |
destroy t explicitly frees the image content of t.
|
| destroy [Image_intf.RAWIMAGE] |
|
| destroy [Fttext.T] |
|
| destroy [Cmyk32] |
|
| destroy [Bitmap.Make] |
|
| done_face [Ftlow] |
|
| dpi [Images] |
Info query
|
| draw [Imagegdk] |
|
| draw_glyphs [Fttext.Make] |
|
| draw_glyphs [Fttext] |
|
| draw_image [Graphic_image] |
Draw an Images.t value into the graphic window.
|
| draw_mono_glyphs [Fttext.Make] |
|
| draw_mono_glyphs [Fttext] |
|
| draw_mono_rotated_glyphs [Fttext.Make] |
|
| draw_mono_rotated_glyphs [Fttext] |
|
| draw_mono_rotated_text [Fttext.Make] |
|
| draw_mono_rotated_text [Fttext] |
|
| draw_mono_text [Fttext.Make] |
|
| draw_mono_text [Fttext] |
|
| draw_rotated_glyphs [Fttext.Make] |
|
| draw_rotated_glyphs [Fttext] |
|
| draw_rotated_text [Fttext.Make] |
|
| draw_rotated_text [Fttext] |
|
| draw_text [Fttext.Make] |
|
| draw_text [Fttext] |
|
| dump [Rgba32] |
|
| dump [Rgb24] |
|
| dump [Index8] |
|
| dump [Index16] |
|
| dump [Image_intf.IMAGE] |
functions for internal use
|
| dump [Image_intf.RAWIMAGE] |
|
| dump [Exif.Data] |
|
| dump [Cmyk32] |
|
| dump [Bitmap.Make] |
|
| dump_block [Rgba32] |
|
| dump_block [Rgb24] |
|
| dump_block [Index8] |
|
| dump_block [Index16] |
|
| dump_block [Image_intf.IMAGE] |
|
| dump_block [Image_intf.RAWIMAGE] |
|
| dump_block [Cmyk32] |
|
| dump_block [Bitmap.Make] |
|
E |
| eGifCloseFile [Gif] |
|
| eGifOpenFileName [Gif] |
|
| eGifPutExtension [Gif] |
|
| eGifPutImageDesc [Gif] |
|
| eGifPutLine [Gif] |
|
| eGifPutScreenDesc [Gif] |
|
| encode [Jis_unicode] |
|
| entries [Exif.Content] |
|
| error [Region] |
|
| error_diffuse [Reduce] |
|
| exif_datetime [Exif.Analyze] |
Get exif DateTimeOriginal
|
| extension [Images] |
Functions for filename extensions
|
F |
| f [Reduce.ErrorDiffuse] |
|
| f [Blend] |
|
| face_info [Ftlow] |
|
| file_format [Images] |
file_format filename reads the header of image file filename
and returns its format and some useful information found in the
header (ex.
|
| filter [Colorhist] |
|
| find_exact [Color.Cmyk] |
|
| find_exact [Color.Rgba] |
|
| find_exact [Color.Rgb] |
|
| find_exact [Color] |
Finds a color in the colormap and returns its color index.
|
| find_nearest [Reduce.REDUCER] |
|
| find_nearest [Color.Cmyk] |
|
| find_nearest [Color.Rgba] |
|
| find_nearest [Color.Rgb] |
|
| fix [Exif.Data] |
|
| float_of_rational [Exif.Numbers] |
|
| float_of_srational [Exif.Numbers] |
|
| format [Jpeg.Marker] |
|
| format [Exif.Data] |
|
| format [Exif.Content] |
|
| format [Exif.Entry.Pack] |
|
| format [Exif.Entry] |
format does decode + unpack
|
| format_unpacked_entry [Exif.Entry] |
|
| from_string [Exif.Data] |
|
| func_darken_only [Fttext] |
|
| func_red_only [Fttext] |
|
G |
| gamma [Colorhist] |
|
| gensym [Mstring] |
|
| get [Ximage] |
|
| get [Rgba32] |
|
| get [Rgb24] |
|
| get [Index8] |
|
| get [Index16] |
|
| get [Image_intf.IMAGE] |
get t x y gets image pixel of t at x,y.
|
| get [Image_intf.RAWIMAGE] |
|
| get [Image_intf.ENCODE] |
|
| get [Fttext.T] |
|
| get [Cmyk32] |
|
| get_bitmap_info [Ftlow] |
|
| get_bitmap_info [Freetype] |
|
| get_bounding_box [Ps] |
Return the bounding box option of the postscript image inside the file
argument.
|
| get_byte_order [Exif.Data] |
|
| get_char_index [Ftlow] |
|
| get_char_index [Freetype] |
|
| get_charmaps [Ftlow] |
|
| get_charmaps [Freetype] |
|
| get_color [Index8] |
|
| get_color [Index16] |
|
| get_color [Image_intf.IMAGEINDEXED] |
get_color x y returns image pixel color value of t at x,y.
|
| get_exif [Exif.Data] |
|
| get_extension [Images] |
Lower interface
|
| get_glyph_metrics [Ftlow] |
|
| get_glyph_metrics [Freetype] |
|
| get_gps [Exif.Data] |
|
| get_ifd_0 [Exif.Data] |
|
| get_ifd_1 [Exif.Data] |
|
| get_image [Ximage] |
|
| get_image [OXimage] |
|
| get_image [Graphic_image] |
get_image x y w h Capture the contents of a rectangle of the graphic
window with lower left corner at x,y, width w and height h
|
| get_interop [Exif.Data] |
|
| get_mono_gc [Ximage] |
|
| get_num_glyphs [Ftlow] |
|
| get_num_glyphs [Freetype] |
Returns number of glyphs stored in the face.
|
| get_outline_contents [Ftlow] |
|
| get_outline_contents [Freetype] |
|
| get_rgb [Index8] |
|
| get_rgb [Index16] |
|
| get_scanline [Rgba32] |
|
| get_scanline [Rgb24] |
|
| get_scanline [Index8] |
|
| get_scanline [Index16] |
|
| get_scanline [Image_intf.IMAGE] |
|
| get_scanline [Image_intf.RAWIMAGE] |
|
| get_scanline [Cmyk32] |
|
| get_scanline [Bitmap.Make] |
|
| get_scanline_ptr [Rgb24] |
|
| get_scanline_ptr [Image_intf.IMAGE] |
|
| get_scanline_ptr [Image_intf.RAWIMAGE] |
|
| get_scanline_ptr [Bitmap.Make] |
|
| get_size_metrics [Ftlow] |
|
| get_size_metrics [Freetype] |
|
| get_strip [Rgba32] |
|
| get_strip [Rgb24] |
|
| get_strip [Index8] |
|
| get_strip [Index16] |
|
| get_strip [Image_intf.IMAGE] |
|
| get_strip [Image_intf.RAWIMAGE] |
|
| get_strip [Cmyk32] |
|
| get_strip [Bitmap.Make] |
|
| get_suffix [Mstring] |
|
| guess_extension [Images] |
|
| guess_format [Images] |
returns the image format guessed from the file extension of
a given file name
|
H |
| height [Image_intf.RAWIMAGE] |
|
| hex_to_dec [Mstring] |
|
| hex_to_string [Mstring] |
|
| hexchar [Mstring] |
|
I |
| ifd_0_datetime [Exif.Analyze] |
Get ifd_0 DateTime
|
| image_of [Graphic_image] |
Convert an Graphics.image value to *our* image
|
| index16 [OImages] |
|
| index8 [OImages] |
|
| init [Ftlow] |
|
| init [Freetype] |
init () initializes the Freetype library.
|
| int_of_char_index [Freetype] |
|
L |
| load [Xvthumb] |
Returns image info and its thumbnail
|
| load [Xpm] |
Loads an xpm image.
|
| load [Tiff] |
Loads a tiff image.
|
| load [Ps] |
Loads a postscript image.
|
| load [Ppm] |
Ppm.load filename reads the image contained in the file filename,
and returns an image.
|
| load [Png] |
Loads a png image.
|
| load [OXvthumb] |
|
| load [OPng] |
|
| load [OJpeg] |
|
| load [OImages] |
|
| load [Jpeg] |
Loads a jpeg image.
|
| load [Images] |
load filename options read the header of an image file filename,
loads the image by calling corresponding loading method, and
returns it.
|
| load [Gif] |
Loads a gif image sequence
|
| load [Bmp] |
Loads a bmp image.
|
| load_as_rgb24 [Png] |
Loads a png image, and coerce it to Rgb24.
|
| load_as_rgb24 [OPng] |
|
| load_bitmap [Ppm] |
Same as above for portable bitmaps.
|
| load_bmp [Bmp] |
|
| load_char [Ftlow] |
|
| load_char [Freetype] |
|
| load_first [Gif] |
Loads the first frame of a gif image sequence.
|
| load_glyph [Ftlow] |
|
| load_glyph [Freetype] |
|
| load_ppm [Ppm] |
|
| load_progress [Images] |
Option queries
|
| load_ps [Ps] |
Loads a postscript image within a bounding box.
|
| load_resolution [Images] |
|
| load_sequence [Images] |
|
| load_sequence [Gif] |
Loads a gif image sequence, but to more general type
|
| load_thumbnail [OJpeg] |
|
| load_thumbnail [Jpeg] |
|
M |
| make [Rgba32] |
|
| make [Rgb24] |
|
| make [OImages] |
|
| make [Index8] |
|
| make [Index16] |
|
| make [Image_intf.IMAGE] |
make w h c creates an image with a size wxh.
|
| make [Image_intf.RAWIMAGE] |
|
| make [Image_intf.ENCODE] |
|
| make [Cmyk32] |
|
| map [Rgba32] |
|
| map [Rgb24] |
|
| map [Index8] |
|
| map [Index16] |
|
| map [Image_intf.IMAGE] |
map f src x y dst x' y' w h maps pixels of the rectangular area
of src at x,y with size wxh, to an image dst,
using color conversion function f.
|
| map [Image_intf.RAWIMAGE] |
|
| map [Cmyk32] |
|
| mask_of_image [Ximage] |
|
| mask_of_image [OXimage] |
|
| matrix_rotate [Freetype] |
|
| maximum_block_size [Bitmap] |
|
| maximum_live [Bitmap] |
|
| merge [Color.Rgba] |
|
| minus [Color.Cmyk] |
|
| minus [Color.Rgba] |
|
| minus [Color.Rgb] |
|
| minus [Color] |
|
N |
| new_face [Ftlow] |
|
| new_face [Freetype] |
new_face library fontfile n loads n-th font stored
in the font file fontfile, and returns its face and
face information.
|
| new_tmp_file_name [Tmpfile] |
|
| norm_crlf [Mstring] |
norm_crlf last_was_cr buf offs len returns
buf with CRLF/CR/LF converted to LF, and a flag indicating
whether last char was CR.
|
| normalize [Colorhist] |
|
O |
| of_image [Ximage] |
|
| of_image [OXimage] |
|
| of_image [Graphic_image] |
Convert an Images.t value to a graphic image.
|
| of_rgba32 [Rgb24] |
Image format conversion functions between Rgba32.t images
|
| of_string [Exif.DateTime] |
To convert DateTime string to DateTime.t.
|
| of_string [Exif.Date] |
|
| of_string_packed_unix_time [Exif.DateTime] |
I had an Android phone which created DateTime tag with
a little endian encoded unsigned int32 of unix time!
This function tries to fix the issue.
|
| open_in [Tiff] |
|
| open_in [Jpeg] |
|
| open_in_thumbnail [Jpeg] |
|
| open_out [Tiff] |
|
| open_out [Jpeg] |
|
P |
| parse_datetime [Exif.Analyze] |
|
| pixmap_of [Ximage] |
|
| pixmap_of_image [Ximage] |
|
| pixmap_of_image [OXimage] |
|
| plain_mask [Ximage] |
|
| plus [Color.Cmyk] |
|
| plus [Color.Rgba] |
|
| plus [Color.Rgb] |
|
| plus [Color] |
|
R |
| range_check [Util] |
range_check bs from to_ raises Invalid_argument "index out of bounds"
when from and to_ are invalid range for bs.
|
| rawimage [Rgba32] |
|
| rawimage [Rgb24] |
|
| rawimage [Index8] |
|
| rawimage [Index16] |
|
| rawimage [Image_intf.CONTAINER_INDEXED] |
|
| rawimage [Image_intf.CONTAINER] |
|
| rawimage [Cmyk32] |
|
| read_bitmap [Ftlow] |
|
| read_bitmap [Freetype] |
|
| read_markers [Jpeg] |
Open the file, read the markers, then close it immediately.
|
| read_scanline [Tiff] |
|
| read_scanline [Jpeg] |
|
| rem_trailing_sp [Mstring] |
|
| remove_tmp_file [Tmpfile] |
|
| render_char [Ftlow] |
|
| render_char [Freetype] |
|
| render_glyph [Ftlow] |
|
| render_glyph [Freetype] |
|
| render_glyph_of_face [Ftlow] |
|
| render_glyph_of_face [Freetype] |
|
| resize [Rgba32] |
resize progress t w h creates a resized image of t with size wxh.
|
| resize [Rgb24] |
|
| resize [Cmyk32] |
|
| rgb24 [OImages] |
|
| rgb_square_distance [Color] |
Rgb specialized functions (for backward compatibility)
|
| rgba32 [OImages] |
|
S |
| save [Xvthumb] |
Save xv thumbnail.
|
| save [Tiff] |
Save a full-color image in tiff format file.
|
| save [Ps] |
Save a full-color image in the Encapuslated PS format file.
|
| save [Ppm] |
Ppm.save : filename img stores image img, on file filename.
|
| save [Png] |
Saves an image into a png file format.
|
| save [OXvthumb] |
|
| save [OPng] |
|
| save [OJpeg] |
|
| save [Jpeg] |
Save a full-color image in jpeg format file.
|
| save [Images] |
save filename formatopt options image saves image into a file
filename.
|
| save [Gif] |
Saves a gif image sequence
|
| save [Bmp] |
Save an image in bmp format file.
|
| save_as_cmyk [OJpeg] |
|
| save_as_cmyk [Jpeg] |
This converts RGB images to CMYK, but the color conversion is not
something fancy.
|
| save_bitmap [Ppm] |
|
| save_bmp [Bmp] |
Load and save functions for BMP images.
|
| save_cmyk_sample [Jpeg] |
Create CMYK jpeg image sample.
|
| save_image [Gif] |
Saves an image as a gif file with only one frame
|
| save_interlace [Images] |
|
| save_ppm [Ppm] |
Specialized version for portable bitmaps.
|
| save_progress [Images] |
|
| save_quality [Images] |
|
| save_sequence [Images] |
|
| save_with_markers [Jpeg] |
Same as save but it also writes markers
|
| set [Ximage] |
|
| set [Rgba32] |
|
| set [Rgb24] |
|
| set [Index8] |
|
| set [Index16] |
|
| set [Image_intf.IMAGE] |
set t x y c sets image pixel of t at x,y by the color c.
|
| set [Image_intf.RAWIMAGE] |
|
| set [Image_intf.ENCODE] |
|
| set [Fttext.T] |
|
| set [Cmyk32] |
|
| set_byte_order [Exif.Data] |
|
| set_char_size [Ftlow] |
|
| set_char_size [Freetype] |
set_char_size face charw charh resh resv sets the character
size of face.
|
| set_charmap [Ftlow] |
|
| set_charmap [Freetype] |
|
| set_pixel_sizes [Ftlow] |
|
| set_pixel_sizes [Freetype] |
set_pixel_sizes face pixw pixh also sets the character size
of face.
|
| set_scanline [Rgba32] |
|
| set_scanline [Rgb24] |
|
| set_scanline [Index8] |
|
| set_scanline [Index16] |
|
| set_scanline [Image_intf.IMAGE] |
|
| set_scanline [Image_intf.RAWIMAGE] |
|
| set_scanline [Cmyk32] |
|
| set_scanline [Bitmap.Make] |
|
| set_strip [Rgba32] |
|
| set_strip [Rgb24] |
|
| set_strip [Index8] |
|
| set_strip [Index16] |
|
| set_strip [Image_intf.IMAGE] |
|
| set_strip [Image_intf.RAWIMAGE] |
|
| set_strip [Cmyk32] |
|
| set_strip [Bitmap.Make] |
|
| set_transform [Ftlow] |
|
| set_transform [Freetype] |
|
| size [Images] |
Returns size (width and height) of image
|
| size [Fttext] |
|
| size [Color.Cmyk] |
|
| size [Color.Rgba] |
|
| size [Color.Rgb] |
|
| size [Color] |
Colormap manipulation functions
|
| size_of_glyphs [Fttext] |
|
| split_str [Mstring] |
|
| split_str_quoted [Mstring] |
|
| square_distance [Color.Cmyk] |
|
| square_distance [Color.Rgba] |
|
| square_distance [Color.Rgb] |
|
| store_sample [Colorhist] |
|
| string_of_format [Exif.Entry.Pack] |
|
| string_of_rational [Exif.Numbers] |
|
| string_of_srational [Exif.Numbers] |
|
| sub [Rgba32] |
|
| sub [Rgb24] |
|
| sub [OImages] |
|
| sub [Index8] |
|
| sub [Index16] |
|
| sub [Images] |
sub dst x y width height returns sub-bitmap of dst,
at (x, y) - (x + width - 1, y + height - 1).
|
| sub [Image_intf.IMAGE] |
sub t x y w h duplicates a subimage of t of size wxh,
whose origin (0,0) is at (x,y) of t.
|
| sub [Image_intf.RAWIMAGE] |
|
| sub [Cmyk32] |
|
| sub [Bitmap.Make] |
|
| sys [Exif.Endian] |
|
T |
| tag [OImages] |
|
| tmp_dir [Tmpfile] |
|
| to_pixbuf [Imagegdk] |
|
| to_rgb24 [Index8] |
|
| to_rgb24 [Index16] |
|
| to_rgba32 [Rgb24] |
|
| to_rgba32 [Index8] |
|
| to_rgba32 [Index16] |
to_rgb? ~failsafe t: Image format conversion functions to Rgb24.t
and Rgba32.t images.
|
| to_string [Exif.Tag] |
Tag name requires IFD.t since the same tag number has different
meaning in IFD and GPS
|
| to_string [Exif.DateTime] |
|
| to_string [Exif.Date] |
|
| to_string [Exif.Endian] |
|
| total_samples [Colorhist] |
|
U |
| unicode_of_euc_japan [Fttext] |
|
| unicode_of_latin [Fttext] |
|
| unoptimize_sequence [Images] |
|
| unpack [Exif.Entry.Pack] |
unpack format components packed
components are the number of elements in packed,
not the bytes of packed.
|
| unpack [Exif.Entry] |
|
| unpack_exif [Exif.Data] |
|
| unpack_gps [Exif.Data] |
|
| unpack_ifd_0 [Exif.Data] |
|
| unpack_ifd_1 [Exif.Data] |
|
| unpack_interop [Exif.Data] |
|
| unsafe_access [Rgba32] |
|
| unsafe_access [Rgb24] |
|
| unsafe_access [Index8] |
|
| unsafe_access [Index16] |
|
| unsafe_access [Image_intf.IMAGE] |
|
| unsafe_access [Image_intf.RAWIMAGE] |
|
| unsafe_access [Cmyk32] |
|
| unsafe_get [Ximage] |
|
| unsafe_get [Rgba32] |
|
| unsafe_get [Rgb24] |
|
| unsafe_get [Index8] |
|
| unsafe_get [Index16] |
|
| unsafe_get [Image_intf.IMAGE] |
|
| unsafe_get [Image_intf.RAWIMAGE] |
|
| unsafe_get [Fttext.T] |
|
| unsafe_get [Cmyk32] |
|
| unsafe_get_color [Index8] |
|
| unsafe_get_color [Index16] |
|
| unsafe_get_color [Image_intf.IMAGEINDEXED] |
|
| unsafe_get_rgb [Index8] |
|
| unsafe_get_rgb [Index16] |
|
| unsafe_set [Ximage] |
|
| unsafe_set [Rgba32] |
|
| unsafe_set [Rgb24] |
|
| unsafe_set [Index8] |
|
| unsafe_set [Index16] |
|
| unsafe_set [Image_intf.IMAGE] |
Unsafe versions of get and set.
|
| unsafe_set [Image_intf.RAWIMAGE] |
|
| unsafe_set [Fttext.T] |
|
| unsafe_set [Cmyk32] |
|
V |
| vector_gen [Fttext] |
|
| vector_glyphs [Fttext] |
|
| vector_text [Fttext] |
|
W |
| width [Image_intf.RAWIMAGE] |
|
| write_marker [Jpeg] |
|
| write_scanline [Tiff] |
|
| write_scanline [Jpeg] |
|