Skip to main content

​
module  pixeltable.functions.image

Pixeltable UDFs for ImageType. Example: 
import pixeltable as pxt

t = pxt.get_table(...)
t.select(t.img_col.convert('L')).collect()

​
udf  alpha_composite()

alpha_composite(im1: Image, im2: Image) -> Image
Alpha composite im2 over im1. Equivalent to PIL.Image.alpha_composite()

​
udf  b64_encode()

b64_encode(img: Image, image_format: String = 'png') -> String
Convert image to a base64-encoded string. Parameters:

​
udf  blend()

blend(im1: Image, im2: Image, alpha: Float) -> Image
Return a new image by interpolating between two input images, using a constant alpha. Equivalent to PIL.Image.blend()

​
udf  composite()

composite(image1: Image, image2: Image, mask: Image) -> Image
Return a composite image by blending two images using a mask. Equivalent to PIL.Image.composite()

​
udf  convert()

convert(self: Image, mode: String) -> Image
Convert the image to a different mode. Equivalent to PIL.Image.Image.convert(). Parameters:
  • mode (String): The mode to convert to. See the Pillow documentation for a list of supported modes.

​
udf  crop()

crop(self: Image, box: Json) -> Image
Return a rectangular region from the image. The box is a 4-tuple defining the left, upper, right, and lower pixel coordinates. Equivalent to PIL.Image.Image.crop()

​
udf  effect_spread()

effect_spread(self: Image, distance: Int) -> Image
Randomly spread pixels in an image. Equivalent to PIL.Image.Image.effect_spread() Parameters:
  • distance (Int): The distance to spread pixels.

​
udf  entropy()

entropy(
    self: Image,
    mask: Image | None = None,
    extrema: Json | None = None
) -> Float
Returns the entropy of the image, optionally using a mask and extrema. Equivalent to PIL.Image.Image.entropy() Parameters:
  • mask (Image | None): An optional mask image.
  • extrema (Json | None): An optional list of extrema.

​
udf  get_metadata()

get_metadata(self: Image) -> Json
Return metadata for the image.

​
udf  getbands()

getbands(self: Image) -> Json
Return a tuple containing the names of the image bands. Equivalent to PIL.Image.Image.getbands()

​
udf  getbbox()

getbbox(self: Image, *, alpha_only: Bool = True) -> Json | None
Return a bounding box for the non-zero regions of the image. Equivalent to PIL.Image.Image.getbbox() Parameters:
  • alpha_only (Bool): If True, and the image has an alpha channel, trim transparent pixels. Otherwise, trim pixels when all channels are zero.

​
udf  getchannel()

getchannel(self: Image, channel: Int) -> Image
Return an L-mode image containing a single channel of the original image. Equivalent to PIL.Image.Image.getchannel() Parameters:
  • channel (Int): The channel to extract. This is a 0-based index.

​
udf  getcolors()

getcolors(self: Image, maxcolors: Int = 256) -> Json
Return a list of colors used in the image, up to a maximum of maxcolors. Equivalent to PIL.Image.Image.getcolors() Parameters:
  • maxcolors (Int): The maximum number of colors to return.

​
udf  getextrema()

getextrema(self: Image) -> Json
Return a 2-tuple containing the minimum and maximum pixel values of the image. Equivalent to PIL.Image.Image.getextrema()

​
udf  getpalette()

getpalette(self: Image, mode: String | None = None) -> Json | None
Return the palette of the image, optionally converting it to a different mode. Equivalent to PIL.Image.Image.getpalette() Parameters:
  • mode (String | None): The mode to convert the palette to.

​
udf  getpixel()

getpixel(self: Image, xy: Json) -> Json
Return the pixel value at the given position. The position xy is a tuple containing the x and y coordinates. Equivalent to PIL.Image.Image.getpixel() Parameters:
  • xy (Json): The coordinates, given as (x, y).

​
udf  getprojection()

getprojection(self: Image) -> Json
Return two sequences representing the horizontal and vertical projection of the image. Equivalent to PIL.Image.Image.getprojection()

​
udf  height()

height(self: Image) -> Int
Return the height of the image.

​
udf  histogram()

histogram(
    self: Image,
    mask: Image | None = None,
    extrema: Json | None = None
) -> Json
Return a histogram for the image. Equivalent to PIL.Image.Image.histogram() Parameters:
  • mask (Image | None): An optional mask image.
  • extrema (Json | None): An optional list of extrema.

​
udf  mode()

mode(self: Image) -> String
Return the image mode.

​
udf  point()

point(
    self: Image,
    lut: Json,
    mode: String | None = None
) -> Image
Map image pixels through a lookup table. Equivalent to PIL.Image.Image.point() Parameters:
  • lut (Json): A lookup table.

​
udf  quantize()

quantize(
    self: Image,
    colors: Int = 256,
    method: Int | None = None,
    kmeans: Int = 0,
    palette: Image | None = None,
    dither: Int = <Dither.FLOYDSTEINBERG: 3>
) -> Image
Convert the image to ‘P’ mode with the specified number of colors. Equivalent to PIL.Image.Image.quantize() Parameters:
  • colors (Int): The number of colors to quantize to.
  • method (Int | None): The quantization method. See the Pillow documentation for a list of supported methods.
  • kmeans (Int): The number of k-means clusters to use.
  • palette (Image | None): The palette to use.
  • dither (Int): The dithering method. See the Pillow documentation for a list of supported methods.

​
udf  reduce()

reduce(self: Image, factor: Int, box: Json | None = None) -> Image
Reduce the image by the given factor. Equivalent to PIL.Image.Image.reduce() Parameters:
  • factor (Int): The reduction factor.
  • box (Json | None): An optional 4-tuple of ints providing the source image region to be reduced. The values must be within (0, 0, width, height) rectangle. If omitted or None, the entire source is used.

​
udf  resize()

resize(self: Image, size: Json) -> Image
Return a resized copy of the image. The size parameter is a tuple containing the width and height of the new image. Equivalent to PIL.Image.Image.resize()

​
udf  rotate()

rotate(self: Image, angle: Int) -> Image
Return a copy of the image rotated by the given angle. Equivalent to PIL.Image.Image.rotate() Parameters:
  • angle (Int): The angle to rotate the image, in degrees. Positive angles are counter-clockwise.

​
udf  transpose()

transpose(self: Image, method: Int) -> Image
Transpose the image. Equivalent to PIL.Image.Image.transpose() Parameters:

​
udf  width()

width(self: Image) -> Int
Return the width of the image.