A description of the implementation details of these classes can be found in Note 216
This class, LELInterface, is the abstract base class for all of the letter classes. Its purpose is to declare the interface inherited by all of its derived classes which are used polymorphically. The derived classes offer the functionality to create and evaluate the expression tree that results from the compiler parsing the expression. For example, these derived classes are activated by LatticeExprNode to handle operations like reading pixels from a Lattice, applying binary operations to Lattices, applying mathematical functions to Lattices and so on.
The heart of the interface is in the functions eval and getScalar. These recursively evaluate the result of the current expression when the result is either an array or a scalar, respectively. The need for recursion can be understood with a simple example.
Consider an expression summing two Lattices such as "2*(b+c)". The expression tree consists of nodes (leaves) that 1) get Lattice pixels from the Lattice (expressions "b" and "c"), 2) add the pixel values of the Lattices together (operator "+"), and 3) multiply a Lattice by a scalar (operator "*"). At the top of the tree, we have a scalar (2.0) and a Lattice (the result of "b+c"). The top-of-the-tree expression has to multiply them together. That's what the eval function for the "*" operation needs to do. The key is that each of the "2.0" and "b+c" are really Lattice expressions themselves and they can be evaluated. So before the "*" eval function can multiply its two expressions together, it must individually evaluate them. Thus, it first calls the getScalar function of the object housing the expression "2.0". This will in fact return the scalar value "2.0". Then it calls eval on the expression object housing "b+c". This object in turn first calls eval on the left ("b") and right ("c") expressions which results in the pixels for the Lattices being returned. It then adds them together, returning the result to the top of the tree where they are multiplied by 2. You can see that since all these different expression objects call the eval or getScalar function that they all inherit from LELInterface. Indeed for our example above, the actual classes involved are are LELLattice (get pixels from Lattice) and LELBinary ("+" and "*" operators) which inherit from LELInterface. When these objects are constructed, they work out whether the result of their evaluation is a scalar or not. This is how the classes higher up the tree know whether to call eval or getScalar.
The results of the computations are either returned in the buffer in the eval function or by value by getScalar
The classes evaluate the expression for each specified Lattice chunk (usually tile by tile). The section argument in the eval function specifies the section of the Lattice being evaluated. The absence of the section argument in the getScalar function emphasises the scalar nature; a scalar expression does not have a shape. For most of the letter classes, the section argument is irrelevant; the only one it really matters for is LELLattice which fetches the pixels from the Lattice. The rest only care about the shape of the buffer in the eval call.
Evaluate the expression and fill the result array
Get the result of a scalar subexpression.
Get the result of an array subexpression. It does eval for the entire array. An exception is thrown if the shape of the subexpression is unknown.
Do further preparations (e.g. optimization) on the expression. It returns True if the expression is an invalid scalar (i.e. with a False mask). That can happen if the expression has a component with an invalid scalar value (e.g. min(lattice) where lattice contains no valid elements).
Is the result of evaluating this expression a scalar ?
Get the shape of the expression result.
Get expression attribute
Get class name
If the given expression is a valid scalar, replace it by its result. It returns False if the expression is no scalar or if the expression is an invalid scalar (i.e. with a False mask).
Handle locking/syncing of the parts of a lattice expression.
By default the functions do not do anything at all.
lock() and hasLock return True.