Skip to content

Graphics

  • gemcubeframebuffer The gemcubeframebuffer object renders a 3D scene onto the faces of a GL cubemap texture.
  • fd_circle fd_circle computes successive positions for circular motion, outputting each position as an x–y list and supporting use with Gem.
  • pofplane pofplane draws a textured plane with configurable width and height, supplied as arguments or through inlets 2 and 3.
  • pdp_rotate pdp_rotate rotates PDP image data and supports zoom.
  • pix_compare The pix_compare object compares two input image streams pixel by pixel based on their luminance.
  • pix_aging The pix_aging object applies a Super8-like aging effect to images or video streams, simulating the look of old film.
  • fd_GEMbuffsize fd_GEMbuffsize helps determine a suitable size for a gemvertexbuffer, with power-of-two sizes recommended.
  • pix_posterize pix_posterize applies a posterization effect to images within the GEM environment.
  • mesh_line The mesh_line object renders a line mesh within the GEM environment, drawing it at the current position with the current color.
  • poffonts poffonts loads and declares a font using ofxFontStash so it can be referenced by objects such as poftexts.
  • gemglutwindow The gemglutwindow object creates and manages an OpenGL rendering window using the GLUT (OpenGL Utility Toolkit) library.
  • pix_opencv_hough_lines pix_opencv_hough_lines applies a Hough line-detection algorithm to an image and reports each detected line as X1, Y1, X2, and Y2 coordinates.
  • fd_array2pix fd_array2pix displays the values of a source array as grayscale pixels in a Gem list.
  • pix_a_2grey The pix_a_2grey object converts an input RGBA image to grayscale based on its alpha channel.
  • fd_autopoly fd_autopoly creates a variable-point Gem polygon or curve from sigmund~ peak-tracking output.
  • pofresetmatrix pofresetmatrix undoes all previous translation, rotation, and scaling transformations in a Pof rendering chain.
  • pofipcam pofipcam is an IP camera grabber that connects to a URL and supplies the camera image in a Pof rendering chain.
  • fd_plot fd_plot is a graph-on-parent abstraction for plotting points on an existing parent-patch canvas.
  • pix_subtract The pix_subtract object subtracts the pixel values of one image from another, requiring both input images to be of the same size.
  • pdp_xv pdp_xv outputs video in a window using the XVideo extension.
  • pix_blur The pix_blur object applies a blur effect to an image or video stream within Pure Data's GEM environment.
  • pix_convert The pix_convert object transforms the color space of an image within GEM.
  • pd-colors pd-colors provides color palettes for Pure Data, associated with Tcl/Tk and data structures.
  • pix_threshold_bernsen pix_threshold_bernsen applies a dynamic tiled threshold filter to greyscale images for binarization.
  • pdp_v4l pdp_v4l is intended to capture video from a Video4Linux input device and output PDP image packages, although the help patch inconsistently labels its example objects as pdp_ieee1394.
  • pofcolor pofcolor changes the color and alpha of subsequent Pof rendering by multiplying incoming red, green, blue, and alpha values by its own values.
  • pix_snap2tex The pix_snap2tex object captures a snapshot of the current GEM render buffer and applies it as a texture to attached geometric objects.
  • pix_opencv_hu_moments pix_opencv_hu_moments calculates the seven Hu moments (h1–h7) of incoming image frames, allowing moments from images such as simple patterns to be compared.
  • pix_buf The pix_buf object, also known as pix_separator, buffers image data (pixes) to store the results of time-consuming processing operations.
  • color The color object in Pure Data sets the color for all subsequent GEM (Graphics Environment for Multimedia) shape and vertex operations.
  • biplot The biplot object visualizes the frequency response of a biquad filter.
  • zbiplot The zbiplot object visualizes biquad filter coefficients by plotting their poles and zeros in the complex plane.
  • fd_pix2list fd_pix2list dumps an incoming Gem list as a grayscale list whose size is a power of two, cropping and truncating non-power-of-two images according to the smaller image dimension.
  • pix_scanline The pix_scanline object processes image rows, either duplicating or removing them.
  • fd_gembuf fd_gembuf buffers incoming gemlists, using Gem's pixel-buffer facilities.
  • pix_opencv_athreshold pix_opencv_athreshold performs adaptive thresholding to segment an image, calculating a threshold individually for each pixel and assigning thresholded pixels a configurable maximum value (255 by default).
  • pdp_scale pdp_scale rescales a packet to new dimensions, making it possible to combine packets of different sizes.
  • part_velocity The part_velocity object in Pure Data, part of the GEM library, sets the initial velocity of newly emitted particles.
  • part_color The part_color object is a component of the GEM particle system, designed to define the visual color of particles.
  • pix_grey The pix_grey object converts the color space of an incoming image to grayscale.
  • rectangle The rectangle object is a GEM (Graphics Environment for Multimedia) object that renders a rectangular shape.
  • pix_opencv_matchshape pix_opencv_matchshape compares a contour against loaded template contours using OpenCV’s cv::matchShapes function to recognize corresponding shapes.
  • pix_takealpha The pix_takealpha object transfers the alpha channel from a second input image to a first input image.
  • pix_opencv_camshift pix_opencv_camshift uses continuously adaptive mean-shift to track a selected object in a Gem image stream, reporting its center coordinates, width, height, and angle.
  • pix_roll The pix_roll object scrolls or rolls an image, wrapping its content around the edges.
  • osci3d~ osci3d~ is a configurable three-dimensional oscilloscope for displaying three input signals, as demonstrated with three osc~ sources.
  • pix_puzzle The pix_puzzle object shuffles an input image by cutting it into rectangular pieces and rearranging them.
  • gemwin+ gemwin+ is a user-friendly Gem window manager that provides a gemlist and mouse input data.
  • pix_opencv_opticalflow pix_opencv_opticalflow computes optical flow from an RGBA image, producing a gemlist output and an additional info output.
  • pix_opencv_motempl pix_opencv_motempl performs OpenCV-based motion detection, reporting each motion component as center X/Y, width, height, and angle; component -1 represents the whole image.
  • gemorb The gemorb object connects to a SpaceOrb 3D controller via a specified serial port (comport).
  • ui.icon ui.icon is a UI element that displays a named icon and provides button capabilities, with bang, toggle, and button output modes.
  • pix_opencv_bgstats pix_opencv_bgstats performs background and foreground extraction on an incoming image stream, with objects disappearing from the background after a certain period.
  • pofbeam pofbeam builds and renders a beam from points supplied with add x y width messages, with controls for width, color, quality, and clearing the beam.
  • pix_opencv_warpperspective pix_opencv_warpperspective applies a perspective transformation to an image, computing the transformation matrix from source and destination matrices.
  • poffill poffill controls whether shapes are drawn filled or as outlines, with optional arguments for the fill state and outline line width.
  • pix_rds The pix_rds object generates black and white random dot stereograms, commonly known as "magic eye" images.
  • pix_multiply The pix_multiply object in Pure Data multiplies two input images (pixes) together, requiring them to be of the same size.
  • poffont poffont defines a named font from a font file for use by objects such as poftext.
  • colormap colormap maps a linear value to an RGB output.
  • pix_mano The pix_mano object tracks light-reflecting objects within a video stream by applying a threshold and analyzing their contours.
  • part_head The part_head object initializes and manages a particle system within GEM.
  • ui.lcd ui.lcd is a black-and-white bitmap display for presenting and manipulating pixel-based content in a Pd interface.
  • rotateXYZ The rotateXYZ object in GEM applies a 3D rotation to the current transformation matrix.
  • ui.plot~.log2 The help patch does not instantiate ui.plot~.log2, so its behavior cannot be established from the supplied evidence.
  • pdp_grey2mask pdp_grey2mask converts a grayscale image or an image’s luma channel into a mask.
  • pix_movement2 The pix_movement2 object is a time-based IIR filter designed for motion detection in video streams.
  • pix_histo pix_histo calculates the histogram (density function) of an input image, storing the results in Pure Data tables.
  • pix_opencv_hist_compare pix_opencv_hist_compare performs image recognition by comparing an input image’s histogram with stored histograms, outputting matching measures and the closest stored histogram as the winner.
  • pix_opencv_clahe pix_opencv_clahe processes incoming GEM pixel data using CLAHE, with controls for the clip limit and tile-grid size.
  • pdp2gem pdp2gem is a bridge that transforms PDP image data into a format usable in GEM.
  • emissionRGB The emissionRGB object sets the emission color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • gemsdlwindow gemsdlwindow is a Pure Data object that utilizes the SDL (Simple DirectMedia Layer) toolkit to create and manage graphical windows.
  • pix2canvas pix2canvas converts images into a canvas.
  • fd_blobtracks fd_blobtracks is a utility for analyzing, tracking, and displaying pixel blobs, using Gem’s pix_multiblob.
  • gemglfw2window The gemglfw2window object creates and manages a graphical window using GLFW (version 2) within Pure Data's GEM environment.
  • trapezoid The trapezoid object in Pure Data renders a trapezoidal shape in a graphical environment, taking its position and color from the current rendering state.
  • pdp_zoom pdp_zoom zooms PDP data, with the right inlet setting the zoom amount.
  • ofWindow ofWindow is a graphics-window handler used to create or destroy a window and change properties such as its position, size, title, window mode, and OpenGL/OpenGL ES version.
  • pix_artoolkit pix_artoolkit processes a GEM video/image stream for ARToolKit marker tracking, with its output used to texture a rectangle and drive 3D translation and rotation.
  • shearXY The shearXY object applies a shear transformation to graphical objects within GEM (Graphics Environment for Multimedia).
  • gemreceive gemreceive is an ordered message receiver for the GEM (Graphics Environment for Multimedia) environment.
  • pix_share_read The pix_share_read object reads pixel data from a shared memory region, identified by a unique ID.
  • part_sink The part_sink object defines a spatial region within a particle system where particles will be removed or "vanish." Users can specify various geometric shapes (domains) such as points, lines, spheres, or boxes, along with their corresponding arguments (e.g., coordinates, radii).
  • fd_pixrecord fd_pixrecord simplifies handling Gem’s pix_record for recording the current gemwin pixels to a movie file, with controls for starting and stopping, recording length, filename/path, and frame dimensions.
  • pix_rgba The pix_rgba object converts the color space of an incoming image to RGBA format, which is the native color space for GEM.
  • pix_opencv_floodfill pix_opencv_floodfill marks image components with a fill color and can serve as an object selector in tracking algorithms.
  • pix_set The pix_set object allows you to create or modify image data by providing a flat list of pixel values.
  • visu~ visu~ refers to signal visualizers that send their signal inputs to an external process for display as a waterfall (wfvisu~), spectrogram (sgvisu~), or oscillogram (ogvisu~).
  • pix_invert The pix_invert object inverts the colors of an input image, transforming black pixels to white and vice-versa.
  • pofvisible pofvisible shows or hides downstream drawing: a visibility value of 1 draws, while 0 prevents drawing.
  • hsb hsb appears to be related to hue, saturation, and brightness, but this help patch only refers to hueSaturationBrightness and provides no behavioral or usage details.
  • pix_lumaoffset The pix_lumaoffset object offsets pixels in the y-direction based on their luminance, creating a visual effect where brighter areas are shifted more.
  • pofwin pofwin controls the main POF window, including its size, position, frame rate, background color, cursor, and normalized texture-coordinate setting, and reports the actual window size.
  • ui.colorpanel ui.colorpanel is a color-chooser widget for selecting and displaying a color.
  • pix_diff The pix_diff object calculates the absolute difference between two input images, which must be of the same size.
  • part_killslow The part_killslow object is a GEM particle system utility designed to manage particle populations.
  • pix_opencv_calibration pix_opencv_calibration calibrates a camera from multiple views of a chessboard pattern and then undistorts incoming images.
  • pix_opencv_haarcascade pix_opencv_haarcascade detects objects in image frames using a trained cascade classifier, reporting the number of detected objects and, for each detection, its center coordinates and radius.
  • pix_info The pix_info object retrieves metadata about the current image in GEM, such as its dimensions, pixel size, color space (format), and a pointer to the image data.
  • pix_deinterlace The pix_deinterlace object applies a deinterlacing algorithm to incoming images, primarily by averaging neighboring rows.
  • pix_buffer_filmopen The pix_buffer_filmopen object reads a movie file into a named pix_buffer for subsequent image processing within GEM.
  • pix_dump The pix_dump object processes an incoming GEM image and outputs its raw pixel data as a single, long list of color component values.
  • hueSaturationBrightness hueSaturationBrightness outputs a number representing a color in the HSB color space, with hue, saturation, and brightness each ranging from 0 to 255.
  • pix_opencv_of_hs pix_opencv_of_hs applies the Horn–Schunck optical-flow algorithm to a video stream to analyze movement.
  • pdp_zrot pdp_zrot applies zoom and rotation to PDP data.
  • pix_image The pix_image object loads image files (like TIFFs and JPEGs) into Pure Data, primarily for use as textures or for bitblitting operations within the GEM environment.
  • pix_levels The pix_levels object performs image level adjustments, similar to brightness and contrast controls.
  • fluid.plotter The fluid.plotter object provides a native graphical user interface for plotting and querying two-dimensional datasets.
  • pdp_glx pdp_glx outputs video in a window using the OpenGL extension and sends mouse event messages from its output.
  • gemrepeat The gemrepeat object is a GEM manipulation object designed to duplicate incoming gemlist messages.
  • mesh_square The mesh_square object renders a square mesh at the current position and color, with its size controllable via the second inlet.
  • part_source The part_source object creates a source for particles within a particle system, emitting new particles at a specified rate per rendering frame.
  • pix_opencv_trackKnn pix_opencv_trackKnn uses the KNN algorithm to keep track of detected features supplied as cvblob lists, and can be used with other tracking techniques.
  • pix_freeframe The pix_freeframe object loads and applies FreeFrame video effects in real-time.
  • linear_path The linear_path object reads out values from a specified table.
  • tube The tube object in Pure Data renders a 3D tube shape.
  • pix_mask The pix_mask object applies a mask to an image using the luminance of a second image.
  • conv.lab2rgb conv.lab2rgb converts LAB color components to RGB values.
  • pix_film The pix_film object loads and plays digital video files, providing frames as textures for use within Pure Data's GEM environment.
  • spline_path The spline_path object reads interpolated values from a multi-dimensional table, treating it as a spline.
  • ui.plot~.lin2 ui.plot~.lin2 is a help-patch example for plotting two signals with ui.plot~, using math.sin~ and math.cos~ alongside a plot.linspace~ range from 0 to 10 with 300 points.
  • rgbtable rgbtable maps a float input to separate red, green, and blue float outputs for use as a color table.
  • pix_resize The pix_resize object resizes an image to specified dimensions.
  • fd_blobvid fd_blobvid is a buffer-based blob tracker for video data, intended to detect blobs using fd_blobtracks and Gem.
  • poftexture poftexture retrieves a named texture from a producer such as pofimage, poffilm, or poffbo, allowing that texture to be applied to downstream Pof drawing objects.
  • pdp_noise pdp_noise creates a random image with a uniform distribution, generating colour images by default or greyscale images when selected.
  • fd_gemsphere fd_gemsphere plots a sphere on the screen using Gem and takes no arguments.
  • yuv2rgb The yuv2rgb object converts video signals between the YUV and RGB color spaces.
  • pix_draw The pix_draw object directly draws pixels onto the screen without applying any texture mapping.
  • torus The torus object renders a 3D torus (doughnut shape) within a GEM environment.
  • pix_crop The pix_crop object is a GEM utility that extracts a sub-image from an incoming image.
  • circle-gui circle-gui is a simple circular GUI slider implemented using pdlua’s graphics.
  • pix_buffer pix_buffer is a named storage object for images, functioning similarly to a table but without direct visual access to its contents.
  • pofcirc pofcirc draws a circle or ellipse with an initial width, height, and optional resolution.
  • pix_opencv_of_bm pix_opencv_of_bm applies a block-matching optical-flow algorithm to an image stream to detect movement, marking the block with the greatest motion using a white arrow.
  • ortho ortho is a GEM object in Pure Data that controls the rendering projection for subsequent graphical objects.
  • ambientRGB The ambientRGB object in Pure Data sets the ambient color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) patch.
  • pix_colorreduce The pix_colorreduce object reduces the number of colors in a pixImage based on its statistical information.
  • pdp_chrot pdp_chrot rotates the chroma components of PDP image data by a specified angle.
  • translate The translate object in Pure Data is a GEM manipulation object that applies a translation to the current transformation matrix.
  • pix_movie The pix_movie object loads and plays digital video files, making their frames available as textures for real-time graphics rendering within GEM.
  • pix_bitmask The pix_bitmask object applies a bitmask to incoming image data (gemlist), allowing selective modification or filtering of pixels.
  • pix_yuv The pix_yuv object converts the colorspace of an image to the YUV format.
  • pix_biquad The pix_biquad object applies a time-based Infinite Impulse Response (IIR) filter to images, functioning similarly to the audio biquad~ object but for visual data.
  • pofpath pofpath draws a path, with optional width and height arguments such as pofpath 200 200.
  • fd_blob fd_blob renders an information blob on screen using Gem and has no outlets.
  • pix_hit The pix_hit object performs hit tests on incoming GEM pixel data, allowing users to define specific areas (circles, lines, rectangles) within an image or video stream.
  • gcanvas gcanvas is a GUI rectangle that detects mouse position, outputting X and Y pixel values when you click and drag inside it, along with a click indication.
  • pix_opencv_contours_boundingrect pix_opencv_contours_boundingrect detects multiple contours and calculates an upright bounding rectangle for each detected contour, making it useful for motion tracking when objects are well isolated.
  • spot_light The spot_light object adds a customizable spot-light to a GEM scene, allowing control over its position, color (via RGB list), and properties like linear attenuation, cone cutoff angle, and decay at edges.
  • pix_blobtracker The pix_blobtracker object in Pure Data is a video analysis tool designed to detect and track multiple distinct regions (blobs) within an incoming video stream.
  • pix_opencv_edge pix_opencv_edge is an edge-detection filter for image streams in Pd/GEM.
  • c.scope~ c.scope~ is an oscilloscope that displays a signal’s waveform and can also display two signals in XY mode.
  • pix_pix2sig~ The pix_pix2sig~ object converts incoming image data, typically from GEM, into audio signals.
  • ofWindowResized ofWindowResized listens for window-resize events and outputs the resized window width and height as a two-float list.
  • pix_colorclassify The pix_colorclassify object analyzes an input RGBA image, classifying each pixel into one of six primary color categories (red, green, blue, yellow, black, white) or marking it as 'uncertain'.
  • pdp_plasma pdp_plasma generates plasma or turbulence image packets, with colour output as the default and greyscale output available.
  • pix_multiblob The pix_multiblob object detects multiple "blobs" within an image, defined as adjacent pixels exceeding a specified luminance threshold and minimum blobSize.
  • pix_clearblock The pix_clearblock object, part of the GEM (Graphics Environment for Multimedia) library, clears the visual content of an image while preserving its underlying texture information and setup.
  • part_targetsize The part_targetsize object is a GEM particle object that dynamically adjusts the size of particles over time.
  • pix_opencv_contours pix_opencv_contours finds contours in an incoming binarized image, passes the GEM list through its first outlet, and outputs contour-related data and summary information from its other outlets.
  • poffilm poffilm is a video player that loads a movie file and displays it at an optional width and height.
  • ambient The ambient object is a GEM manipulation object that sets the ambient color for all subsequent vertex operations in a 3D scene.
  • pofdepthtest pofdepthtest enables depth testing so rendering respects depth rather than draw order.
  • obj_exporter obj_exporter provides a way to create an OBJ file from Gem primitives, with save test1.obj specifying the output file.
  • gemmacoswindow The gemmacoswindow object is a macOS-specific Pure Data external that creates and manages graphical windows using Cocoa.
  • colorRGB The colorRGB object in Pure Data's GEM environment sets the color for subsequent graphical shapes and vertex operations.
  • pix_2pdp pix_2pdp captures the contents of a Gem pix and transforms it for PDP output, enabling uses such as feeding pix_video into PDP or recording Gem pixes with pdp_rec~.
  • fluid.waveform The fluid.waveform object visualizes multichannel audio waveforms, feature data, slices, and spectrograms within Pure Data.
  • camera The camera object in Pure Data is used to access and control video camera input.
  • fd_vidbuf fd_vidbuf links a named frame buffer to a video feed, making it useful for working with multiple video feeds.
  • disk The disk object renders a flat disk, optionally with a central hole, at the current GEM OpenGL position using the current color.
  • pix_opencv_surf pix_opencv_surf applies SURF (Speeded-Up Robust Features) to image frames for marking and tracking up to 10 points, with optional Delaunay processing.
  • pix_opencv_laplace pix_opencv_laplace applies a Laplace filter and is used as an edge detector.
  • pix_gain The pix_gain object applies a gain multiplier to the pixel values of an image (pix).
  • primTri The primTri object renders a triangle with gradient colors.
  • gem2pdp gem2pdp is a bridge between Gem and PDP that converts captured Gem output into PDP frames.
  • fd_pixcrop fd_pixcrop is a utility for “friendlier” cropping of a Gem gemlist, outputting the processed gemlist for further rendering.
  • redGreenBlue redGreenBlue outputs an integer representing an RGB color from red, green, and blue values.
  • gemglxwindow gemglxwindow is a Gem object designed for direct interaction with the X-window system, enabling the creation and management of an OpenGL rendering window.
  • pdp_pointcloud pdp_pointcloud converts an image into a point cloud containing the points with the highest intensity.
  • pix_blob The pix_blob object calculates the "center of gravity" of an image.
  • curve The curve object in Pure Data generates and renders a Bezier curve within the GEM environment.
  • fd_camara fd_camara is a GUI abstraction for handling Gem’s camera object.
  • gemcocoawindow The gemcocoawindow object creates and manages a graphical window on macOS using the Cocoa framework, specifically for GEM (Graphics Environment for Multimedia).
  • part_size The part_size object controls the size of particles within a particle system, typically used in graphical contexts like GEM.
  • ui.canvas ui.canvas is a UI canvas for drawing shapes, lines, text, images, icons, QR codes, and music notation using methods modeled on the Cairo graphics library.
  • pix_write The pix_write object captures a snapshot of the current GEM frame buffer and saves it to a file.
  • text3d The text3d object in Pure Data renders a single line of text within a 3D graphical environment, leveraging GEM's transformations.
  • pix_movement The pix_movement object is a time-based IIR filter that detects movement between consecutive video frames.
  • poffbo poffbo draws the following Pof tree into a framebuffer, for uses such as clipping a sub-scene, pre-drawing, and feedback; it also clips touch events.
  • fd_any2list fd_any2list takes an incoming Gem gemlist and outputs a dump.
  • pmpd3d The pmpd3d object implements 3D physical models based on a mass-spring-damper system.
  • ui.aview ui.aview displays a Pd array with a movable cursor and an editable range selection, making it suitable for viewing a waveform and choosing a region to play.
  • fragment_program The fragment_program object loads and applies ARB or NV fragment shaders, which perform per-pixel operations within OpenGL.
  • pix_dot The pix_dot object simplifies an input image by segmenting it and representing each segment with a white dot.
  • py.score py.score is a py4pd object associated with displaying a score, as suggested by the show message and the neoscore dependency.
  • pix_2grey The pix_2grey object converts an incoming pixel image (represented as a gemlist) to grayscale.
  • pofgetmatrix pofgetmatrix retrieves the current OpenGL matrix and its decomposition.
  • shininess The shininess object in GEM sets the shininess property of materials for subsequent OpenGL vertex operations.
  • slideSquares The slideSquares object renders a series of sliding rectangles within a GEM patch.
  • glsl_program The glsl_program object compiles and links GLSL shader modules (from glsl_fragment, glsl_vertex, and glsl_geometry) into an OpenGL 2.0 shader program.
  • pix_snap The pix_snap object captures the current content of the GEM (Graphics Environment for Multimedia) rendering buffer, effectively taking a screenshot.
  • gemlist_matrix gemlist_matrix is a Pure Data object within the GEM library that retrieves the current transformation matrix of an incoming gemlist.
  • textoutline The textoutline object renders a single line of outlined text within a GEM (Graphics Environment for Multimedia) context.
  • glsl_geometry The glsl_geometry object loads and compiles a GLSL geometry shader from a specified file.
  • ofUpdate ofUpdate outputs a bang every frame while the window exists, before ofDraw is called, so patches can update state ahead of drawing.
  • ui.plot~.lin1 The help patch does not instantiate or document ui.plot~.lin1, so its behavior and purpose cannot be determined from the supplied evidence.
  • pix_colormatrix The pix_colormatrix object transforms pixel values using a matrix.
  • GLdefine The GLdefine object retrieves the numerical value of an OpenGL configuration constant, specified by its name (e.g., GL_LINES, GL_POLYGON).
  • pix_metaimage The pix_metaimage object processes an input image to create an output composed of many smaller, scaled versions of the original, each altered to match the color of its corresponding area.
  • pix_rgb2hsv The pix_rgb2hsv object converts an RGB (Red, Green, Blue) image into the HSV (Hue, Saturation, Value) color space.
  • fd_img2feat fd_img2feat takes a Gem list and applies the image feature specified by its creation arguments, providing feature extraction for Gem images.
  • pix_opencv_hough_circles pix_opencv_hough_circles applies a Hough circle-detection algorithm to image input and reports each detected circle’s X/Y position and radius.
  • hsv hsv converts hue, saturation, and value into a 24-bit RGB integer, useful for generating Pd color values such as those sent with color $1.
  • rubber The rubber object is a GEM object that renders and distorts a square.
  • multimodel The multimodel object loads and renders multiple 3D Alias/Wavefront (.obj) models.
  • square The square object renders a square within the GEM graphical environment.
  • emission The emission object in Pure Data, part of the GEM library, sets the emission color for subsequent OpenGL vertex operations.
  • pofquad pofquad draws a quad and supports warping it by setting each draw corner independently.
  • fd_tracktopol fd_tracktopol maps a sigmund~ “tracks” output list to a triangle represented as a polygon of three points, with an index prepended to the output list.
  • light The light object in GEM adds a local point-light source to a 3D scene, allowing for realistic lighting effects.
  • hsv2rgb The hsv2rgb object converts color values from the Hue, Saturation, Value (HSV) color space to the Red, Green, Blue (RGB) color space.
  • pix_offset The pix_offset object adds an offset to the color channels of an incoming image (gemlist).
  • pofshader pofshader loads and controls a GLSL shader, with its first inlet enabling or disabling playback via play 0/1.
  • pofblend pofblend controls OpenGL blending in a Pof rendering chain by setting the source and destination blend factors.
  • pix_opencv_distrans pix_opencv_distrans performs distance processing as a morphology filter that can be used to preprocess images.
  • fd_background fd_background loads a Gem shader for extracting a background from video imagery.
  • pix_zoom The pix_zoom object, part of the GEM library, allows for magnifying or minifying pixels.
  • specularRGB The specularRGB object in GEM sets the specular color for subsequent OpenGL vertex operations.
  • pix_noise The pix_noise object generates a uniform noise image, with adjustable width and height.
  • pdp_scope~ pdp_scope~ is a very simple oscilloscope for visualizing a signal, such as one produced by osc~.
  • rgb2hsv The rgb2hsv object converts color values from the RGB (Red, Green, Blue) color space to the HSV (Hue, Saturation, Value/Luminance) color space.
  • fd_bufvid fd_bufvid reads a Gem list from a fd_vidbuf pixel buffer and loops through a specified number of frames, enabling the same buffer to be used multiple times.
  • pix_duotone The pix_duotone object processes a pixImage to reduce its colors to a duotone palette.
  • pix_color The pix_color object sets the color of each pixel in an input image to a specified RGBA value.
  • world_light world_light adds a directional light source to a GEM scene, simulating light rays from an infinite distance (parallel rays).
  • diffuseRGB The diffuseRGB object in Pure Data sets the diffuse color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • pofscale pofscale scales the following Pof tree along the x and y axes, with optional z-axis scaling for a 3D initial vector.
  • part_gravity The part_gravity object sets a gravitational vector for a particle system.
  • diffuse The diffuse object in Pure Data sets the diffuse color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • pix_refraction The pix_refraction object processes an input image by dividing it into rectangular cells and scaling the image content within each cell.
  • pofrotate pofrotate rotates the following Pof tree by an angle in degrees.
  • part_move The part_move object is a core component of the GEM particle system.
  • ui.plot~.ln ui.plot~.ln is a logarithmic signal plot example that uses plot.logspace~ to generate values and math.log~ to transform them for display in ui.plot~.
  • fd_logo fd_logo displays a bang-toggle based logo and has no inlets or outlets.
  • glsl_vertex The glsl_vertex object loads and compiles a GLSL vertex shader into a module.
  • pix_opencv_hu_compare pix_opencv_hu_compare compares contours with a reference pattern contour using Hu moments (CvMatchShape) and reports detected contours by position, width, and height.
  • pix_drum The pix_drum object analyzes incoming video streams, specifically detecting black pixels from the top of the image.
  • pofimage pofimage draws an image loaded from a file and can also expose it as a texture without drawing when the file argument is followed by TEX.
  • spectrograph~ The spectrograph~ object visualizes FFT amplitudes from 0 Hz to Nyquist, using a Hann window for spectral analysis.
  • shearXZ The shearXZ object applies a shear transformation to a GEM list, modifying the current OpenGL transformation matrix.
  • sphere3d The sphere3d object renders a deformable 3D sphere within GEM.
  • mtx_plot mtx_plot displays a matrix as a plot, clipping values to the range 0 (black) to 1 (white), with optional table-based colormaps.
  • cube The cube object renders a 3D cube within the GEM (Graphics Environment for Multimedia) context.
  • timeroll timeroll is a GUI control abstraction that displays a changing value over time.
  • pix_roi The pix_roi object sets a region of interest (ROI) on an image using normalized coordinates.
  • tLink3D The tLink3D object in Pure Data is designed for 3D physical modeling, simulating a link between two masses.
  • pix_add The pix_add object combines two input images of the same size by adding their pixel values.
  • pdp_convert pdp_convert converts an incoming packet to the format specified by its argument; here, image/grey/* requests a grayscale image format.
  • cylinder The cylinder object renders a 3D cylinder shape within the GEM environment, utilizing OpenGL.
  • pix_convolve The pix_convolve object applies a convolution kernel to a GEM pix (image).
  • pix_kaleidoscope The pix_kaleidoscope object applies a visual kaleidoscope effect to an input image, reflecting a selected portion multiple times around a central point.
  • pix_opencv_contours_convexhull pix_opencv_contours_convexhull finds the convex hull of the largest detected contour in an image, providing the hull’s vertex count and vertex coordinates.
  • pix_film+ tof/pix_film+ is a more user-friendly Gem movie-file player that passes a gemlist through its first inlet and outlet.
  • cube_sphere cube_sphere is a graphical object that displays a 2D projection of a hemisphere for positioning multiple sources by azimuth and elevation.
  • pix_opencv_colorfilt pix_opencv_colorfilt filters video by selecting a color from specified RGB components and applying a tolerance to the color selection.
  • gemsdl2window The gemsdl2window object creates and manages a graphical window using the SDL2 toolkit, providing an OpenGL context for rendering.
  • alpha The alpha object in Pure Data enables and controls alpha blending for graphical rendering within GEM.
  • pix_chroma_key The pix_chroma_key object performs real-time video compositing by comparing pixels from two input streams.
  • translateXYZ The translateXYZ object applies a 3D translation to the current transformation matrix within GEM (Graphics Environment for Multimedia).
  • pix_multitexture The pix_multitexture object applies multiple texture mappings within a GEM (Graphics Environment for Multimedia) network.
  • pix_delay The pix_delay object creates a frame-based delay line for images, allowing a series of images to be delayed.
  • pix_opencv_bgsubstract pix_opencv_bgsubstract performs simple background subtraction by comparing an image’s color values with a background reference, making it useful for detecting dynamic objects against a static background.
  • iem_logo iem_logo displays the IEM emblem using only Pd vanilla objects, without requiring externals.
  • gemw32window The gemw32window object is a GEM (Graphics Environment for Multimedia) object specific to Microsoft Windows, used for creating and managing a graphical output window.
  • tdh.util.framedCanvas tdh.util.framedCanvas is an autosized graph-on-parent abstraction that creates a movable, filled canvas outlined in a second color, useful for visually grouping areas of a Pd patch.
  • part_killold The part_killold object is a GEM particle system utility that removes particles older than a specified "kill time." This allows for controlling the lifespan of particles, making them disappear after a set duration within a visual context..
  • 02.nfp 02.nfp demonstrates creating a 1024×768 framebuffer with gemframebuffer, texturing it with grid.jpg, and displaying it across two nfp_flat_wall surfaces and one nfp_curved_wall surface.
  • 01.flat_projection flat_projection is an abstraction for configuring a flat multi-screen projection, defining how screens are physically connected and positioned in space even when screen and computer geometries differ.
  • GEMgl The GEMgl objects in Pure Data provide direct wrappers for OpenGL functions, enabling users to access low-level graphics rendering commands within their patches.
  • pix_composite The pix_composite object alpha-blends two input images (gemlists) of the same size.
  • vertex_program The vertex_program object in Pure Data loads and applies an ARB or NV vertex shader, enabling custom vertex processing within GEM.
  • pix_rtx The pix_rtx object performs a real-time "Time-X transformation" on incoming video frames, effectively swapping the time axis with the x-axis of the image.
  • render_trigger The render_trigger object provides timing signals related to the rendering process within a gemlist.
  • pix_opencv_dft pix_opencv_dft calculates the discrete Fourier transform of an image pattern and can be used for pattern matching.
  • pix_opencv_threshold pix_opencv_threshold performs pixel thresholding and is used as a filter to detect bright or dark pixels.
  • sphere The sphere object renders a 3D sphere within the GEM (Graphics Environment for Multimedia) context.
  • pix_tIIR The pix_tIIR object implements a time-based Infinite Impulse Response (IIR) filter for image processing within GEM.
  • modelfiler The modelfiler object loads 3D model data from Alias/Wavefront OBJ files into Pure Data tables.
  • model The model object in Pure Data renders 3D models saved in the Alias/Wavefront OBJ format.
  • pix_opencv_pgh_compare pix_opencv_pgh_compare compares contours from an image or video with a pattern contour and outputs the position and dimensions (X, Y, width, and height) of detected contours.
  • pix_sig2pix~ pix_sig2pix~ converts up to four incoming audio signals into an image, treating each signal as a color channel (red, green, blue, alpha).
  • image image displays an image in a Pd GUI and supports GIF, PPM, and PGM files.
  • ofReloadTextures ofReloadTextures listens for when textures need to be reloaded on Android and outputs a bang when this occurs.
  • pofhead pofhead is the root of a new drawing tree in the Pd OpenFrameworks (Pof) externals.
  • surface3d The surface3d object renders a 3D bicubic curve, with its shape controlled by a matrix of control points.
  • pix_share_write The pix_share_write object writes pixel data to a shared memory region, identified by a unique ID, width, height, and colorspace.
  • gemmanager The gemmanager object is an internal helper designed to interact with Gem's global state.
  • depth The depth object controls OpenGL's depth testing (Z-buffering) within GEM.
  • fd_bangem fd_bangem outputs a bang on the next Gem rendering frame when rendering is on, then shuts itself off.
  • pix_motionblur The pix_motionblur object applies a simple and fast motion blur effect to an incoming image stream.
  • pofbang pofbang listens to POF render events and outputs bangs for use during rendering.
  • my_canvas my_canvas is a cnv GUI canvas used as a visual background or labeled area whose geometry, position, font, and colors can be configured.
  • shearYX The shearYX object applies a shear transformation to a GEM object's current transformation matrix.
  • ui.plot~ ui.plot~ is a signal plotter for displaying one or more input signals, with configurable drawing modes, axes, grids, labels, colors, and y-axis ranges.
  • pix_mean_color The pix_mean_color object calculates the average color of an incoming image.
  • poflayer poflayer multiplexes multiple named layers on the same Pof rendering tree, allowing common processing alongside per-layer preprocessing and rendering.
  • ofDraw ofDraw provides a draw callback for drawing to the graphics window and outputs a bang every frame while the window exists.
  • pix_opencv_backgroundsubtractor pix_opencv_backgroundsubtractor performs background subtraction on incoming image streams using a selectable algorithm.
  • scope~ The scope~ object visualizes audio signals in the style of an oscilloscope.
  • conv.rgb2hex conv.rgb2hex converts separate red, green, and blue channel values into a #RRGGBB color symbol, outputting a value whenever any inlet changes.
  • part_velcone The part_velcone object is a GEM object designed to set properties for a cone, likely within a particle system, by interacting with a partList.
  • pix_background The pix_background object removes a static background from an incoming video stream by comparing it to a stored reference image.
  • pix_opencv_knear pix_opencv_knear performs OCR-like pattern recognition by comparing an incoming frame with a set of image patterns and outputting the comparison distance.
  • color.mix color.mix mixes two colors and outputs the result as data:color, making it useful for color interpolation.
  • part_draw The part_draw object is used to render a particle system within Pure Data's GEM environment.
  • ui.plot~.log10 ui.plot~.log10 is a help/example patch that uses ui.plot~ to display the output of math.log10~ for values generated by plot.logspace~.
  • cuboid The cuboid object renders a 3D box within GEM (Graphics Environment for Multimedia) at the current position and with the current color.
  • fd_rgbcol fd_rgbcol converts three integer RGB components, each in the range 0–9, into a single color value for use with Pd data structures.
  • pix_threshold The pix_threshold object applies a threshold filter to incoming image data.
  • pix_equal The pix_equal object processes an input RGBA image, generating a binary output image.
  • glsl The glsl object simplifies the creation of OpenGL Shading Language (GLSL) programs by wrapping various GLSL compilers and the linker into a single, easy-to-use interface.
  • part_velsphere The part_velsphere object is a GEM object designed to set a sphere with a specified radius for a particle list.
  • newWave The newWave object renders a dynamic, waving square using a mass-spring system, acting as a geometric object within GEM.
  • scopeXYZ~ The scopeXYZ~ object functions as a 3-dimensional oscilloscope, visualizing three input signals as excursions along the X, Y, and Z axes.
  • ndi_input ndi_input receives an NDI video source for use in Gem.
  • pix_texture The pix_texture object applies texture mapping to GEM graphics.
  • pix_backlight The pix_backlight object applies a backlighting effect to images by radially displacing pixels based on their luminance.
  • mpv mpv plays media into a GEM framebuffer, inheriting from gemframebuffer; its two leftmost outlets match gemframebuffer, while its third outlet reports media properties.
  • pix_flip The pix_flip object is a GEM object designed to flip images along a specified axis.
  • scope3d~ The scope3d~ object visualizes audio signals in a three-dimensional space, allowing users to observe the interplay of up to three input signals (X, Y, Z axes).
  • polygon_smooth The polygon_smooth object controls antialiasing for polygons within GEM, effectively smoothing their edges.
  • gemmouse The gemmouse object captures and outputs mouse events occurring within a GEM (Graphics Environment for Multimedia) window.
  • py.vispy py.vispy appears to provide a VisPy-based visualization for the signal generated by osc~, with its display color controlled by an rgb message.
  • c.blackboard c.blackboard is a drawable canvas for making mouse-drawn lines and rendering shapes, paths, arcs, GIF images, and text from messages.
  • rgb2yuv The rgb2yuv object converts color values from the RGB (Red, Green, Blue) color space to the YUV (Luma, Chroma) color space.
  • fd_gem2feat fd_gem2feat takes a GEM list and applies the timbreID-style feature named by its argument, such as specBrightness.
  • pqtorusknots The pqtorusknots object renders a customizable 3D torus knot within a GEM (Graphics Environment for Multimedia) context.
  • Gem The Gem object serves as a meta-object for the Pure Data Graphics Environment for Multimedia (GEM).
  • part_info The part_info object provides detailed information about each particle within a particle system, typically set up with part_head and other part_ objects.
  • pofonce pofonce draws the next frame on receipt of a bang, allowing drawings to be optimized by updating them only when needed.
  • ___textbbox__ The _textbbox object is a helper for visualizing bounding box information generated by Pure Data's text* objects.
  • curve3d The curve3d object renders a 3D Bezier curve.
  • pix_opencv_morphology pix_opencv_morphology applies a morphology filter to image data, with open/close and erode/dilate modes, to help focus on bright or dark zones.
  • pix_data The pix_data object retrieves the color of a specified pixel within an image when triggered.
  • fd_gemloop fd_gemloop stores an incoming Gem gemlist in a buffer for later playback or export of the stored images as JPEG files.
  • pix_normalize The pix_normalize object processes image data to enhance visual contrast.
  • gemframebuffer The gemframebuffer object renders a graphical scene into an off-screen texture, which can then be used as an input for further rendering operations.
  • glsl_fragment The glsl_fragment object loads and compiles GLSL fragment shaders, outputting a module ID for use with glsl_program.
  • poftranslate poftranslate translates the following Pof tree by an (x, y, z) vector.
  • gemmacwindow The gemmacwindow object is a legacy Pure Data external designed for macOS (up to OSX 10.6) that creates and manages graphical windows using the Carbon API.
  • ui.plot~.lin3 The help patch demonstrates ui.plot~ receiving a signal from sig~, with a numeric control value scaled by / 10.
  • ripple The ripple object is a GEM geometric object that renders and distorts a square.
  • shearZY The shearYZ object applies a shear transformation to a gemlist, modifying the current OpenGL transformation matrix.
  • gemhead The gemhead object initiates and manages a GEM (Graphics Environment for Multimedia) rendering chain.
  • pix_contrast pix_contrast is a GEM object designed to adjust the contrast and saturation of an input image.
  • fd_shader fd_shader is a Gem-dependent tool for loading shaders and applying them to a Gem list.
  • pix_video The pix_video object captures live video input from various cameras (USB, FireWire, capture cards) supported by the operating system.
  • fd_pix_shift fd_pix_shift takes a Gem list and produces four shifted, separated Gem lists.
  • specular The specular object sets the specular color for subsequent 3D vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • pix_frei0r The pix_frei0r object loads and applies Frei0r video effects, a minimalistic plugin API for real-time video processing.
  • triangle The triangle object in Pure Data is a GEM (Graphics Environment for Multimedia) object that renders an isosceles triangle.
  • pix_mix The pix_mix object functions as a video mixer, blending two input images based on provided mixing factors.
  • teapot The teapot object renders a 3D teapot shape within a GEM patch.
  • hsl The hsl help patch does not document the object's behavior directly; it only refers to the help file for hueSaturationLuminosity.
  • textextruded The textextruded object renders a single line of extruded text within the GEM environment, applying current color and 3D transformations.
  • conv.hsl2rgb conv.hsl2rgb converts HSL color values to RGB for use in color-processing patches.
  • pix_halftone The pix_halftone object applies a halftone effect to an incoming image, transforming it into patterns of dots or diamonds, similar to those found in newspaper prints.
  • pix_buffer_read The pix_buffer_read object reads image data from a named pix_buffer.
  • pix_opencv_findchessboardcorners pix_opencv_findchessboardcorners searches an image for the inner corners of a chessboard pattern, which is useful for calibrating several cameras together.
  • pofsphere pofsphere draws a sphere that can be textured.
  • pix_opencv_lk pix_opencv_lk performs Lukas–Kanade corner-point tracking, with corner detection based on the Shi–Tomasi method.
  • poftexts poftexts draws text using ofxFontStash and supports multiline layout controls such as width, line height, spacing, alignment, clipping, and underlining.
  • iem_image iem_image displays a chosen GIF file in a Pure Data patch.
  • pix_opencv_facetracker pix_opencv_facetracker finds and tracks a face in a GEM image stream using the FaceTracker library, passing the gemlist from its inlet to its outlet.
  • timeline wavview/timeline displays time marks for a wavview, including the times at the left and right view bounds, and automatically follows the view width.
  • shearZX The shearZX object is a GEM manipulation object that applies a shear transformation to the current transformation matrix.
  • grainflow.waveform grainflow.waveform visualizes one or more sample arrays in a waveform display, including grain and buffer-position information from grainflow~.
  • pdp_constant pdp_constant creates an image filled with a constant, producing a colour image by default or a greyscale image when selected.
  • pix_record The pix_record object in Pure Data is used to record sequences of video frames (pixes) to an output file, pipe, or video device.
  • part_targetcolor The part_targetcolor object is a GEM object designed for particle systems, enabling dynamic color changes for particles.
  • part_vertex The part_vertex object is a core component for GEM-based particle systems.
  • imageVert The imageVert object maps an input image (pix) to a 3D geometric representation.
  • graph~ graph~ is a simple abstraction designed for visualizing audio signals.
  • separator The separator object in Pure Data's GEM library isolates transformation effects between parallel rendering chains.
  • part_damp The part_damp object is a GEM particle system utility that modifies the velocity of particles.
  • pix_coloralpha The pix_coloralpha object calculates and sets the alpha channel of an RGBA image.
  • pp.waveform pp.waveform draws a waveform from a named source array, with configurable dimensions, Y range, color, thickness, and resolution.
  • gemlist The gemlist object stores a list of GEM graphics commands or data.
  • part_render The part_render object is used within the GEM environment to draw particle systems.
  • animate tof/animate animates the object boxes inside a Pd patch, providing visual effects for patch fun.
  • part_follow The part_follow object is a GEM particle system component that enables particles to follow each other, creating dynamic visual effects.
  • gemwin The gemwin object manages the output window for GEM (Graphics Environment for Multimedia), controlling its properties like size, fullscreen mode, and title.
  • pix_curve The pix_curve object applies color curves to an image, modifying its RGBA channels.
  • pix_alpha The pix_alpha object in Pure Data modifies the alpha channel of an RGBA image based on RGB color thresholding.
  • pdp_flip_lr pdp_flip_lr flips PDP image data horizontally, exchanging the left and right sides.
  • pix_test The pix_test object generates test images, primarily featuring SMPTE colorbars and black/white gradients.
  • pofrect pofrect draws a rectangle in the Pd OpenFrameworks environment, with width and height supplied as arguments or through inlets.
  • pix_opencv_contours_convexity pix_opencv_contours_convexity finds convexity defects in a detected contour, with each defect defined by a start point, depth point, and end point.
  • pix_opencv_blobtrack pix_opencv_blobtrack implements an all-in-one blob-tracking pipeline for RGBA or grayscale images.
  • pix_multiimage The pix_multiimage object loads multiple image files (TIFF, JPEG, PNG) into memory, which can then be used as textures or for bitblitting within GEM.
  • color.scale color.scale creates a color scale by interpolating through a list of colors.
  • cone The cone object renders a 3D cone at the current OpenGL position using the current color.
  • gemglfw3window The gemglfw3window object uses GLFW (version 3) to create and manage graphical windows within Pure Data, primarily for OpenGL rendering.
  • polygon The polygon object in Pure Data renders a polygon graphic within the GEM environment.
  • colorSquare The colorSquare object renders a square at the current position within a GEM (Graphics Environment for Multimedia) context.
  • pp.wfdisplay pp.wfdisplay displays the waveform of a source array at a fixed width and height.
  • blinkenlights blinkenlights is a Blinkenlights movie player and a configurable pixel grid that can also display ASCII-style graphics.
  • pix_hsv2rgb The pix_hsv2rgb object converts an image's color representation from HSV (Hue, Saturation, Value) to RGB (Red, Green, Blue).
  • text2d The text2d object in Pure Data renders a line of text using TrueType fonts within a GEM environment.
  • accumrotate The accumrotate object is a GEM utility that applies accumulated rotations to a 3D transformation matrix.
  • pix_fiducialtrack The pix_fiducialtrack object detects and tracks fiducial markers in black and white grayscale images, utilizing a system similar to reacTable.
  • hueSaturationLuminosity hueSaturationLuminosity outputs a numeric representation of a color in the HSL color space, with hue, saturation, and luminosity each ranging from 0 to 255.
  • part_orbitpoint The part_orbitpoint object is a GEM particle system object that causes particles to orbit a specified 3D position (x, y, z).
  • shearYZ The shearYZ object applies a shear transformation to the current OpenGL transformation matrix, affecting subsequent graphical rendering.
  • gemvertexbuffer The gemvertexbuffer object efficiently renders geometric objects by managing a Vertex Buffer Object (VBO).
  • pix_imageInPlace The pix_imageInPlace object efficiently loads multiple image files (TIFF, JPEG, PNG) into texture RAM, enabling very fast switching between them.
  • poftext poftext draws text using a named font in a Pd OpenFrameworks rendering chain.
  • pix_coordinate pix_coordinate is a GEM object designed to set and remap the S and T texture coordinates for a pix object.
  • conv.color2rgba conv.color2rgba converts a supported named color, full hexadecimal color value (#RRGGBB or #RRGGBBAA), or color data into separate red, green, blue, and alpha channel values.
  • pix_rectangle pix_rectangle is a GEM object that renders a rectangle onto an existing image buffer (pix-buffer).
  • gemlist_info The gemlist_info object takes a gemlist as input and decomposes its current transformation matrix into basic transformations.
  • pix_writer The pix_writer object saves the current GEM texture (image) to a file on disk.
  • part_information The part_information object provides detailed data for all particles within a particle system, typically set up using part_head and other part_ objects.
  • scaleXYZ The scaleXYZ object scales a GEM (Graphics Environment for Multimedia) object along its X, Y, and Z axes.
  • pix_indycam The pix_indycam object captures video signals from an SGI video camera, outputting them as pixel data within Pure Data.
  • pix_buffer_write The pix_buffer_write object writes incoming image data (a gemlist) into a specified pix_buffer at a given index.
  • pdp_flip_tb pdp_flip_tb flips PDP image data vertically, exchanging the top and bottom.
  • pix_opencv_of_lk pix_opencv_of_lk applies the Lucas–Kanade optical-flow algorithm to calculate movement in an image stream, including the largest movement amplitude, its block angle, and the average block-movement angle.