唐工-上位机视觉 · Bilibili · 2:55
This segment introduces the fundamental concept of 'operators' in HALCON. The video first explains operators as algorithmic tools provided by HALCON developers, drawing an analogy to functions that have inputs and outputs; it then characterizes HALCON usage as procedural—'reactive to each requirement'. Next, it enters the HDevelop coding environment and demonstrates one operator call: read_image (Image, 'printer_chip/printer_chip_01'), where the path string serves as input and Image as the output image variable, and after execution the graphics window displays the loaded circuit board image. At the segment's end, the presenter states the desire to also retrieve the image's width and height, though the corresponding code has not yet been written. This video segment primarily introduces the concept of 'operators' in the HALCON machine vision software. Through a hands-on demonstration of the get_image_size operator retrieving image dimensions, it visually illustrates that operators possess input parameters and output parameters. The presenter then explicitly states that 'operators' in HALCON are fundamentally the same as 'functions' in programming—only differing in name—and are pre-written tools designed to help beginners overcome unfamiliarity with specialized terminology.
Use the learning inspector for key ideas and moments, or open the reading tabs for the complete notes.
Generated from the video's visuals and explanation; not verbatim speech.
The segment opens with the title slide '1-7 Introduction to Operators'. The presenter states that this section will explain the underlying meaning of operators, establishing the theme for subsequent conceptual explanations and code demonstrations.
The slide poses '1. What is an operator?' and uses the relationship 'HALCON → tools' to clarify: within HALCON, operators are understood as a set of algorithmic tools provided by developers. The presenter further analogizes them to functions in programming, emphasizing that function-like tools typically have inputs and outputs.
The same slide continues, summarizing HALCON usage as 'procedural → reactive to each requirement'. Here, 'reactive to each requirement' is not a strict technical definition but rather the video's informal explanation: for each specific processing need, invoke the corresponding operator to accomplish the task.
The screen switches to the HALCON HDevelop code environment, with #main (::) visible at the top. The instructor begins demonstrating with code: to read an image, call read_image. The code is entered as read_image (Image, 'printer_chip/printer_chip_01'), where the path string is the input and Image is the output variable.
After execution, the graphics window displays a circuit board image, and 'Image' appears in the image variable area. This interface change directly confirms the earlier concept: operators, like functions, have inputs and outputs; the input determines the processing target, and the output returns the result object.
The presenter then introduces a new requirement: to obtain the image's width and height, another function must be called. The clip ends here, only introducing subsequent operator calls without actually writing the code for retrieving width and height.
In the HALCON software, we first use `read_image` to load an image of a printer chip. Next, to obtain the dimensions of this image, we enter the `get_image_size` operator in the code area, supplying the previously loaded image variable `Image` as input, and declaring `Width` and `Height` as output variables to receive the results.
After pressing F5 to run the program, observe the variable panel in the lower-left corner: `Width` is assigned the value 1600, and `Height` is assigned the value 1200. This clearly illustrates the operator’s mechanism: it has an ‘input port’ to receive data and an ‘output port’ to return processed values.
Many beginners feel unfamiliar with the term ‘operator’. In fact, an ‘operator’ in HALCON is essentially what we commonly call a ‘function’ in other programming languages. Operators are pre-written tools designed to perform specific tasks; they are simply referred to uniformly as operators within the HALCON context. Understanding this makes learning HALCON commands as natural as learning ordinary functions.
The video defines operators as algorithmic tools provided by HALCON developers, analogous to functions in programming. This explanation emphasizes that operators are not abstract slogans but concrete tools that can be invoked to accomplish specific tasks.
The presenter says functions are individual tools that have inputs and outputs. In the subsequent read_image example, 'printer_chip/printer_chip_01' serves as the input path and 'Image' as the output image variable, illustrating the entry and exit points of an operator call.
The video summarizes HALCON's usage style as 'procedural → respond to each situation as it arises': when encountering specific needs such as reading an image or retrieving its width and height, one simply invokes the corresponding operator. This phrase offers a colloquial explanation; the clip does not provide a rigorous definition of a programming paradigm.
After executing read_image in HDevelop, the graphics window displays the loaded circuit board image, and 'Image' appears newly in the image variable area. This example illustrates how a single operator call produces an output image object from an input path.
In the HALCON machine vision software, an ‘operator’ is not some esoteric or mysterious concept—it is, in fact, equivalent to a ‘function’ in programming. Operators are functional modules pre-developed by the official team or third parties; users invoke these operators to carry out tasks such as image reading, processing, and measurement. Viewing operators as functions helps lower the cognitive barrier for beginners.
Like ordinary functions, HALCON operators typically include input parameters and output parameters. Input parameters (‘entry points’) pass data requiring processing—such as images or regions—to the operator, while output parameters (‘exit points’) receive the operator’s results—such as computed area, retrieved width and height, or newly generated images. This mechanism ensures clear, modular data-processing workflows.
This is a typical application of an operator. Suppose we have already obtained an image variable `Image` via `read_image`. To retrieve its resolution, we call `get_image_size(Image, Width, Height)`, where `Image` is the input and `Width` and `Height` are the outputs. Upon execution, the system automatically assigns the image’s pixel width and height to these two variables (e.g., width 1600, height 1200).
Explore conditions, steps and evidence. Supplementary explanations are labeled separately from content shown in the video.
The orange text on the left side of the slide reads "halcon".
The instructor says, "We'll call it halcon."
halcon
In the video context, this refers to the HALCON machine vision software platform and the collection of algorithmic tools provided by its developers.
Machine vision / image processing software environment
In the code editor, type and highlight read_image (Image, 'printer_chip/printer_chip_01').
The instructor says, "I want to read an image, so I'll call a function."
read_image
Operator / function name in HALCON for reading image files.
HALCON HDevelop program statement
The first parameter of read_image is Image.
After execution, the variable area on the left displays Image along with a thumbnail of the image.
The instructor says, "It outputs an image type—you can see here, image."
Image
Output parameter of read_image, storing the loaded image object.
HALCON image variable
The second parameter of read_image is the string 'printer_chip/printer_chip_01'.
The instructor says, 'First, I will give it a path here so that it reads an image.'
'printer_chip/printer_chip_01'
Input parameter of read_image, specifying the file path or filename of the image to be read.
File path string
The HDevelop code window displays #main (::) at the top.
This segment does not explain the full syntactic meaning of #main (::).
#main (::)
HDevelop main program region identifier; code executes within this region.
HALCON HDevelop program structure
The code editor displays `read_image (Image, 'printer_chip/printer_chip_01')` and `get_image_size (Image, Width, Height)`, and the variable panel shows `Image`.
Image
The image variable, representing the loaded image data.
HALCON image object
The code editor displays `get_image_size (Image, Width, Height)`, and the variable panel shows `Width` with value 1600.
Width
The width of the image in pixels.
Integer
The code editor displays `get_image_size (Image, Width, Height)`, and the variable panel shows `Height` with value 1200.
Height
The height of the image in pixels.
Integer
The slide title reads '1. What is an operator?', where 'halcon' points to 'tool' via a green arrow.
The instructor says, 'An operator is actually a set of algorithmic tools developed by HALCON's developers.'
The instructor says, 'It is essentially like writing individual functions.'
The video explains 'operators' as a set of algorithmic tools provided by HALCON developers, analogized to individual functions. Their core characteristic is having inputs and outputs, like functions, and being used to accomplish specific processing tasks.
The video's context restricts the discussion of operators to the HALCON software.
Operators are analogized to functions or tools with inputs and outputs.
On the slide, 'procedural orientation' points via a green arrow to 'responding to each situation as it arises'.
The presenter says, 'Actually, we are building something procedural.'
The presenter says, 'What does it look like inside HALCON? Actually, it is procedural—responding to each situation as it arises.'
The video does not give a formal definition of 'procedural orientation', only offering the colloquial explanation 'responding to each situation as it arises'.
The video summarizes HALCON usage as 'procedural', using 'responding to each situation as it arises' to describe it: when a required processing action arises, one calls the corresponding operator or function to implement it.
This statement is the video's colloquial summary of HALCON's programming style.
The video explicitly states that joint programming will not be discussed for now, and the discussion remains strictly within HALCON.
The instructor says, "This function has inputs and outputs—it has entry points and exit points."
The code read_image (Image, 'printer_chip/printer_chip_01') contains both the output variable Image and the input path string.
After execution, the image variable area displays Image and shows the loaded image.
The video does not list the input/output direction rules for read_image parameters one by one; it only indicates the presence of entry and exit points through examples.
The video uses the read_image example to illustrate that operator or function calls typically have inputs and outputs: inputs supply data or paths, and outputs return processed results or objects.
For example, HALCON HDevelop code calls.
The output parameter Image receives the loaded image.
The input parameter is the image file path string.
The presenter says: "So, operators in HALCON are essentially functions. They are simply called operators in HALCON, but they are indeed individual functions—prewritten tools."
In the HALCON machine vision software, an 'operator' is fundamentally the same as a 'function' commonly found in programming. They are prewritten tools designed to perform specific image processing or computational tasks.
Applicable to understanding operator instructions in HALCON software
The instructor says: 'Look, isn't this also the same? It has an entry point—you input a variable, and it produces an output value.'
The code `get_image_size (Image, Width, Height)` demonstrates input `Image` and outputs `Width` and `Height`.
HALCON operators, like functions, have input parameters (entries) and output parameters (exits). Input parameters supply the data to be processed, and output parameters return the processed results.
Applicable to all HALCON operators with input and output parameters
The instructor says, "It is actually similar to writing functions one by one."
The instructor says, "Those who have studied programming know that a function is essentially a tool, right? Functions are tools—they have inputs and outputs."
This is an analogy used in the video, not a formal mathematical definition.
In the video context, HALCON operators resemble functions in programming: each operator performs a specialized task and has inputs and outputs.
The topic under discussion is HALCON operators.
The audience possesses a basic understanding of functions.
The focus is on how the HALCON operators shown in the video are used.
The code window is gradually filled from an empty line to read_image (Image, 'printer_chip/printer_chip_01').
After execution, the upper-left graphics window displays the circuit board image, and the variable area for images in the lower-left shows Image.
The presenter says, "I will first read out an image.", "I want to read an image, so I call a function.", "I first provide it with a path here so that it reads out an image.", "It outputs a type of image."
Entering the main program code area of HDevelop.
The screen shows that the top of the code window reads #main (::).
Calling read_image, passing the file path as input and assigning the output to the variable Image.
The instructor says that reading an image requires calling a function and passing it a path; the code shows two parameters.
After execution, an Image appears in the image variable area, and the graphics window displays the loaded image.
The screen shows that executing the code generates both an image variable and its content; the instructor points out that it outputs an image type.
This example illustrates that operator calls can obtain data through input parameters and return an image object through output parameters.
The code is read_image (Image, 'printer_chip/printer_chip_01').
After execution, the graphics window displays a circuit board image, and Image appears in the image variable area.
The instructor explains reading images, calling functions, passing paths as input, and returning images as output.
At the end of the segment, the instructor begins mentioning retrieving the image width and height but has not yet written the corresponding code.
Demonstrates how to load an image using an operator in HALCON HDevelop.
HDevelop main program environment.
The image path string 'printer_chip/printer_chip_01'.
Output the variable name Image.
Call the operator to read an image and observe the input and output.
Enter the read_image call in the code window.
The screen displays typing this statement character by character.
Execute this statement.
The presenter says "F execute", and the execution result appears on screen shortly after.
Check the image variable area, where Image appears along with the loaded image.
After execution, the left window displays both the image and the variable Image.
read_image takes a path string as input and outputs an image object to the variable Image.
The graphics window shows the circuit board image, and the image variable area displays Image, indicating successful reading.
The code editor contains `read_image (Image, 'printer_chip/printer_chip_01')` and `get_image_size (Image, Width, Height)`.
After pressing F5 to run, the variable panel at the lower left displays `Width` as 1600 and `Height` as 1200.
The instructor describes the process of reading an image's width and height and points out the numerical values in the output interface.
How do you obtain the width and height of a loaded image?
The loaded image variable Image
Obtain the image's width and height
First, read an image named printer_chip_01 into the variable Image.
Prepare the input data
Call the get_image_size operator, using Image as input and Width and Height as output variables.
Execute the size retrieval operation
After running the operator, check the obtained width and height values in the Variables window.
Observe the operator's execution result
The image's width is 1600 and its height is 1200.
Confirm that the values of Width and Height are 1600 and 1200 respectively by checking the 'Control Variables' panel in the lower-left corner of the software interface.
Slide title: "1. What is an operator?"; two relationships shown: halcon → tool, procedural → ad hoc.
A yellow circular cursor sequentially highlights the words halcon, tool, procedural, and ad hoc.
Title "1. What is an operator?"
Text "HALCON"
Text "tool"
Text "procedural"
Text "reactive"
Green arrow
Yellow circular cursor
The cursor moves over different words to support the explanation.
The slide's text content and arrow relationships remain unchanged.
Visually, arrows link HALCON with tool, and procedural with reactive, illustrating the tool-like nature of operators and the call-based programming style.
The HDevelop interface includes a graphics window, a code window, an image variable area, and a control variable area.
After entering read_image (Image, 'printer_chip/printer_chip_01') in the code window and executing it, the graphics window displays the circuit board image and the image variable area shows Image.
The status bar size text is small and is not extracted as primary mathematical content.
Code window
Graphics window
Image variable area
Control variable area
read_image statement
Image variable
Circuit board image
The code is typed from scratch to input the read_image call.
After execution, the graphics window changes from blank to displaying the image.
The Image variable area has a new Image.
The code and parameters are highlighted in blue.
The interface remains the HDevelop program editing and execution environment.
This animation shows one operator call, from writing and execution to generating output variables, illustrating the relationship between the input path and the output image.
Click the Run button with the mouse (or press F5); the corresponding line of code highlights during execution, and then the lower-left Variables panel updates to display the specific numerical values of Width and Height.
Code editor
Variable panel
Mouse pointer
Code execution status changes
Width and Height, along with their values, are added to the variable panel
The image display area remains unchanged
It demonstrates the process where output parameters receive concrete values after an operator executes, visually illustrating the operator's 'output' characteristic.
The presenter emphasizes that an operator is 'a set of algorithmic tools' and draws an analogy to functions having inputs and outputs.
The slide points HALCON toward 'tools'.
Seeing 'operator' may mistakenly suggest only mathematical symbols or formulas.
The video explains HALCON operators as callable algorithmic tools, emphasizing that they have inputs and outputs and can perform specific processing tasks.
The presenter says 'procedural-oriented means responding to each situation as it arises.'
The slide displays 'procedural-oriented → responding to each situation as it arises.'
'Responding to each situation as it arises' is a colloquial expression; the video does not elaborate on a strict definition of programming paradigms.
One might mistakenly take "Handle each situation as it arises" as a complete, procedural technical definition.
In the video, this phrase is used to illustrate step-by-step operator invocation in HALCON according to tasks, rather than providing a formal definition.
The instructor explicitly emphasizes, "Operators in HALCON are essentially functions... they are just called operators in HALCON."
Beginners might assume that "operators" in HALCON are a special concept entirely distinct from "functions" in ordinary programming languages.
The video clearly states that operators are fundamentally functions—merely termed operators within the HALCON software—and that they are prewritten tools.
The instructor compares operators to functions and states that functions have inputs and outputs.
The video's explanation of operators includes the feature "having inputs and outputs, like functions", which the read_image example further illustrates.
The instructor first states that HALCON is procedural and "handle-each-situation-as-it-arises", then says "Let us examine the code together".
Next, a read_image call demonstrates task-based operator invocation.
The read_image example concretely implements the idea of "procedural, handle-each-situation-as-it-arises": when image reading is needed, the corresponding operator is invoked.
The slide first shows halcon → tool.
Executing read_image in HDevelop produces an Image output.
The read_image invocation process is a concrete application example of "operators are algorithmic tools".
The instructor explains HALCON operators equivalently as functions.
Since operators are functions, they naturally possess the basic features of functions: input parameters and output parameters.
The slide title is "1. What is an operator?".
The presenter explains that operators are algorithmic tools developed by HALCON developers.
The presenter says functions have inputs and outputs, entry points and exit points.
Read an image (Image, 'printer_chip/printer_chip_01').
The slide shows 'Procedural orientation → Respond to each situation as it arises'.
The presenter says HALCON uses procedural orientation.
The code window displays read_image (Image, 'printer_chip/printer_chip_01').
After execution, the graphics window displays the image, and the variable area for images shows Image.
The presenter explains the relationship between operators and functions.
Demonstrates the usage of get_image_size.
Covered · The title slide reads '1-7 Operator Introduction', and the presenter opens the section by explaining that this segment introduces what operators are at the foundational level.
Covered · The slide explains that operators are HALCON's algorithmic tools, analogous to functions, and summarizes HALCON usage as procedural and reactive.
Covered · In HDevelop, enter and execute read_image (Image, 'printer_chip/printer_chip_01'); demonstrate input and output using the image variable and the graphics window; at the end, mention wanting to retrieve the image width and height but not yet writing the code.
Covered · Shows the complete process of reading an image and using the get_image_size operator to retrieve its width and height.
Covered · Building on the previous example, the presenter explains that operators have inputs (entry points) and outputs (exit points).
Covered · Core concept explanation: Operators in HALCON are essentially functions.
Covered · Polite closing remarks and a call for subscriptions at the end of the video—no mathematical or technical content.
Reviewed subject paths
In HALCON, an operator is essentially the same as a function in standard programming. They are prewritten tools designed to perform specific tasks.
Conditions: Applicable to understanding operator instructions in HALCON software.; The comparison is between HALCON operators and standard programming functions.
Operators are said to have inputs and outputs because they function as tools that require data or paths to process (inputs) and return processed results or objects (outputs). This mechanism ensures clear, modular data-processing workflows.
Conditions: Applicable to HALCON operators with input and output parameters.; The operator call is demonstrated in the HDevelop environment.
In HALCON, an operator is a set of algorithmic tools provided by the developers. It is analogous to a function in standard programming, designed to perform specific image processing tasks by accepting inputs and producing outputs.
Conditions: The discussion is restricted to the HALCON software environment.; Operators are analogized to functions with inputs and outputs.
To obtain the width and height of an image in HALCON, you use the get_image_size operator. You pass the loaded image variable as an input, and declare Width and Height variables as outputs to receive the pixel dimensions.
Conditions: The image must already be loaded into a variable (e.g., using read_image).; The operator get_image_size is called in the HDevelop environment.
The video interprets procedural orientation in HALCON as 'responding to each situation as it arises.' This means that when a specific processing need emerges, the user calls the corresponding operator or function to implement the task.
Conditions: This is the video's colloquial summary of HALCON's programming style.; The discussion remains strictly within HALCON, excluding joint programming.
The read_image example demonstrates the process by showing how to call an operator in HDevelop, pass a file path as an input parameter, and receive an image object as an output variable. After execution, the loaded image appears in the graphics window and the variable panel.
Conditions: The code is executed in the HALCON HDevelop main program region (#main).; The input is a valid image file path string.; The output is an image variable.
Continue with related videos in the same subject.
Bilibili18:45.61200000000008
Bilibili13:2.7000000000000455
Bilibili11:02