Skip to content

zexy

zexy provides several addon objects for the Pd computer music system, including (but not limited to) objects for message handling (construction, parsing, control flow), signal handling (synthesis, analysis, comparison) et al.

Contributors

People who contribute to this project.

Objects

  • &&~ The &&~ object performs a logical AND operation on two input signals.
  • 0x3c0x7e This Pure Data object, 0x3c0x7e, is an abstraction for the signal comparison object <~.
  • 0x3e0x7e The >~ object compares two incoming audio signals, outputting a signal that is true (non-zero) when the first inlet's signal is greater than the second.
  • 0x7c0x7c0x7e The Pure Data object ||~ performs a logical OR operation on two incoming audio signals.
  • ==~ The ==~ object compares two incoming audio signals for equality, outputting a signal that indicates whether they are identical.
  • 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.
  • GLdefine The GLdefine object retrieves the numerical value of an OpenGL configuration constant, specified by its name (e.g., GL_LINES, GL_POLYGON).
  • Gem The Gem object serves as a meta-object for the Pure Data Graphics Environment for Multimedia (GEM).
  • ___textbbox__ The _textbbox object is a helper for visualizing bounding box information generated by Pure Data's text* objects.
  • a2l The a2l object converts any incoming message into a list, providing a unified data format for further processing.
  • absgn~ The absgn~ object calculates the absolute value and the signum of an incoming audio signal.
  • abs~ The abs~ object calculates the absolute value of an incoming audio signal.
  • accumrotate The accumrotate object is a GEM utility that applies accumulated rotations to a 3D transformation matrix.
  • alpha The alpha object in Pure Data enables and controls alpha blending for graphical rendering within GEM.
  • ambient The ambient object is a GEM manipulation object that sets the ambient color for all subsequent vertex operations in a 3D scene.
  • ambientRGB The ambientRGB object in Pure Data sets the ambient color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) patch.
  • any2list The any2list object converts any incoming message into a list, standardizing various message types into a list format for further processing.
  • atof The atof object converts an ASCII symbol (text) into a floating-point number.
  • atoi The atoi object converts an incoming symbol (string) into a numerical representation.
  • blockmirror~ The blockmirror~ object reverses an incoming audio signal in time, processing it in fixed-size blocks (signal vectors).
  • blockswap~ The blockswap~ object swaps the upper and lower halves of an incoming audio signal vector.
  • camera The camera object in Pure Data is used to access and control video camera input.
  • cart2pol The cart2pol object converts 3D Cartesian coordinates (x, y, z) into 3D polar coordinates.
  • cart2sph The cart2sph object converts 3D Cartesian coordinates (x, y, z) into spherical coordinates (radius, azimuth, elevation).
  • color The color object in Pure Data sets the color for all subsequent GEM (Graphics Environment for Multimedia) shape and vertex operations.
  • colorRGB The colorRGB object in Pure Data's GEM environment sets the color for subsequent graphical shapes and vertex operations.
  • colorSquare The colorSquare object renders a square at the current position within a GEM (Graphics Environment for Multimedia) context.
  • cone The cone object renders a 3D cone at the current OpenGL position using the current color.
  • coordinates The cart2pol, pol2sph, sph2cart, cart2sph, pol2cart, and sph2pol objects convert between Cartesian, Polar, and Spherical coordinate systems.
  • cube The cube object renders a 3D cube within the GEM (Graphics Environment for Multimedia) context.
  • cuboid The cuboid object renders a 3D box within GEM (Graphics Environment for Multimedia) at the current position and with the current color.
  • curve The curve object in Pure Data generates and renders a Bezier curve within the GEM environment.
  • curve3d The curve3d object renders a 3D Bezier curve.
  • cylinder The cylinder object renders a 3D cylinder shape within the GEM environment, utilizing OpenGL.
  • date The date object retrieves the current system date and time.
  • demultiplex The demultiplex object routes data from its left inlet to one of its outlets.
  • demultiplex~ The demultiplex~ (or demux~) object takes a single audio or control signal and routes it to one of its multiple outlets.
  • demux The demux object acts as a demultiplexer, routing data from its left inlet to one of its multiple outlets.
  • demux~ The demux~ object acts as a signal demultiplexer, routing a single audio signal from its inlet to one of its multiple outlets.
  • depth The depth object controls OpenGL's depth testing (Z-buffering) within GEM.
  • dfreq~ The dfreq~ object is a computationally efficient frequency detector that estimates the frequency of an incoming audio signal by counting zero-crossings.
  • diffuse The diffuse object in Pure Data sets the diffuse color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • diffuseRGB The diffuseRGB object in Pure Data sets the diffuse color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • digidistort The digidistort object provides digital distortion effects for audio signals.
  • dirac~ The dirac~ object generates a single unit sample (a unit impulse) as an audio signal.
  • disk The disk object renders a flat disk, optionally with a central hole, at the current GEM OpenGL position using the current color.
  • drip The drip object unfolds a package (list) into a sequence of individual elements, outputting them one by one with a configurable delay in milliseconds.
  • emission The emission object in Pure Data, part of the GEM library, sets the emission color for subsequent OpenGL vertex operations.
  • emissionRGB The emissionRGB object sets the emission color for subsequent vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • envrms~ The envrms~ object is an envelope follower designed for audio signals.
  • fifop The fifop object implements a First-In-First-Out (FIFO) queue system that manages multiple internal queues, each capable of being assigned a floating-point priority.
  • fragment_program The fragment_program object loads and applies ARB or NV fragment shaders, which perform per-pixel operations within OpenGL.
  • freadln The freadln object reads text files line by line, outputting each line as a list.
  • fwriteln The fwriteln object writes text files line by line, serving as a simplified version of textfile.
  • gemargs The gemargs object retrieves arguments and initialization messages passed to its parent patch, enabling consistent object initialization patterns within GEM abstractions.
  • gemcocoawindow The gemcocoawindow object creates and manages a graphical window on macOS using the Cocoa framework, specifically for GEM (Graphics Environment for Multimedia).
  • gemcubeframebuffer The gemcubeframebuffer object renders a 3D scene onto the faces of a GL cubemap texture.
  • 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.
  • gemglfw2window The gemglfw2window object creates and manages a graphical window using GLFW (version 2) within Pure Data's GEM environment.
  • gemglfw3window The gemglfw3window object uses GLFW (version 3) to create and manage graphical windows within Pure Data, primarily for OpenGL rendering.
  • gemglutwindow The gemglutwindow object creates and manages an OpenGL rendering window using the GLUT (OpenGL Utility Toolkit) library.
  • 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.
  • gemhead The gemhead object initiates and manages a GEM (Graphics Environment for Multimedia) rendering chain.
  • gemkeyboard The gemkeyboard object captures keyboard events occurring within a GEM window.
  • gemkeyname The gemkeyname object captures keyboard events occurring within the GEM window.
  • gemlist The gemlist object stores a list of GEM graphics commands or data.
  • gemlist_info The gemlist_info object takes a gemlist as input and decomposes its current transformation matrix into basic transformations.
  • gemlist_matrix gemlist_matrix is a Pure Data object within the GEM library that retrieves the current transformation matrix of an incoming gemlist.
  • gemmacoswindow The gemmacoswindow object is a macOS-specific Pure Data external that creates and manages graphical windows using Cocoa.
  • 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.
  • gemmanager The gemmanager object is an internal helper designed to interact with Gem's global state.
  • gemmouse The gemmouse object captures and outputs mouse events occurring within a GEM (Graphics Environment for Multimedia) window.
  • gemorb The gemorb object connects to a SpaceOrb 3D controller via a specified serial port (comport).
  • gemreceive gemreceive is an ordered message receiver for the GEM (Graphics Environment for Multimedia) environment.
  • gemrepeat The gemrepeat object is a GEM manipulation object designed to duplicate incoming gemlist messages.
  • gemsdl2window The gemsdl2window object creates and manages a graphical window using the SDL2 toolkit, providing an OpenGL context for rendering.
  • gemsdlwindow gemsdlwindow is a Pure Data object that utilizes the SDL (Simple DirectMedia Layer) toolkit to create and manage graphical windows.
  • gemtablet The gemtablet object in Pure Data interfaces with and responds to events from a graphics tablet.
  • gemvertexbuffer The gemvertexbuffer object efficiently renders geometric objects by managing a Vertex Buffer Object (VBO).
  • 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.
  • gemwin The gemwin object manages the output window for GEM (Graphics Environment for Multimedia), controlling its properties like size, fullscreen mode, and title.
  • 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.
  • glsl_fragment The glsl_fragment object loads and compiles GLSL fragment shaders, outputting a module ID for use with glsl_program.
  • glsl_geometry The glsl_geometry object loads and compiles a GLSL geometry shader from a specified file.
  • 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.
  • glsl_vertex The glsl_vertex object loads and compiles a GLSL vertex shader into a module.
  • glue The glue object combines two "packages" or messages, typically by appending or prepending one to the other.
  • hsv2rgb The hsv2rgb object converts color values from the Hue, Saturation, Value (HSV) color space to the Red, Green, Blue (RGB) color space.
  • imageVert The imageVert object maps an input image (pix) to a 3D geometric representation.
  • l The l object (an alias for list) is used to store and manipulate lists in Pure Data.
  • l2i The l2i object converts all floating-point numbers within an incoming list to integers.
  • l2s The list2symbol (or l2s) object converts an incoming list into a single symbol.
  • length The length object, part of the zexy external library, determines the number of elements in an incoming list.
  • lifop The lifop object manages multiple Last-In-First-Out (LIFO) stacks, each assigned a floating-point priority.
  • light The light object in GEM adds a local point-light source to a 3D scene, allowing for realistic lighting effects.
  • limiter~ The limiter~ object in Pure Data functions as an audio dynamics processor, preventing signals from exceeding a specified output level to avoid clipping.
  • linear_path The linear_path object reads out values from a specified table.
  • list2int The list2int object converts all floating-point numbers within an incoming list to integers.
  • list2lists The list2lists object splits an incoming list into multiple sublists.
  • list2symbol The list2symbol object converts an incoming list into a single symbol.
  • lister The lister object (alias l) stores and outputs lists, and can also append one list to another.
  • listfind The listfind object searches for occurrences of a sublist within a larger list.
  • longload The longload object is an experimental utility designed to simulate a long loading time within a Pure Data patch.
  • lpt The lpt object in Pure Data allows writing and reading data to and from a computer's parallel port.
  • makesymbol The makesymbol object converts an incoming list (up to 10 members) into a single symbol.
  • matchbox The matchbox object stores a collection of lists and retrieves them based on various matching algorithms.
  • mavg The mavg object implements a moving average filter, smoothing incoming float values by averaging a specified number of recent samples.
  • mesh_line The mesh_line object renders a line mesh within the GEM environment, drawing it at the current position with the current color.
  • mesh_square The mesh_square object renders a square mesh at the current position and color, with its size controllable via the second inlet.
  • minmax The minmax object takes a list of floating-point numbers as input.
  • model The model object in Pure Data renders 3D models saved in the Alias/Wavefront OBJ format.
  • modelfiler The modelfiler object loads 3D model data from Alias/Wavefront OBJ files into Pure Data tables.
  • msgfile The msgfile object reads and writes messages to text files, extending the functionality of textfile.
  • multiline~ The multiline~ object performs line-interpolated multiplication of multiple input signals.
  • multimodel The multimodel object loads and renders multiple 3D Alias/Wavefront (.obj) models.
  • multiplex The multiplex object routes data from one of its multiple inlets to a single outlet.
  • multiplex~ The multiplex~ object functions as a signal multiplexer, allowing you to select one signal from multiple inputs to be passed to a single output.
  • multireceive The multireceive object allows a single outlet to receive messages from multiple send objects.
  • mux The mux object functions as a multiplexer, directing the signal from one of its multiple input inlets to its single outlet.
  • mux~ The mux~ object acts as a signal multiplexer, routing one of its multiple signal inlets to a single signal outlet.
  • newWave The newWave object renders a dynamic, waving square using a mass-spring system, acting as a geometric object within GEM.
  • niagara The niagara object divides an incoming message or list into two sub-packages.
  • noish~ The noish~ object generates bandlimited noise by drawing a random number every n samples and interpolating between these values.
  • noisi~ The noisi~ object generates bandlimited noise by drawing random numbers at a specified rate in Hz and interpolating between them.
  • nop The nop object in Pure Data acts as a "no operation" pass-through.
  • operating_system The operating_system object outputs a symbol representing the operating system Pure Data is currently running on.
  • ortho ortho is a GEM object in Pure Data that controls the rendering projection for subsequent graphical objects.
  • pack The pack object combines multiple incoming atoms (numbers, symbols, or pointers) from its inlets into a single list message.
  • packel The packel object extracts elements from a list, referred to as a "package." It can retrieve a specific element by its index (positive for from the beginning, negative for from the end), or the entire list if the index is 0.
  • pack~ The pack~ object converts incoming audio signals into lists of floating-point numbers.
  • part_color The part_color object is a component of the GEM particle system, designed to define the visual color of particles.
  • part_damp The part_damp object is a GEM particle system utility that modifies the velocity of particles.
  • part_draw The part_draw object is used to render a particle system within Pure Data's GEM environment.
  • part_follow The part_follow object is a GEM particle system component that enables particles to follow each other, creating dynamic visual effects.
  • part_gravity The part_gravity object sets a gravitational vector for a particle system.
  • part_head The part_head object initializes and manages a particle system within 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.
  • 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.
  • 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..
  • part_killslow The part_killslow object is a GEM particle system utility designed to manage particle populations.
  • part_move The part_move object is a core component of the GEM particle system.
  • part_orbitpoint The part_orbitpoint object is a GEM particle system object that causes particles to orbit a specified 3D position (x, y, z).
  • part_render The part_render object is used within the GEM environment to draw particle systems.
  • 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).
  • part_size The part_size object controls the size of particles within a particle system, typically used in graphical contexts like GEM.
  • 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.
  • part_targetcolor The part_targetcolor object is a GEM object designed for particle systems, enabling dynamic color changes for particles.
  • part_targetsize The part_targetsize object is a GEM particle object that dynamically adjusts the size of particles over time.
  • 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.
  • part_velocity The part_velocity object in Pure Data, part of the GEM library, sets the initial velocity of newly emitted particles.
  • part_velsphere The part_velsphere object is a GEM object designed to set a sphere with a specified radius for a particle list.
  • part_vertex The part_vertex object is a core component for GEM-based particle systems.
  • pdf~ The pdf~ object calculates the probability density function of an incoming signal.
  • pix_2grey The pix_2grey object converts an incoming pixel image (represented as a gemlist) to grayscale.
  • pix_a_2grey The pix_a_2grey object converts an input RGBA image to grayscale based on its alpha channel.
  • pix_add The pix_add object combines two input images of the same size by adding their pixel values.
  • pix_aging The pix_aging object applies a Super8-like aging effect to images or video streams, simulating the look of old film.
  • pix_alpha The pix_alpha object in Pure Data modifies the alpha channel of an RGBA image based on RGB color thresholding.
  • pix_background The pix_background object removes a static background from an incoming video stream by comparing it to a stored reference image.
  • pix_backlight The pix_backlight object applies a backlighting effect to images by radially displacing pixels based on their luminance.
  • 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.
  • pix_bitmask The pix_bitmask object applies a bitmask to incoming image data (gemlist), allowing selective modification or filtering of pixels.
  • pix_blob The pix_blob object calculates the "center of gravity" of an image.
  • 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_blur The pix_blur object applies a blur effect to an image or video stream within Pure Data's GEM environment.
  • pix_buf The pix_buf object, also known as pix_separator, buffers image data (pixes) to store the results of time-consuming processing operations.
  • pix_buffer pix_buffer is a named storage object for images, functioning similarly to a table but without direct visual access to its contents.
  • pix_buffer_filmopen The pix_buffer_filmopen object reads a movie file into a named pix_buffer for subsequent image processing within GEM.
  • pix_buffer_read The pix_buffer_read object reads image data from a named pix_buffer.
  • pix_buffer_write The pix_buffer_write object writes incoming image data (a gemlist) into a specified pix_buffer at a given index.
  • pix_chroma_key The pix_chroma_key object performs real-time video compositing by comparing pixels from two input streams.
  • 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.
  • pix_color The pix_color object sets the color of each pixel in an input image to a specified RGBA value.
  • pix_coloralpha The pix_coloralpha object calculates and sets the alpha channel of an RGBA image.
  • 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'.
  • pix_colormatrix The pix_colormatrix object transforms pixel values using a matrix.
  • pix_colorreduce The pix_colorreduce object reduces the number of colors in a pixImage based on its statistical information.
  • pix_compare The pix_compare object compares two input image streams pixel by pixel based on their luminance.
  • pix_composite The pix_composite object alpha-blends two input images (gemlists) of the same size.
  • pix_contrast pix_contrast is a GEM object designed to adjust the contrast and saturation of an input image.
  • pix_convert The pix_convert object transforms the color space of an image within GEM.
  • pix_convolve The pix_convolve object applies a convolution kernel to a GEM pix (image).
  • pix_coordinate pix_coordinate is a GEM object designed to set and remap the S and T texture coordinates for a pix object.
  • pix_crop The pix_crop object is a GEM utility that extracts a sub-image from an incoming image.
  • pix_curve The pix_curve object applies color curves to an image, modifying its RGBA channels.
  • pix_data The pix_data object retrieves the color of a specified pixel within an image when triggered.
  • pix_deinterlace The pix_deinterlace object applies a deinterlacing algorithm to incoming images, primarily by averaging neighboring rows.
  • pix_delay The pix_delay object creates a frame-based delay line for images, allowing a series of images to be delayed.
  • pix_diff The pix_diff object calculates the absolute difference between two input images, which must be of the same size.
  • pix_dot The pix_dot object simplifies an input image by segmenting it and representing each segment with a white dot.
  • pix_draw The pix_draw object directly draws pixels onto the screen without applying any texture mapping.
  • pix_drum The pix_drum object analyzes incoming video streams, specifically detecting black pixels from the top of the image.
  • 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.
  • pix_duotone The pix_duotone object processes a pixImage to reduce its colors to a duotone palette.
  • pix_equal The pix_equal object processes an input RGBA image, generating a binary output image.
  • pix_fiducialtrack The pix_fiducialtrack object detects and tracks fiducial markers in black and white grayscale images, utilizing a system similar to reacTable.
  • pix_film The pix_film object loads and plays digital video files, providing frames as textures for use within Pure Data's GEM environment.
  • pix_flip The pix_flip object is a GEM object designed to flip images along a specified axis.
  • pix_freeframe The pix_freeframe object loads and applies FreeFrame video effects in real-time.
  • pix_frei0r The pix_frei0r object loads and applies Frei0r video effects, a minimalistic plugin API for real-time video processing.
  • pix_gain The pix_gain object applies a gain multiplier to the pixel values of an image (pix).
  • pix_grey The pix_grey object converts the color space of an incoming image to grayscale.
  • 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_histo pix_histo calculates the histogram (density function) of an input image, storing the results in Pure Data tables.
  • 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.
  • pix_hsv2rgb The pix_hsv2rgb object converts an image's color representation from HSV (Hue, Saturation, Value) to RGB (Red, Green, Blue).
  • 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_imageInPlace The pix_imageInPlace object efficiently loads multiple image files (TIFF, JPEG, PNG) into texture RAM, enabling very fast switching between them.
  • pix_indycam The pix_indycam object captures video signals from an SGI video camera, outputting them as pixel data within Pure Data.
  • 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_invert The pix_invert object inverts the colors of an input image, transforming black pixels to white and vice-versa.
  • 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_levels The pix_levels object performs image level adjustments, similar to brightness and contrast controls.
  • 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.
  • pix_mano The pix_mano object tracks light-reflecting objects within a video stream by applying a threshold and analyzing their contours.
  • pix_mask The pix_mask object applies a mask to an image using the luminance of a second image.
  • pix_mean_color The pix_mean_color object calculates the average color of an incoming image.
  • 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_mix The pix_mix object functions as a video mixer, blending two input images based on provided mixing factors.
  • pix_motionblur The pix_motionblur object applies a simple and fast motion blur effect to an incoming image stream.
  • pix_movement The pix_movement object is a time-based IIR filter that detects movement between consecutive video frames.
  • pix_movement2 The pix_movement2 object is a time-based IIR filter designed for motion detection in video streams.
  • 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_multiblob The pix_multiblob object detects multiple "blobs" within an image, defined as adjacent pixels exceeding a specified luminance threshold and minimum blobSize.
  • 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.
  • pix_multiply The pix_multiply object in Pure Data multiplies two input images (pixes) together, requiring them to be of the same size.
  • pix_multitexture The pix_multitexture object applies multiple texture mappings within a GEM (Graphics Environment for Multimedia) network.
  • pix_noise The pix_noise object generates a uniform noise image, with adjustable width and height.
  • pix_normalize The pix_normalize object processes image data to enhance visual contrast.
  • pix_offset The pix_offset object adds an offset to the color channels of an incoming image (gemlist).
  • pix_pix2sig~ The pix_pix2sig~ object converts incoming image data, typically from GEM, into audio signals.
  • pix_posterize pix_posterize applies a posterization effect to images within the GEM environment.
  • pix_puzzle The pix_puzzle object shuffles an input image by cutting it into rectangular pieces and rearranging them.
  • pix_rds The pix_rds object generates black and white random dot stereograms, commonly known as "magic eye" images.
  • 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.
  • pix_rectangle pix_rectangle is a GEM object that renders a rectangle onto an existing image buffer (pix-buffer).
  • pix_refraction The pix_refraction object processes an input image by dividing it into rectangular cells and scaling the image content within each cell.
  • pix_resize The pix_resize object resizes an image to specified dimensions.
  • pix_rgb2hsv The pix_rgb2hsv object converts an RGB (Red, Green, Blue) image into the HSV (Hue, Saturation, Value) color space.
  • 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_roi The pix_roi object sets a region of interest (ROI) on an image using normalized coordinates.
  • pix_roll The pix_roll object scrolls or rolls an image, wrapping its content around the edges.
  • 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.
  • pix_scanline The pix_scanline object processes image rows, either duplicating or removing them.
  • pix_set The pix_set object allows you to create or modify image data by providing a flat list of pixel values.
  • pix_share_read The pix_share_read object reads pixel data from a shared memory region, identified by a unique ID.
  • 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.
  • 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).
  • pix_snap The pix_snap object captures the current content of the GEM (Graphics Environment for Multimedia) rendering buffer, effectively taking a screenshot.
  • 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_subtract The pix_subtract object subtracts the pixel values of one image from another, requiring both input images to be of the same size.
  • pix_tIIR The pix_tIIR object implements a time-based Infinite Impulse Response (IIR) filter for image processing within GEM.
  • pix_takealpha The pix_takealpha object transfers the alpha channel from a second input image to a first input image.
  • pix_test The pix_test object generates test images, primarily featuring SMPTE colorbars and black/white gradients.
  • pix_texture The pix_texture object applies texture mapping to GEM graphics.
  • pix_threshold The pix_threshold object applies a threshold filter to incoming image data.
  • pix_threshold_bernsen pix_threshold_bernsen applies a dynamic tiled threshold filter to greyscale images for binarization.
  • pix_video The pix_video object captures live video input from various cameras (USB, FireWire, capture cards) supported by the operating system.
  • pix_write The pix_write object captures a snapshot of the current GEM frame buffer and saves it to a file.
  • pix_writer The pix_writer object saves the current GEM texture (image) to a file on disk.
  • pix_yuv The pix_yuv object converts the colorspace of an image to the YUV format.
  • pix_zoom The pix_zoom object, part of the GEM library, allows for magnifying or minifying pixels.
  • pol2cart The pol2cart object converts 3D polar coordinates (radius r, azimuthal angle phi, and polar angle theta) into Cartesian coordinates (x, y, z).
  • pol2sph The pol2sph object converts 2D polar coordinates (radius, angle, and height) into 3D spherical coordinates.
  • polyfun The polyfun object evaluates a polynomial function.
  • polygon The polygon object in Pure Data renders a polygon graphic within the GEM environment.
  • polygon_smooth The polygon_smooth object controls antialiasing for polygons within GEM, effectively smoothing their edges.
  • pqtorusknots The pqtorusknots object renders a customizable 3D torus knot within a GEM (Graphics Environment for Multimedia) context.
  • primTri The primTri object renders a triangle with gradient colors.
  • prime The prime object detects if an input number is prime.
  • quantize~ The quantize~ object quantizes an incoming audio signal to a variable number of steps.
  • rawprint The rawprint object, part of the zexy external library, provides a raw message printing functionality.
  • rectangle The rectangle object is a GEM (Graphics Environment for Multimedia) object that renders a rectangular shape.
  • regex The regex object checks if an input symbol matches a given regular expression.
  • regex-help The regex object checks if an incoming symbol matches a specified regular expression.
  • relay The relay object routes incoming messages based on their first element.
  • render_trigger The render_trigger object provides timing signals related to the rendering process within a gemlist.
  • repack The repack object in Pure Data is used to (re)pack various data types—floats, symbols, or pointers—into fixed-size packages.
  • repeat The repeat object in Pure Data outputs any incoming message a specified number of times.
  • rgb2hsv The rgb2hsv object converts color values from the RGB (Red, Green, Blue) color space to the HSV (Hue, Saturation, Value/Luminance) color space.
  • rgb2yuv The rgb2yuv object converts color values from the RGB (Red, Green, Blue) color space to the YUV (Luma, Chroma) color space.
  • ripple The ripple object is a GEM geometric object that renders and distorts a square.
  • rotateXYZ The rotateXYZ object in GEM applies a 3D rotation to the current transformation matrix.
  • route~ The route~ object, part of the zexy library, separates incoming audio signals from control messages.
  • rubber The rubber object is a GEM object that renders and distorts a square.
  • s2l The s2l object converts an input symbol into a list.
  • scalarmult The scalarmult object performs scalar multiplication, also known as a "dot product," on incoming lists of numbers.
  • scaleXYZ The scaleXYZ object scales a GEM (Graphics Environment for Multimedia) object along its X, Y, and Z axes.
  • scopeXYZ~ The scopeXYZ~ object functions as a 3-dimensional oscilloscope, visualizing three input signals as excursions along the X, Y, and Z axes.
  • segregate The segregate object sorts incoming messages by their data type, sending them to dedicated outlets.
  • separator The separator object in Pure Data's GEM library isolates transformation effects between parallel rendering chains.
  • sf-play_record The sf-play_record object provides a hard disk recording and playback system for Pure Data, enabling multi-track audio recordings.
  • sgn~ The sgn~ object calculates the signum of an incoming audio signal, outputting 1 for positive values, -1 for negative values, and 0 for zero.
  • shearXY The shearXY object applies a shear transformation to graphical objects within GEM (Graphics Environment for Multimedia).
  • shearXZ The shearXZ object applies a shear transformation to a GEM list, modifying the current OpenGL transformation matrix.
  • shearYX The shearYX object applies a shear transformation to a GEM object's current transformation matrix.
  • shearYZ The shearYZ object applies a shear transformation to the current OpenGL transformation matrix, affecting subsequent graphical rendering.
  • shearZX The shearZX object is a GEM manipulation object that applies a shear transformation to the current transformation matrix.
  • shearZY The shearYZ object applies a shear transformation to a gemlist, modifying the current OpenGL transformation matrix.
  • shininess The shininess object in GEM sets the shininess property of materials for subsequent OpenGL vertex operations.
  • sigzero~ The sigzero~ object detects the presence or absence of an audio signal.
  • slideSquares The slideSquares object renders a series of sliding rectangles within a GEM patch.
  • specular The specular object sets the specular color for subsequent 3D vertex operations within a GEM (Graphics Environment for Multimedia) context.
  • specularRGB The specularRGB object in GEM sets the specular color for subsequent OpenGL vertex operations.
  • sph2cart The sph2cart object converts spherical coordinates (radius, azimuth, elevation) to Cartesian coordinates (x, y, z).
  • sph2pol The sph2pol object converts spherical coordinates (radius R, azimuthal angle phi, and polar angle theta) into polar coordinates.
  • sphere The sphere object renders a 3D sphere within the GEM (Graphics Environment for Multimedia) context.
  • sphere3d The sphere3d object renders a deformable 3D sphere within GEM.
  • spline_path The spline_path object reads interpolated values from a multi-dimensional table, treating it as a spline.
  • 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.
  • square The square object renders a square within the GEM graphical environment.
  • step~ The step~ object generates an audio signal that is either a unit step sequence or a rectangular window.
  • strcmp The strcmp object compares two lists as if they were strings, similar to the strcmp function in C programming.
  • surface3d The surface3d object renders a 3D bicubic curve, with its shape controlled by a matrix of control points.
  • swap~ The swap~ object processes incoming audio signals by first converting them to a 16-bit format.
  • symbol2list The symbol2list object converts an incoming symbol into a list.
  • tabdump The tabdump object outputs the entire contents of a Pure Data table as a list.
  • tabminmax The tabminmax object finds the minimum and maximum values within a Pure Data table.
  • tabset The tabset object from the zexy library allows users to set the contents of a Pure Data table.
  • tavg~ The tavg~ object calculates the arithmetic mean of an incoming audio signal.
  • teapot The teapot object renders a 3D teapot shape within a GEM patch.
  • text2d The text2d object in Pure Data renders a line of text using TrueType fonts within a GEM environment.
  • text3d The text3d object in Pure Data renders a single line of text within a 3D graphical environment, leveraging GEM's transformations.
  • textextruded The textextruded object renders a single line of extruded text within the GEM environment, applying current color and 3D transformations.
  • textoutline The textoutline object renders a single line of outlined text within a GEM (Graphics Environment for Multimedia) context.
  • time The time object outputs the current system time in milliseconds, seconds, minutes, and hours when triggered by a bang.
  • torus The torus object renders a 3D torus (doughnut shape) within a GEM environment.
  • translate The translate object in Pure Data is a GEM manipulation object that applies a translation to the current transformation matrix.
  • translateXYZ The translateXYZ object applies a 3D translation to the current transformation matrix within GEM (Graphics Environment for Multimedia).
  • 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.
  • triangle The triangle object in Pure Data is a GEM (Graphics Environment for Multimedia) object that renders an isosceles triangle.
  • tube The tube object in Pure Data renders a 3D tube shape.
  • uniqsym The uniqsym object removes duplicate symbols from a list or stream, maintaining a unique set of values.
  • unpack The unpack object splits an incoming message or list into its individual atoms, sending each atom to a separate outlet.
  • unpack~ The unpack~ object converts a list of floating-point numbers into an audio signal.
  • vertex_program The vertex_program object in Pure Data loads and applies an ARB or NV vertex shader, enabling custom vertex processing within GEM.
  • world_light world_light adds a directional light source to a GEM scene, simulating light rays from an infinite distance (parallel rays).
  • wrap The wrap object functions as a float-capable modulo, constraining an input float value within specified limits.
  • yuv2rgb The yuv2rgb object converts video signals between the YUV and RGB color spaces.
  • zexy_index The index object creates and manages a symbol-to-integer map, allowing you to associate unique symbols with numerical indices.
  • zigbinops The zigbinops help patch describes a collection of signal-rate Pure Data objects from the zexy library.
  • z~ The z~ object provides a sample-wise delay for audio signals, effectively implementing a z^-N delay.