All Classes and Interfaces
Class
Description
Fusion strategy using fixed pixel distance thresholds for match grouping.
Entry point for executing GUI automation actions in the Brobot model-based framework.
Manages analysis data from action execution.
Fluent builder for creating action chains in a readable, declarative style.
Examples demonstrating how to use ActionChainOptions to replace deprecated composite patterns.
Example 6: Reusable Chain Builder
Executes a chain of actions according to a specified chaining strategy.
Specialized logging for action chains with step-by-step tracking.
Context for tracking an action chain execution
Represents a single step in an action chain
Configuration for executing a chain of actions with specific chaining behavior.
Builder for constructing ActionChainOptions with a fluent API.
Defines how results from one action in the chain relate to the next.
Abstract base class for all action configurations in the Brobot framework.
Abstract generic Builder for constructing ActionConfig and its subclasses.
Overrides the global illustration setting for this specific action.
Custom deserializer for ActionConfig hierarchy that handles polymorphic deserialization.
Provides a facade of commonly used action patterns for GUI automation using the modern
ActionConfig API.
Factory for creating ActionConfig instances based on action type.
Specialized JSON serialization utility for ActionConfig objects in the Brobot framework.
Bridge between legacy ActionConfig and modern region resolution.
Custom serializer for ActionConfig hierarchy that adds a type discriminator field.
Provides factory methods for commonly used ActionConfig configurations.
Mock durations for different Actions.
Event representing the execution of a Brobot action.
Central orchestrator for executing GUI automation actions with full lifecycle management.
Thrown when an action fails during execution.
Maintains historical match data for pattern learning and mock execution in the Brobot framework.
Exports ActionHistory data to various formats for analysis and reporting.
Export formats supported by the exporter.
Utility class for persisting and loading ActionHistory data.
Core interface for all actions in the Brobot model-based GUI automation framework.
Defines the standard types of GUI automation actions available in the framework.
Tracks the temporal execution state of a GUI automation action.
Aspect that manages the lifecycle of all action executions.
Internal class to track action execution context.
Manages the execution lifecycle logic for GUI automation actions.
Formats action logs in a concise, consistent manner for all Brobot actions.
Interface for formatting ActionResult data into log messages.
Verbosity levels supported by the logging system.
Spring configuration for action logging with console output and visual feedback.
Inner class for startup GUI check.
Provides fluent API methods for adding comprehensive logging capabilities to ActionConfig
objects.
Configuration holder for logging settings on an ActionConfig
Centralized service for logging action executions using modular formatters.
Captures metrics and performance data for action execution.
Verification for action execution patterns and retry behavior.
Represents a single action attempt.
Builder for creating action pattern verifications.
Records match results and context at a specific point in time for the Brobot framework.
Utility class for creating ActionRecord instances for testing and mock data initialization.
Comprehensive results container for all action executions in the Brobot framework.
Builder for creating ActionResult instances with the new component architecture.
Initializes and manages ActionResult objects throughout the action lifecycle.
Provides advanced composite action patterns that combine multiple sequential actions.
Fluent API builder for creating DSL-compatible action sequences.
Central service for resolving action implementations based on configuration.
Manages action sessions for correlated logging.
Represents a single step in an automation sequence within the Brobot DSL.
Strategy interface for action execution.
Evaluates and determines success conditions for all action types.
Determines the text description of an action given the action itself as well as the active states
before and after action execution.
Enumerates all available action types in the Brobot framework.
Represents an action as a numerical vector for machine learning applications.
Interface for bidirectional translation between ActionConfig and ActionVectors.
Core drawing utilities for visualizing action results on screenshots.
Manages a collection of currently active states in the Brobot framework.
Discovers states reachable through direct transitions from given states.
Preset configuration for finding all occurrences of a pattern on screen.
Creates detailed sidebar visualizations showing individual match results.
Defines relative positioning constraints between visual elements in Brobot.
Handles the adjustment of region boundaries based on anchor points from matched elements.
Collection of Anchor objects for defining complex relative positioning constraints.
Builds Brobot State objects from @State annotated classes.
Configuration class for Brobot annotations support.
Processes @State and @Transition annotations to automatically configure the Brobot state machine.
ANSI color codes for colorful console output.
ApplicationContextInitializer that ensures critical Brobot settings are configured before ANY
Spring beans are created.
Service for managing application lifecycle events in Brobot applications.
Provides comprehensive startup verification for Brobot applications.
Configuration for application startup verification
Result of startup verification
Provides access to the currently focused application window with mock support.
Configuration for filtering action results based on their pixel area.
Represents an assignment statement in the Brobot DSL.
Configuration for automation execution behavior.
Represents the project configuration settings and references to automation functions.
Validates automation DSL JSON against the Brobot DSL schema.
Exception thrown when automation sequences fail.
Comprehensive container for an entire Brobot automation project.
Manages the active project configuration in the Brobot framework.
Base class for automation runners that provides graceful failure handling.
Functional interface for automation tasks.
Core interface for automation script lifecycle management in the Brobot framework.
Configuration for automatic pattern scaling detection.
Properties holder for auto-scaling configuration.
Automatic startup verifier that handles both image and state verification in a two-phase approach
without requiring application-specific code.
Utility for Base64 encoding of files and byte arrays in the Brobot framework.
Abstract base class for building GUI automation applications in the Brobot framework.
Base configuration for all Find actions in the Brobot framework.
Abstract generic Builder for constructing BaseFindOptions and its subclasses.
BasicActions, which run for 1 iteration, require 1 or no Find operations.
Captures and saves the best matching region when pattern searches fail or find low-similarity
matches.
Predefined color constants for OpenCV operations in BGR format.
Represents a binary operation expression in the Brobot DSL.
Entry point for the Brobot fluent API.
Spring Boot auto-configuration for the Brobot framework.
Central service for screen capture operations in Brobot.
Spring configuration class for the Brobot framework.
Unified configuration system for Brobot with validation and environment-specific profiles.
Core configuration settings
Environment-specific configuration
Performance tuning configuration
SikuliX-specific configuration
Loads default Brobot properties from the library's resources.
Jackson mixin for Brobot's Image class to control JSON serialization.
Custom Jackson module for Brobot that registers all custom serializers and deserializers.
Jackson module that configures custom serializers and deserializers for Brobot domain objects.
Launcher that restarts the JVM with DPI awareness disabled if needed.
Core logger interface for the Brobot framework.
Fluent API for building structured log entries.
Main implementation of the BrobotLogger interface.
A wrapper around Jackson's ObjectMapper configured specifically for Brobot JSON operations.
Brobot Pattern Capture Tool - Alternative to SikuliX IDE for capturing patterns.
Pattern metadata class.
Centralized configuration properties for the Brobot framework.
Initializes and logs BrobotProperties configuration on startup.
Verifies and logs Brobot property configuration after Spring Boot initialization.
Base runtime exception for all Brobot framework exceptions.
Intelligent screen capture that handles DPI scaling and application scaling issues.
Handles graceful shutdown of Brobot components and native resources.
Custom Jackson deserializer for BufferedImage objects.
Jackson mixin for java.awt.image.BufferedImage to control JSON serialization.
Custom Jackson serializer for BufferedImage objects.
Comprehensive BufferedImage operations for the Brobot GUI automation framework.
Represents a builder pattern expression in the Brobot DSL.
Represents a method call within a builder chain in the Brobot DSL.
Main entry point for business rule validation in Brobot configurations.
Represents a single automation function in the Brobot DSL.
Configuration helper for the modular capture system.
Provider presets for quick switching.
Comprehensive debugging tool for screen capture issues.
Interface for screen capture providers.
Analyzes why SikuliX captures at 1536x864 instead of 1920x1080.
Primary implementation of
FindDynamicPixels that detects pixel changes across a sequence
of images to identify motion.Creates color-coded legends for classification visualization results.
Provides scene classification functionality through the Brobot action interface.
Performs click operations on GUI elements without embedded Find operations.
Modern implementation of Click and Type composite action using the fluent API.
Configuration for Click and Type composite action.
Builder for constructing ClickAndTypeOptions with a fluent API.
Executes click operations on elements WITHOUT depending on Find.
Configuration for click operations.
Configuration for all Click actions.
Builder for constructing
ClickOptions with a fluent API.Maps click types to Sikuli button constants.
Enum representing mouse button types.
Marks a method for automatic dataset collection for machine learning.
Data storage formats
Per-pixel color analysis results for scene-color profile matching.
Types of color analysis metrics available.
Central orchestrator for pixel-level color analysis in Brobot's vision system.
DynamicImages classify as probabilities, standard Images have 100% pixel probability when found.
Manages color profiles across multiple color spaces for pattern matching in Brobot.
Creates color profiles from image data for pattern matching.
Configuration for color-based Find actions.
Builder for constructing
ColorFindOptions with a fluent API.Defines the color analysis strategy to be used.
Statistical color channel information for pattern matching.
Extensions of OpenCV operations to handle 3-channel (color) images.
Jackson mixin for java.awt.image.ColorModel to control JSON serialization.
Abstract color space representation for statistical color matching.
BGR color schema implementation for OpenCV-compatible color matching.
HSV color schema implementation for color-based pattern matching.
Statistical profile mapping color channels to their values for a specific statistic.
Represents a statistical color profile for a specific statistic type in a color space.
Provides convenience methods for common drag operation patterns in GUI automation.
Provides simplified helper methods for performing Select operations.
Provides concise logging for find operations with intelligent deduplication and summarization to
reduce repetitive log output.
Enhanced version of ConditionalActionChain with the missing features from documentation.
Spring-friendly wrapper around ConditionalActionChain that simplifies conditional action
execution in Brobot applications.
Implements conditional logging based on action results.
Represents a logging condition with its associated action
Configuration diagnostics tool to help users troubleshoot configuration issues.
Comprehensive diagnostic report
Thrown when there is an error in the configuration of actions or the framework.
Exception thrown when configuration processing fails in the Brobot framework.
Provides robust JSON parsing and serialization capabilities for the Brobot framework.
Main validator class for Brobot configurations.
Exception thrown when Brobot configuration validation fails.
Extracts and processes contours from classified image regions to generate Match objects.
Builder class for constructing ContourExtractor instances with required parameters.
Utility class for scaling coordinates between physical and logical resolution.
Manages correlation IDs and session context for log entries.
Context data structure for a single thread's execution.
Automatic cross-platform physical resolution capture.
Enhanced anchor that can reference matches from other states.
Processes cross-state anchors to define regions dynamically based on matches from other states.
Marker class for transitions targeting the current active state.
Executes custom find operations using a provided strategy function.
Jackson mixin for java.awt.image.DataBuffer to control JSON serialization.
Aspect that automatically collects datasets for machine learning training.
Dataset statistics
Manages the creation and storage of training datasets for machine learning.
Generates comprehensive debug reports for image finding operations.
Default implementation of StateHandler for automated state navigation.
Primary text typing implementation that handles both mock and live environments.
Tracks which borders of a region have been defined during the region definition process.
Converts pre-defined regions from state objects into match results without performing searches.
Defines a region as the bounding box that encompasses all found matches.
Defines a region as the smallest rectangle that contains all specified anchor points.
Defines a region as the bounding box that encompasses all anchor points.
Central orchestrator for region definition operations in the Brobot framework.
Configuration for Define actions, which capture screen regions.
Builder for constructing
DefineRegionOptions with a fluent API.Defines the strategy for how a new region should be captured or calculated.
Defines regions based on the position and dimensions of found matches.
Defines a region based on the boundaries of the currently focused window.
Diagnostic logger for pattern matching and image analysis.
Configuration for diagnostic tools that can be enabled via properties.
Represents directional relationships in state transitions and navigation.
Direct screen capture using SikuliX Screen API.
Comprehensive geometric calculations for distances, angles, and spatial relationships.
Calculates distance matrices for color-based pattern matching.
Java Agent that disables DPI awareness before any classes are loaded.
Spring ApplicationContextInitializer that ensures DPI awareness is disabled before any Spring
beans are created or AWT classes are loaded.
Automatically detects DPI scaling factor for the primary monitor.
Disables DPI awareness in Java 21+ to ensure screen captures are at physical resolution.
Configures DPI scaling for Brobot applications.
Diagnostic tool for analyzing and resolving DPI scaling issues.
Strategy for handling DPI scaling in pattern matching.
Pattern source types
Diagnostic tool to verify that DPI awareness disabling is working correctly.
Pure implementation of drag-and-drop operations for GUI automation.
Builder utility for creating drag operations as a chain of actions.
Provides drag-and-drop functionality between locations with configurable timing and mock support.
Configuration for drag actions.
Builder for constructing DragOptions with a fluent API.
Utility for drawing directional arrows on images.
Creates visual legends for image classification results and color analysis.
Visualizes classification results with color-coded regions and legends.
Visual representation generator for color profiles of StateImage objects.
Utility for visualizing object contours and boundaries.
Visualizes histogram data as vertical bar charts.
Utility for drawing straight lines on images.
Provides high-level drawing operations for visualizing match results on images.
Handles the visualization and saving of motion detection masks from action results.
Utility for drawing circular point markers on images.
Provides rectangle drawing utilities for visualizing matches and regions on OpenCV Mat images.
Engine for processing dynamic message templates with variable substitution.
Finds dynamic and fixed pixels by comparing pixel values across multiple images.
Configuration for finding dynamic pixels within GUI scenes.
Builder for constructing
DynamicPixelsFindOptions with a fluent API.Resolves and updates search regions dynamically based on matches from other state objects.
Ensures image paths are initialized as early as possible in the Spring Boot lifecycle.
Initializes ScreenDimensions with defaults early in the Spring Boot startup process.
Edge-based validation strategy for determining if matches fall within search regions.
Core interface for element location operations.
Result of an element location operation.
Find strategies that determine how elements are located.
Request object for element location operations.
Builder for creating LocateRequest instances.
Represents the absence of a match in the Brobot model-based GUI automation framework.
Aspect that provides automatic error recovery with configurable retry policies.
Custom exceptions
Configuration to ensure robust event handling across module boundaries.
Custom event multicaster with enhanced logging for debugging
Interface for controlling the execution flow of automation tasks.
Manages Brobot's runtime environment configuration.
Builder for creating custom ExecutionEnvironment configurations.
Tracks the execution history of action chains and composite actions.
Controls execution permissions and modes in the Brobot framework.
Central coordinator for seamlessly switching between mock and live execution modes.
Manages execution pausing and resuming for debugging purposes.
Represents the possible states of an automation execution.
Exception thrown when an execution is stopped during a pause point check.
Marker class for transitions to an expected state determined at runtime.
Manages and orchestrates comprehensive testing of the automation application.
Executes individual test runs with comprehensive logging and monitoring capabilities.
Abstract base class for all expressions in the Brobot DSL.
Defines failure patterns for mock actions to simulate real-world error conditions.
FFmpeg-based screen capture provider.
Cross-platform physical resolution capture using FFmpeg.
Manages filename reservations to prevent file conflicts during concurrent operations.
Utility class for extracting and manipulating file names from paths.
Utility class for common filename manipulation operations.
Core pattern matching action that locates GUI elements on the screen.
Finds all matches for all patterns within StateImages on the screen.
Composite action configuration that combines Find and Click operations.
Builder for creating FindAndClick instances with a fluent API.
Composite action configuration that combines Find, Click, and Type operations.
Builder for creating FindAndType instances with a fluent API.
Executes color-based pattern matching and scene classification.
Finds matches based on dynamic (changing) pixels across multiple patterns.
Interface for identifying dynamic (changing) and fixed (unchanging) pixels across a sequence of
images.
Finds matches based on fixed (unchanging) pixels across multiple patterns.
Implements histogram-based image matching for finding patterns in scenes.
Core component for finding images on screen using various search strategies.
Detects and tracks motion across multiple scene captures.
AOP interceptor for Find operations to provide debug output.
Encapsulates the Find operation pipeline, orchestrating all steps of the pattern matching
process.
Identifies regions containing motion across multiple scene captures.
The image to compare is in ObjectCollections #1 (0), in the list of StateImage objects.
Finds and creates states dynamically based on scene analysis and image combinations.
Defines the various strategies available for find operations in Brobot.
Defines strategies for finding patterns, text, and other elements on screen.
Registry for different find strategies available in the system.
Finds text elements within GUI scenes using OCR (Optical Character Recognition).
Wrapper for Find operations that routes to mock or live implementation.
Configuration for finding fixed (static) pixels within GUI scenes.
Builder for constructing
FixedPixelsFindOptions with a fluent API.Example demonstrating how to use the Brobot fluent API to create DSL-compatible automation
sequences.
Represents a for-each loop statement in the Brobot DSL.
Initialization service for the Brobot model-based GUI automation framework.
Manages the Brobot framework initialization lifecycle within Spring.
Validates all references related to automation functions in Brobot configurations.
Validates business rules for automation functions in Brobot DSL configurations.
Aggregates pixel scores across multiple color profiles for comprehensive matching.
Defines conditions for text-based action termination.
Provides OCR text extraction functionality from image regions with mock support.
Divides a screen region into a matrix of cells for systematic interaction.
Fast spatial clustering using overlapping grid-based partitioning.
Comprehensive headless environment debugger for Windows.
Debug class to track headless property changes throughout the application lifecycle.
Simplified headless detection for the Brobot framework.
Diagnostics component for headless mode detection issues.
Highlights regions on screen without embedded Find operations.
Configuration for Highlight actions.
Builder for constructing
HighlightOptions with a fluent API.Wrapper for highlight operations that routes to mock or live implementation.
Compares histograms using the Earth Mover's Distance (EMD) metric.
Calculates and manages histograms for image regions in HSV color space.
Configuration for histogram-based Find actions.
Builder for constructing
HistogramFindOptions with a fluent API.Represents a specific region within images for histogram analysis.
Manages histogram regions for spatial color analysis of images.
Wrapper for Histogram operations that routes to mock or live implementation.
Generates unique filenames for Brobot's visual history illustrations.
Configuration for HSV (Hue, Saturation, Value) color space binning.
Represents a conditional if-then-else statement in the Brobot DSL.
Advanced configuration for illustration generation with context-aware control.
Configuration for batching illustrations to improve performance.
Advanced quality metrics for illustration filtering.
Context information for making intelligent illustration decisions.
Record of a single action execution for historical context.
Priority levels for action executions.
Current system performance metrics.
Controls when and how action results are illustrated to prevent redundancy.
Performance optimization system for illustration generation.
Physical representation of an image in the Brobot GUI automation framework.
Compares images to determine similarity and find matches between patterns.
Static utility methods for image format conversions and operations.
Configuration for image finding debugging features.
Custom deserializer for
Image objects that recreates Image instances from JSON metadata,
generating placeholder BufferedImage objects as needed.Utility component for saving images to disk with automatic filename generation.
Central debugging orchestrator for image finding operations.
V2 component for finding images on screen using various search strategies.
JavaCV-based image acquisition and conversion utilities for Brobot.
Diagnostic runner for testing image loading capabilities.
Early initializer for image loading infrastructure.
Cross-platform physical resolution capture using ImageMagick.
Normalizes images to ensure consistent bit depth and format for pattern matching.
Centralized image path management system that handles all path resolution strategies.
Resolves image paths at startup to ensure they are absolute and valid.
Validates image resources referenced in Brobot project configurations.
Associates a
StateImage with all the scenes in which it appears.Custom serializer for
Image objects that provides memory-efficient JSON serialization by
excluding the actual image data (BufferedImage) while preserving metadata.Marks a method as an IncomingTransition (also known as arrival transition or verification
transition).
Central orchestrator for Brobot's critical initialization path.
Phase status tracking for health checks and debugging.
Auto-configuration for initial state management in Brobot applications.
Test profile specific configuration that optimizes initial state handling for tests.
Manages probabilistic initial state discovery for automation startup and recovery.
Modern approach to initial state verification for Brobot applications.
Root data structure for Brobot's Domain-Specific Language (DSL) automation definitions.
Orchestrates iterative pattern finding across multiple scenes and state images.
Physical resolution screen capture using JavaCV's bundled FFmpeg.
JavaCV FFmpeg-based capture provider that uses bundled FFmpeg libraries.
JavaCV-based OCR service using Tesseract directly.
Word match result with position and confidence.
Pure JavaCV/OpenCV implementation of pattern matching.
Jackson mixin for JavaCV's Rect class to control JSON serialization.
Code-based state transition implementation for the Brobot framework.
Builder for creating JavaStateTransition instances fluently.
Spring configuration for JSON processing in the Brobot application.
JSON log formatter for machine processing.
Provides utilities for navigating and extracting data from JSON structures using path notation.
Provides advanced JSON serialization utilities with enhanced error handling and recovery.
Core interface for keyboard control operations.
Special keys enumeration for keyboard operations.
Presses and holds keyboard keys in the Brobot model-based GUI automation framework.
Configuration for the KeyDown action.
Builder for constructing
KeyDownOptions with a fluent API.Handles keyboard key press-and-hold operations for modifier key combinations.
Releases previously pressed keyboard keys in the Brobot model-based GUI automation framework.
Configuration for the KeyUp action.
Builder for constructing
KeyUpOptions with a fluent API.Handles keyboard key release operations in both real and mock modes.
KmeansCluster represents a cluster of points in a k-means analysis corresponding to one of the
centers.
KmeansProfile represents a k-means analysis for one number of means and one color schema (BGR,
HSV, etc.).
Generates and manages K-means clustering profiles for state images across multiple color schemas.
Manages a collection of K-means clustering profiles for a single color schema.
Manages K-means clustering profiles for multiple color schemas in the Brobot framework.
Manages Brobot's initialization lifecycle to ensure proper component startup order.
Framework status information
Represents a literal (constant) value expression in the Brobot DSL.
Represents a point on the screen in the Brobot model-based GUI automation framework.
Builder class for constructing Location instances with a fluent API.
Comprehensive utility methods for Location manipulation and calculations in Brobot.
Standalone implementation of the fluent builder API for log entries.
Categories for Brobot logging events.
The actual log entry data structure that gets passed to formatters.
Interface for formatting log entries into string output.
Output format types for different use cases.
Auto-configuration for the Brobot logging system.
Manages logging presets for different environments.
Spring configuration for the Brobot logging subsystem.
Configuration for the Brobot logging system.
Configuration for data enrichment
Preset configurations for common scenarios
Configuration for output formatting
Output format options
Configuration for performance optimizations
Configuration for logging verbosity across the Brobot framework.
Configuration for normal logging mode.
Configuration for verbose logging mode.
Verbosity levels for logging output.
Standard log levels for the Brobot logging system.
Flexible builder for composing multiple OpenCV Mat objects into a single image.
Represents a successful pattern match found on the screen in the Brobot model-based GUI
automation framework.
Builder class for constructing Match instances with a fluent API.
Configuration for adjusting the position and dimensions of found matches.
Builder class for MatchAdjustmentOptions.
Manages a collection of Match objects found during action execution.
Sorting strategies for match collections.
Utility operations for managing collections of Match objects.
Captures visual and text content from matched regions after find operations.
Specialized JSON serialization utility for ActionResult (Matches) in the Brobot framework.
Custom serializer for
ActionResult objects (formerly Matches) that provides safe
serialization by handling circular references and complex object graphs.Event representing pattern matching operations in the Brobot framework.
Provides filtering operations for match collections.
Combines overlapping or closely positioned matches into single unified matches.
Strategy interface for determining whether two matches should be fused together.
Defines methods for combining matches based on spatial proximity.
Configuration for match fusion operations in Find actions.
Builder class for MatchFusionOptions.
Defines the method for fusing multiple matches into a single larger match.
Provides visual highlighting functionality for matches on screen with mock support.
Jackson mixin for Brobot's Match class to control JSON serialization.
Validates whether matches fall within designated search regions.
Analyzes pattern matching quality to diagnose matching issues and optimize thresholds.
Adjusts the position and dimensions of Match objects based on MatchAdjustmentOptions settings.
Provides statistical analysis of match collections.
Confidence levels for match collections.
Creates State objects from Match results for dynamic state generation.
Custom Jackson deserializer for OpenCV Mat objects.
Custom deserializer for OpenCV
Mat (Matrix) objects that provides safe JSON
deserialization by creating placeholder Mat objects from metadata.OpenCV-based template matching implementation for image recognition.
Jackson mixin for OpenCV's Mat class to control JSON serialization.
Comprehensive utility class for OpenCV Mat operations in Brobot.
Visualization utilities for OpenCV Mat objects, primarily for debugging and testing.
Custom Jackson serializer for OpenCV Mat objects.
Custom serializer for OpenCV
Mat (Matrix) objects that provides safe JSON serialization
by extracting only metadata while avoiding native memory issues.Represents a method invocation expression in the Brobot DSL.
Represents a method call statement in the Brobot DSL.
Builder for creating mock ActionHistory with bulk snapshots.
Static factory methods for common patterns.
Factory for creating common mock ActionHistory patterns.
Advanced verification system for mock behavior and state transitions.
Represents a single execution event for verification.
Generates mock scene data for testing color-based operations.
Configuration for mock and wrapper beans to ensure proper initialization order.
Returns snapshots with matching actions and states.
Provides mock window focus functionality for testing scenarios.
Configuration for grid operations in mock mode.
Mock implementation of highlight operations for testing.
Provides mock histogram matching functionality for testing and development.
Generates synthetic Match objects for probability-based mock testing scenarios.
Builder for creating customized Match objects with various configuration options.
Centralized manager for mock mode configuration across the Brobot framework.
Resolver for mock mode configuration.
Simplified mock configuration properties for the Brobot framework.
Nested configuration for action success probability.
Configuration for scenario-based mock testing with advanced conditions and patterns.
Builder for creating mock Scene and SceneAnalysis objects for testing.
Builder class for more complex SceneAnalysis configurations.
Mock implementation of ScreenCaptureService for testing and headless environments.
Manages state probabilities for controlled testing scenarios in the Brobot framework.
Tracks mock operation counts for controlled testing scenarios.
Context information for mock test execution, tracking state and history.
Mock text for GetText Actions using Snapshots.
Provides simulated time control for mock testing environments in Brobot.
Registry for different find strategies available in the system.
Configuration and result container for do-until composite actions using ActionConfig.
Builder for constructing RepeatUntilConfigV2 instances with proper configuration.
Marks a method or class for enhanced performance monitoring.
Service for executing continuous monitoring and automation tasks in the Brobot framework.
Manages multi-monitor support for Brobot automation framework.
Information about a monitor
Detects motion between images using frame differencing techniques.
Configuration for motion-based Find actions.
Builder for constructing
MotionFindOptions with a fluent API.Metadata about the motion detection process and parameters used.
Jackson builder configuration for deserialization.
Represents the physical mouse buttons.
Core interface for mouse control operations.
Mouse button enumeration for click operations.
Configuration for MouseController in the Brobot framework.
Presses and holds a mouse button in the Brobot model-based GUI automation framework.
Configuration for MouseDown actions.
Builder for constructing MouseDownOptions with a fluent API.
Provides mouse button press-and-hold functionality with timing control and mock support.
Configuration for Move Mouse actions.
Builder for constructing
MouseMoveOptions with a fluent API.Configuration for mouse button press-and-release behaviors.
Releases a mouse button in the Brobot model-based GUI automation framework.
Configuration for MouseUp actions.
Builder for constructing MouseUpOptions with a fluent API.
Provides mouse button release functionality with timing control and mock support.
Provides mouse wheel scrolling functionality with support for both real and mocked operations.
Represents a directed movement from a start location to an end location.
Analyzes movement patterns by comparing object positions before and after actions.
Tracks movement operations performed during action execution.
Moves the mouse to one or more locations without embedded Find operations.
Handles mouse movement operations to specific screen locations.
Identifies moving objects by analyzing motion patterns across three consecutive scenes.
Aspect that provides intelligent routing of actions to specific monitors in multi-monitor setups.
Inner class for monitor statistics
Early initializer to suppress native library debug output.
Configuration for controlling native library debug output.
Modern implementation of nested finds using action chaining.
Configuration for nested find operations.
Builder for constructing NestedFindsOptions with a fluent API.
Converts non-image state objects into Match objects for action processing.
Provides standard output for action results.
Condition that checks if the application is NOT running in headless mode.
Special state for handling stateless objects in the Brobot framework.
Container for GUI elements that serve as targets for automation actions in Brobot.
Builder class for constructing ObjectCollection instances with a fluent API.
Specialized JSON serialization utility for ObjectCollection in the Brobot framework.
Custom serializer for
ObjectCollection that provides controlled serialization of complex
state management objects while preventing circular references and handling native resources.Manages offset-based location adjustments for find and action operations.
One-hot encoding implementation for converting actions to vectors.
Enum representing highlight colors with their encoded values.
Initializes OpenCV/JavaCV native libraries at application startup.
OpenCV-based implementation of the PatternMatcher interface.
Represents a decision made by the illustration performance optimizer.
Types of optimization decisions.
Marks a method as an OutgoingTransition - a transition FROM the state defined in the
enclosing @TransitionSet class TO a specific target state.
Creates two offset grids that overlap to provide comprehensive coverage of grid-like interfaces.
Generic immutable container for holding two related values as a single unit.
Represents a parameter definition for automation functions in the Brobot DSL.
Represents a navigation path between states in the Brobot model-based GUI automation framework.
Implements graph traversal algorithms to find navigation paths between States.
Manages path scoring and recovery after failed state traversals.
Collection of navigation paths in the Brobot model-based GUI automation framework.
Executes navigation paths by performing state transitions in sequence.
Represents a visual template for pattern matching in the Brobot GUI automation framework.
Builder class for constructing Pattern instances with a fluent API.
Configuration for all standard pattern-matching Find actions.
Builder for constructing
PatternFindOptions with a fluent API.Controls match selection strategy when using
PatternFindOptions.Strategy.EACH.The pattern matching strategy.
Core interface for pattern matching operations.
Configuration options for pattern matching operations.
Result of a single pattern match operation.
Comprehensive diagnostics for pattern matching issues with DPI scaling.
Utility for scaling pattern images to handle DPI and resolution differences.
Example automation script demonstrating pause/resume/stop functionality.
Event representing performance metrics for Brobot operations.
Performance metrics for illustration system monitoring.
Immutable snapshot of performance metrics at a point in time.
Aspect that provides comprehensive performance monitoring for Brobot operations.
Inner class for tracking method performance statistics
Validates performance characteristics using ActionHistory data.
Result of comparing two ActionHistory instances.
Default performance thresholds.
Configuration for performance validation.
Result of performance validation containing metrics and findings.
Interface for pluggable persistence providers.
Session metadata container.
Provides methods to capture at physical resolution even when DPI awareness is enabled.
Provides physical resolution screen capture regardless of DPI settings.
Detects pixel changes between multiple images using configurable image processing techniques.
Builder for creating customized PixelChangeDetector instances.
Performs pixel-level classification to assign scene regions to state images.
Per-pixel color analysis results for individual color profiles.
Types of pixel-level analysis metrics.
Aggregates multiple pixel analyses for comprehensive scene-image matching.
Types of aggregate analysis data stored in the collection.
Extracts match regions from pixel-level color analysis results.
Calculates pixel-level matching scores from color distance analysis.
Configuration for recording and playback actions.
Builder for constructing
PlaybackOptions with a fluent API.Represents a relative position within a rectangular area using percentage coordinates.
Defines standard relative positions within a rectangular area.
Handles post-click operations, particularly mouse movement after click actions.
Marks a method in a State class that should be called after the Spring context is fully
initialized to load images and complete state initialization.
Preset configuration for precise pattern matching operations optimized for accuracy.
Marker class for transitions that should return to the previous (hidden) state.
Creates and manages visualization matrices for state images and their color profiles.
Initializes one-column color matrices for state images to enable unified color analysis.
Orchestrates the complete color profile initialization process for state images.
Validates project configuration JSON against the Brobot project schema.
Temporary container for building states with associated images and scenes.
Populates the temporary state repository with states derived from scene combinations.
Repository for temporary states created during scene analysis.
Pure Type action that types text without embedded Find.
Preset configuration for quick pattern matching operations optimized for speed.
Quick comparison tool to test the hypothesis that SikuliX loads patterns differently when using
Pattern(String) vs Pattern(BufferedImage).
Provides minimal, clean output for action results.
Jackson mixin for java.awt.image.Raster to control JSON serialization.
Implements continuous state-based automation that monitors and responds to GUI changes.
Implementation of SaveToFile for recording automation sessions to disk.
Wrapper for Action that automatically records execution history.
Marks a method for automatic error recovery with retry logic.
Recovery strategies
Jackson mixin for java.awt.geom.Rectangle2D to control JSON serialization.
Jackson mixin for java.awt.Rectangle to control JSON serialization.
Custom serializer for JavaCV
Rect objects that provides safe JSON serialization for
OpenCV/JavaCV rectangle structures.Main facade for cross-reference validation in Brobot configurations.
Utility class providing common regular expression patterns and validation methods.
Represents a rectangular area on the screen in the Brobot model-based GUI automation framework.
Validates matches by ensuring they fall within designated search regions.
Builder for creating Region objects with screen-size awareness and flexible adjustments.
V2 version that provides reusable helper methods for the various Define actions.
Manages regions created or defined during action execution.
Jackson mixin for Brobot's Region class to control JSON serialization.
Comprehensive utility methods for Region manipulation and analysis in Brobot.
Fusion strategy using size-relative distance thresholds for match grouping.
Configuration and result container for do-until composite actions.
Builder for constructing DoUntilActionObject instances with proper configuration.
Configuration for action repetition and pausing behavior.
Represents a return statement in the Brobot DSL.
Robot-based screen capture provider.
Represents the automation configuration for UI buttons in the Brobot Runner.
Visualizes Brobot states with color-coded elements and boundaries.
Interface for file saving operations supporting various content types.
Represents a captured screenshot or screen state as a searchable pattern.
Container for multiple scene analyses, supporting time-series and multi-scene operations.
Comprehensive analysis results for a single scene with multiple state images.
Orchestrates the creation and population of scene analysis collections for color-based matching.
Represents a combination of two scenes and the images that appear in both.
Generates combinations of scenes for dynamic pixel analysis.
Distributes StateImage objects across scene combinations based on pixel stability.
Repository for managing and querying collections of scene combinations.
Creates Scene objects from screenshot files in a configured directory.
Performs image pattern matching and OCR text detection within captured scenes.
Manages scene acquisition from screenshots or provided images for analysis operations.
Processes pixel scores to generate scene-wide classification indices and visualizations.
Manages JSON schema loading, caching, and validation for the Brobot configuration system.
Entry point for schema validation operations in Brobot configurations.
Visualization component for color matching scores and analysis.
Core interface for screen capture operations.
Validates screen capture functionality in different environments.
Result of screen capture validation
Simple static holder for screen dimensions.
Manages screen resolution information based on the active capture provider.
Verifies the actual resolution that SikuliX uses for screen capture and tests how
Settings.AlwaysResize affects capture dimensions.
Provides screenshot capture functionality with multiple capture strategies.
Manages continuous screenshot capture for various analysis and recording purposes.
Utility class for screen dimension operations and region creation.
Scrolls the mouse wheel in the Brobot model-based GUI automation framework.
Configuration for mouse wheel scrolling actions.
Builder for constructing
ScrollOptions with a fluent API.Defines the direction of mouse wheel scrolling.
Registry that tracks dependencies between StateObjects for search region resolution.
Represents an object that depends on another for its search region
Configuration for deriving search regions from another state object's match.
Selects appropriate search regions for find operations based on a priority hierarchy.
Manages multiple search areas for pattern matching in the Brobot framework.
Custom deserializer for
SearchRegions objects that handles flexible JSON formats and
filters out invalid or default region data during deserialization.Jackson mixin for Brobot's SearchRegions class to control JSON serialization.
Utility methods for manipulating and working with SearchRegions objects.
Represents an angular sector (arc) in a circular coordinate system.
A custom composite Action that performs selection operations through swiping.
Data container for configuring and tracking the state of a Select operation.
Builder class for constructing SelectActionObject instances.
Aspect that intercepts all Sikuli method calls to provide: - Centralized error handling and
translation - Mock mode support without wrapper modifications - Automatic screenshot capture on
failures - Comprehensive operation logging - Performance metrics collection
Inner class for tracking operation metrics
Jackson mixin for Sikuli's Location class to control JSON serialization.
Sikuli-based implementation of the MouseController interface.
Sikuli-based implementation of the ScreenCaptureService interface.
Jackson mixin for Sikuli's Screen class to control JSON serialization.
Manages the transactional application of settings to the global SikuliX context.
Diagnostic tool to compare pattern matching between SikuliX and Brobot.
SikuliX-based screen capture provider.
Ensures compatibility between SikuliX and JavaCV by configuring SikuliX to use its bundled OpenCV
libraries instead of JavaCV's.
Configuration class to disable SikuliX internal logging.
Configuration for find operations that compare images for similarity.
Builder for constructing
SimilarImagesFindOptions with a fluent API.Defines how images are compared when multiple patterns exist.
Simple human-readable log formatter.
Executes single mouse click operations at specified locations.
Performs histogram-based pattern matching using a sliding window approach.
Determines size relationships between Pattern objects for image comparison operations.
Intelligent image loading system that works across all deployment scenarios.
Result of an image load attempt with diagnostic information
Defines special state types with reserved IDs in the Brobot framework.
Spring configuration class for the Brobot library's dependency injection setup.
Standalone diagnostic to verify DPI scaling assumptions and test claude-automator patterns.
Configuration properties for Brobot startup behavior.
Automatically verifies initial states on application startup.
Annotation for Brobot states.
Represents a distinct configuration of the GUI in the Brobot model-based automation framework.
BeanPostProcessor that detects beans annotated with @State during bean creation.
Provides state-aware scheduling capabilities for automation tasks in the Brobot framework.
Configuration for state checking behavior.
Defines how states should be checked.
Extracts Brobot state components (StateImage, StateString, StateObject) from annotated state
classes.
Container for extracted state components.
Discovers active states through visual pattern matching in the Brobot framework.
Marker interface for state enumerations in the Brobot framework.
Manages and tracks unvisited states during comprehensive state exploration testing.
Factory for creating Brobot states after framework initialization.
Interface for implementing custom state handling logic in automation scripts.
Service for resolving state names to IDs in state transitions.
Visual pattern identifier for States in the Brobot model-based GUI automation framework.
Handles deferred image loading for State classes after Spring context is fully initialized.
Visits and verifies all images within a given state as part of comprehensive test coverage.
Orchestrator for state-specific initialization phases.
Initialization phases for tracking
Creates visual representations of Brobot states showing expected element positions.
Represents a meaningful screen coordinate associated with a specific state in Brobot.
Maintains the runtime memory of active States in the Brobot framework.
Updates StateMemory based on matches found during action execution.
Abstract base class for all statements in the Brobot DSL.
High-level state navigation orchestrator for the Brobot framework.
Thrown when a requested state cannot be found in the state management system.
Core interface for all objects that belong to states in the Brobot framework.
Lightweight reference to StateObject instances in the Brobot framework.
Validates all references related to states in Brobot configurations.
Represents a meaningful screen area associated with a specific state in Brobot.
Registers Brobot State objects with the framework's StateService.
Service layer for managing states within the active project.
Event fired when all @State annotated classes have been processed and registered.
Represents text input associated with a specific state in the Brobot framework.
This class is meant mostly for testing state structures and state management, although it can
also be used for bootstrapping simple projects.
Represents persistent text that uniquely identifies a state in GUI automation.
Tracks state information discovered during action execution.
Core interface for state transitions in the Brobot model-based GUI automation framework.
Aspect that tracks and analyzes state transitions in the Brobot framework.
Inner class representing a state node in the graph
Inner class for tracking transition statistics
Container for all transitions associated with a specific State in the Brobot framework.
Builder for creating StateTransitions instances fluently.
Service layer for managing state transitions within the active project.
Maintains a comprehensive graph of state transitions for efficient navigation queries.
Manages the StateTransitions repository and retrieves StateTransitions given a state name.
Verification for state transition sequences and timing requirements.
Builder for creating state transition verifications.
Represents a single step in a state transition sequence.
Orchestrates comprehensive state exploration for automated testing of the application.
Manages the conversion of active states to hidden states during transitions.
Records detailed information about individual state visits during test exploration.
States can be illustrated in various ways.
Utility class for intelligently combining strings by removing common prefixes.
Calculates string similarity using the Levenshtein distance algorithm.
Structured log formatter with consistent field placement.
Extracts matches for specific target images from scene classification results.
Represents a UI button configuration for the desktop runner that calls automation functions.
Represents position information for a button in the UI.
Represents styling information for a button.
Defines a sequence of actions as data in the Brobot Domain-Specific Language.
Data-driven state transition implementation for the Brobot framework.
Defines time-based conditions that affect mock behavior during testing.
Represents a time range for conditional activation.
Builder for structured test data with versioning and variation support.
Represents a single test run session with comprehensive metadata for tracking and analysis.
Represents a complete test scenario with baseline data and variations.
Builder class for creating test scenarios with fluent interface.
Represents a variation of test data that modifies baseline scenario elements.
Builder class for creating test variations with fluent interface.
Represents text extracted from GUI elements with inherent OCR variability.
Manages text extraction results from action execution.
Configuration for text-based Find actions using OCR (Optical Character Recognition).
Builder for constructing
TextFindOptions with a fluent API.Selects the most appropriate string from a stochastic Text object using various strategies.
Available text selection strategies.
Interface for text typing operations.
Wrapper for Text operations that routes to mock or live implementation.
Thread-safe implementation of ExecutionController.
Wrapper for Time operations that routes to mock or live implementation.
Manages timing information for action execution.
Represents a timed segment within the overall execution.
Serializable container for machine learning training data.
Builder for creating TrainingExample instances.
Reads serialized training data from persistent storage.
Accumulates and persists training data to disk.
BeanPostProcessor that detects and collects beans annotated with @TransitionSet.
Converts various transition types into executable BooleanSupplier functions.
Event representing a state transition in the Brobot framework.
Methods used for state transitions
Orchestrates complex state transitions in the Brobot framework.
Retrieves and packages all transition components needed for state navigation.
Validates business rules for state transitions in Brobot configurations.
Marks a class as containing all transitions for a specific state.
Processes @TransitionSet classes and their @IncomingTransition and @OutgoingTransition methods to
build StateTransitions objects for the Brobot framework.
Defines maximum threshold values for action timing parameters.
Represents a collection of timing parameters and their execution results.
Manages collections of parameter tuning results for optimization analysis.
Configuration for Type actions, which send keyboard input.
Builder for constructing
TypeOptions with a fluent API.Types text to the window in focus in the Brobot model-based GUI automation framework.
Unified screen capture service that provides a single interface for all capture operations.
Represents the initial uncertain state in Brobot's state management system.
Represents a single validation error found during Brobot configuration validation.
Aggregates results from configuration validation operations.
Defines severity levels for validation errors in Brobot configurations.
Configuration for vanish actions.
Builder for constructing VanishOptions with a fluent API.
Represents a variable declaration statement in the Brobot DSL.
Represents a variable reference expression in the Brobot DSL.
Provides comprehensive, detailed output for action results.
Configuration for action verification and termination conditions.
Defines the type of condition that will terminate the action.
Defines the event that satisfies the termination condition.
Enumeration of possible verification result states.
Creates visual debugging output with annotated screenshots.
Visual implementation of the ElementLocator interface.
Aspect that provides automatic visual feedback during automation execution.
Configuration class for visual feedback components in Brobot.
Container for visual debugging and analysis illustrations in Brobot.
Provides matrix operations for arranging images in column-based layouts.
Orchestrates the creation of comprehensive visual illustrations for action results.
Creates visual representations of detected motion for debugging and analysis.
Monitors GUI elements for visual changes in the Brobot model-based GUI automation framework.
Waits for elements to disappear from the screen without embedded Find operations.
Windows-specific physical resolution capture.
Jackson mixin for java.awt.image.WritableRaster to control JSON serialization.