Into API documentation

Modules

▶

Core module

▶
Pii namespace
- Abs
 An adaptable unary function for taking the absolute value.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- Abs2
 An adaptable unary function for taking the absolute value of the square of a real number.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- AbsDiff
 
 An adaptable binary function that calculates the absolute difference of its arguments, .
 Template parameters
 <class T>
- AbsPow
 
 An adaptable binary function that raises the absolute value of its first argument to the power of the second argument.
 Template parameters
 <class T, class U, class R>
- AbsSum
 
 An adaptable binary function that calculates the sum of absolute values, .
 Template parameters
 <class T>
- Acos
 A unary function that returns acos(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- And
 A template that performs a logical AND operation on its boolean template parameters.
 Template parameters
 <bool, bool, bool, bool, bool, bool, bool>
 Specializations
 - < true, true, true, true, true, true, true >
- Asin
 A unary function that returns asin(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- Atan
 A unary function that returns tan(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- Atan2
 An adaptable binary function that calculates the arc tangent of two variables.
 Template parameters
 <class T>
 Specializations
 - < float >
- BinaryAnd
 
 An adaptable binary functor that performs the binary AND operation.
 Template parameters
 <class T>
- BinaryCompose
 
 A unary/binary function adaptor that makes the results of two unary functions the arguments of a binary function.
 Template parameters
 <class AdaptableBinaryFunction, class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
- BinaryFunction
 
 An stl-compatible model for an adaptable binary function.
 Template parameters
 <class, class, class>
- BinaryNot
 
 An adaptable binary unary functor that performs the binary NOT operation.
 Template parameters
 <class T>
- BinaryOr
 
 An adaptable binary functor that performs the binary OR operation.
 Template parameters
 <class T>
- BinaryShiftLeft
 
 An adaptable binary binary functor that shifts the left operand left as many times as indicated by the right operand.
 Template parameters
 <class T>
- BinaryShiftRight
 
 An adaptable binary binary functor that shifts the left operand right as many times as indicated by the right operand.
 Template parameters
 <class T>
- BinaryXor
 
 An adaptable binary functor that performs the binary XOR operation.
 Template parameters
 <class T>
- Bound
 
 A unary function that bounds its argument to a predefined range.
 Template parameters
 <class T>
- Cast
 
 An adaptable unary function that casts its argument from type From to type To.
 Template parameters
 <class From, class To>
- Ceil
 
 A unary function that returns ceil(x).
 Template parameters
 <class T>
- Conj
 
 An adaptable unary function that returns the complex conjugate of a real number (which is the argument itself) or a complex number.
 Template parameters
 <class T>
- Cos
 A unary function that returns cos(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- CountFunction
 
 A unary function that increments/decrements its internal counter by a predefined value each time the function is called.
 Template parameters
 <class T>
- EigenSystem
 
 Implements eigenvalue calculations and stores the results of the calculations (eigenvalues and eigenvectors).
 Template parameters
 <class tT, class tReal>
- Empty
 
 An empty structure.
- Exp
 
 An adaptable unary function for calculating the base-e exponential.
 Template parameters
 <class T>
- False
 
 A structure whose constant boolValue member evaluates to false.
- FastAtan2
 
 An adaptable binary function that uses a fast approximation (0.01 rad accuracy) to calculate the arc tangent of two variables.
 Template parameters
 <class T>
- FastestAtan2
 
 An adaptable binar function that uses a very fast but crude approximation (0.07 rad accuracy) to calculate the arc tangent of two variables.
 Template parameters
 <class T>
- Floor
 
 A unary function that returns floor(x).
 Template parameters
 <class T>
- ForEachFunction
 
 Helper function for algorithms that involve scrolling elements.
 Template parameters
 <class FuItem, class FuMemory>
- Generator
 
 An stl-compatible model for a generator function that takes no arguments.
 Template parameters
 <class>
- Hypotenuse
 An adaptable binary function that calculates the hypotenuse given two orthogonal sides of a triangle, .
 Template parameters
 <class T>
 Specializations
 - < int >
- Id
 
 A structure whose nested type, Type, is T.
 Template parameters
 <class T>
- Identity
 
 A unary function that returns its argument: f(x) = x.
 Template parameters
 <class T>
- IeeeFloat
 
 A class that wraps a floating-point number and allows one to twiddle its bits.
 Template parameters
 <class >
- IeeeFloatTraits< double >
 A traits structure that specifies the bit counts and corresponding integer types for the double type.
 Specializations
 - < double >
 - < float >
- If
 A conditional template.
 Template parameters
 <bool, class, class>
 Specializations
 - < false, Then, Else >
- IfClass
 
 A conditional template that accepts a type name as the condition parameter.
 Template parameters
 <class Condition, class Then, class Else>
- Imag
 A unary function that returns the imaginary part of its argument.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- IntIdentity
 
 Template parameters
 <int>
- Invert
 
 An adaptable unary function that returns the inverse of its argument (1/x).
 Template parameters
 <class T>
- IsArray
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is an array.
 Template parameters
 <class T>
 Specializations
 - < T[]>
- IsBaseOf
 
 A structure whose boolValue member evaluates statically to true if (and only if) Base is a base class of Derived.
 Template parameters
 <class Base, class Derived>
- IsColor
 A type trait for checking the colorness of a type.
 Template parameters
 <class T>
 Specializations
 - < PiiColor4< T > >
 - < PiiColor< T > >
- IsColor3
 Template parameters
 <class T>
 Specializations
 - < PiiColor< T > >
- IsColor4
 Template parameters
 <class T>
 Specializations
 - < PiiColor4< T > >
- IsComplex
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a complex number (std::complex).
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- IsConst
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a const type.
 Template parameters
 <class T>
 Specializations
 - < const T >
- IsFloatingPoint
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a floating point number type.
 Template parameters
 <class T>
 Specializations
- IsInteger
 
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is an integer type (either signed or unsigned).
 Template parameters
 <class T>
- IsNumeric
 
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a numeric primitive (non-bool) type.
 Template parameters
 <class T>
- IsNumericOrComplex
 
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a numeric primitive (non-bool) type or a complex number (std::complex).
 Template parameters
 <class T>
- IsPointer
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a pointer.
 Template parameters
 <class T>
 Specializations
 - < T * >
- IsPrimitive
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a primitive type.
 Template parameters
 <class T>
 Specializations
 - < bool >
- IsReference
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a reference.
 Template parameters
 <class T>
 Specializations
 - < T & >
- IsSame
 A tester struct whose boolValue member evaluates statically to true if the template parameters T and U are the same type.
 Template parameters
 <class T, class U>
 Specializations
 - < T, T >
- IsSigned
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a signed integer type.
 Template parameters
 <class T>
 Specializations
- IsUnsigned
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is an unsigned integer type.
 Template parameters
 <class T>
 Specializations
- Log
 
 An adaptable unary function for calculating the natural logarithm.
 Template parameters
 <class T>
- MatrixRowAdder
 
 A unary function that adds rows to a matrix.
 Template parameters
 <class T>
- Max
 
 An adaptable binary function that returns the maximum of its two arguments.
 Template parameters
 <class T>
- MaxInt
 
 Template parameters
 <int, int>
- Mean
 
 An adaptable unary function that calculates the sum of its arguments in successive calls and records the number of times the function has been called.
 Template parameters
 <class, class>
- Min
 
 An adaptable binary function that returns the minimum of its two arguments.
 Template parameters
 <class T>
- MinInt
 
 Template parameters
 <int, int>
- NoFunction
 
 A unary function (predicate) that always returns false.
 Template parameters
 <class T>
- Not
 
 Logical not operation.
 Template parameters
 <bool>
- NotClass
 
 Logical not operation.
 Template parameters
 <class T>
- Numeric
 
 Utility for miscellaneous numerical property definitions.
 Template parameters
 <class T>
- OnlyComplex
 
 A structure that has a nested type Type if and only if T is a numeric primitive type.
 Template parameters
 <class T>
- OnlyFloatingPoint
 
 A structure that has a nested type Type if and only if T is a floating-point type.
 Template parameters
 <class T>
- OnlyNumeric
 
 A structure that has a nested type Type if and only if T is a numeric primitive type.
 Template parameters
 <class T>
- OnlyNumericOrComplex
 
 A structure that has a nested type Type if and only if T is a numeric primitive type or a complex number.
 Template parameters
 <class T>
- OnlyPrimitive
 
 A structure that has a nested type Type if and only if T is a primitive type.
 Template parameters
 <class T>
- Or
 A template that performs a logical OR operation on its boolean template parameters.
 Template parameters
 <bool, bool, bool, bool, bool, bool, bool>
 Specializations
 - < false, false, false, false, false, false, false >
- Pow
 
 An adaptable binary function that raises its first argument to the power of the second argument.
 Template parameters
 <class T, class U>
- PtrToValue
 A static functor that converts pointers to values and keeps other types as such.
 Template parameters
 <class T>
 Specializations
 - < T * >
- Real
 A unary function that returns the real part of its argument.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- RealReturnValue
 A trait structure that converts any input type to a real output type.
 Template parameters
 <class T>
 Specializations
 - < float >
- RefToValue
 A static functor that converts references to values and keeps other types as such.
 Template parameters
 <class T>
 Specializations
 - < T & >
- Round
 
 An adaptable unary function that rounds its argument to the closest integer.
 Template parameters
 <class From, class To>
- SelectFirst
 
 A binary function that returns its first argument: f(x,y) = x.
 Template parameters
 <class T, class U>
- SelectSecond
 
 A binary function that returns its second argument: f(x,y) = y.
 Template parameters
 <class T, class U>
- Sign
 
 A unary function that returns the sign (1, 0, or -1) of its argument.
 Template parameters
 <class T>
- Sin
 A unary function that returns sin(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- Sqrt
 A unary function that returns the square root of its argument.
 Template parameters
 <class T>
 Specializations
 - < float >
- Square
 
 An adaptable unary function that returns the square of its argument.
 Template parameters
 <class T>
- SquaredDiff
 
 An adaptable binary function that calculates the squared difference of its arguments, .
 Template parameters
 <class T>
- Tan
 A unary function that returns tan(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- TernaryFunction
 
 A model for an adaptable ternary function.
 Template parameters
 <class, class, class, class>
- ToFloatingPoint
 Converts a type to a corresponding floating-point type.
 Template parameters
 <class T>
 Specializations
- ToNonConst
 A structure whose member type Type is a non-const version of the template parameter T.
 Template parameters
 <class>
 Specializations
 - < const T >
- ToPointer
 A static functor that converts references to pointers and keeps pointers as such.
 Template parameters
 <class T>
 Specializations
 - < T * >
- ToReference
 A static functor that converts pointers to references and keeps references as such.
 Template parameters
 <class T>
 Specializations
 - < T * >
- True
 
 A structure whose constant boolValue member evaluates to true.
- UnaryCompose
 
 A unary function adaptor that makes the result of one unary function the argument of another.
 Template parameters
 <class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
- UnaryFunction
 
 An stl-compatible model for an adaptable unary function.
 Template parameters
 <class, class>
- VaArg
 Type for values passed through the va_arg mechanism ("..." in function parameters).
 Template parameters
 <class>
 Specializations
- ValueType
 The Type member typedef of this structure maps to the value_type member type of the type given as the template argument.
 Template parameters
 <class T>
 Specializations
 - < T * >
- YesFunction
 
 A unary function (predicate) that always returns true.
 Template parameters
 <class T>
- abs
 A generic template for absolute value.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
- abs2
 Returns the absolute value ov value squared.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (const std::complex< T > & value)
- accumulate
 
 Loops through all values in the range [begin, end) and applies func to each element and the current value of initialValue.
 Parameters
 (InputIterator begin, InputIterator end, BinaryFunction func, T initialValue)
- accumulateIf
 
 Loops through all values in the range [begin, end) and applies func to each element and the current value of initialValue, if predicate returns a non-zero value for the element.
 Parameters
 (InputIterator begin, InputIterator end, UnaryPredicate predicate, BinaryFunction func, T initialValue)
- accumulateN
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This fuction works in the range [begin, begin + n).
 Parameters
 (InputIterator begin, int n, BinaryFunction func, T initialValue)
- acos
 Parameters
 (T value)
 Overloads
 - (float value)
- alignAddress
 
 Align a memory address.
 Parameters
 (T address, size_t bitMask)
- almostEqual
 Compares each element in the range [begin, end) to the corresponding element in the range starting at begin2.
 Parameters
 (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, typename std::iterator_traits< InputIterator1 >::value_type tolerance)
 Overloads
 - (const PiiConceptualMatrix< Matrix1 > & mat1, const PiiConceptualMatrix< Matrix2 > & mat2, typename Matrix1::value_type tolerance)
- angleDiff
 
 Returns the difference between two angles (in radians).
 Parameters
 (T angle1, T angle2, typename Pii::OnlyFloatingPoint< T >::Type )
- argsToList
 Converts args to to a QVariantList, assuming that each argument is a valid pointer of the type specified by types.
 Parameters
 (const QList< int > & types, void ** args)
 Overloads
 - (int argc, char * argv)
- arrayCopy
 
 Performs array copy of non-overlapping arrays.
 Parameters
 (T * to, const T * from, const size_type itemCount)
- asin
 Parameters
 (float value)
 Overloads
 - (T value)
- atan
 Parameters
 (float value)
 Overloads
 - (T value)
- atan2
 
 A fast (but slower than fastAtan2()) approximation to four-quadrant arctan.
 Parameters
 (float y, float x)
- bdDecompose
 
 Reduces a rectangular matrix to a bidiagonal form.
 Parameters
 (PiiMatrix< Real > & A, PiiMatrix< Real > & tauQ, PiiMatrix< Real > & tauP)
- bdUnpackB
 
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (PiiMatrix< Real > & A)
- bdUnpackDiagonals
 
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (const PiiMatrix< Real > & A, Real * d, Real * e)
- bdUnpackP
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (PiiMatrix< Real > & V, const Real * tauP, const int diagonal, PiiMatrix< Real > & T)
 Overloads
 - (const PiiMatrix< Real > & A, const Real * tauP)
- bdUnpackQ
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (PiiMatrix< Real > & V, const Real * tauQ, const int diagonal, PiiMatrix< Real > & T)
 Overloads
 - (const PiiMatrix< Real > & A, const Real * tauQ)
- calculateArea
 
 Calculates the area of a triangle, given the lenghts of its sides.
 Parameters
 (double a, double b, double c)
- calculateInterveningAngle
 
 Calculates the angle between sides a and b, given the known lengths of the sides and the angle opposite to side a.
 Parameters
 (double a, double b, double angle)
- calculateOppositeAngle
 
 Calculates the angle opposite to side a, given the known lengths of all sides of a triangle.
 Parameters
 (double a, double b, double c)
- calculateThirdSide
 
 Calculates the length of the third side of a triangle, given the lengths of two adjacent sides and the angle between them.
 Parameters
 (double a, double b, double angle)
- ceil
 Returns ceil(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- centralDiff
 
 Calculates two-point central difference.
 Parameters
 (const PiiMatrix & mat, MatrixDirection direction)
- collectionToVariants
 
 Convert any collection to a QVariantList that contains the same values as QVariant objects.
 Parameters
 (const Collection & lst)
- columnToList
 
 Get a column from a matrix as a collection (QList, QVector)
 Parameters
 (const PiiMatrix< T > & matrix, int column)
- combinations
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 Parameters
 (int n, int k, UnaryFunction func, Storage storage)
 Overloads
 - (int n, int k, UnaryFunction func)
- concatenate
 
 Concatenate two matrices.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & mat1, const PiiConceptualMatrix< Matrix2 > & mat2, Pii::MatrixDirection direction)
- conj
 Calculates the complex conjugate of a real number.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (const std::complex< T > & value)
- convertToGray
 
 Converts any color image (rgb/indexed) to gray scale.
 Parameters
 (QImage & img)
- convertToRgba
 
 Converts any image to 32-bit rgb.
 Parameters
 (QImage & img)
- copy
 
 Copies all elements in the range [begin, end) to output.
 Parameters
 (InputIterator begin, InputIterator end, OutputIterator output)
- copyMetaType
 
 Copies the object pointed to by source to the memory location at target.
 Parameters
 (QVariant::Type type, const void * source, void * target)
- copyN
 
 Copies n elements starting at begin to output.
 Parameters
 (InputIterator begin, int n, OutputIterator output)
- copySign
 
 Parameters
 (T value, T sign)
- copyVaArgs
 
 Copies a variable number of arguments to a range of elements bounded by the iterators begin and end.
 Parameters
 (Iterator begin, Iterator end, typename Pii::VaArg< typename std::iterator_traits< Iterator >::value_type >::Type first, ... )
- copyVaList
 
 Copies a variable argument list to a range of elements.
 Parameters
 (Iterator begin, Iterator end, typename Pii::VaArg< typename std::iterator_traits< Iterator >::value_type >::Type first, va_list rest)
- cos
 Returns cos(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- countOnes
 Get the number of ones in a binary number.
 Parameters
 (unsigned int c, const unsigned char bits)
 Overloads
 - (unsigned int c)
- countTransitions
 Get the number of 0-to-1 or 1-to-0 transitions in a binary number.
 Parameters
 (unsigned int c, const unsigned char bits)
 Overloads
 - (unsigned int c)
- covariance
 
 Calculates the covariance matrix for a set of measurements.
 Parameters
 (const PiiMatrix< T > & mat, PiiMatrix< double > * mean)
- createQImage
 Parameters
 (PiiMatrix< T > & matrix)
 Overloads
 - (const PiiMatrix< T > & matrix)
 - (const PiiMatrix< PiiColor< T > > & matrix)
- crossProduct
 
 Calculates the cross product of two vectors m1 and m2.
 Parameters
 (const PiiMatrix< T > & m1, const PiiMatrix< T > & m2)
- cumulativeSum
 Calculates two-dimensional cumulative sum of a matrix.
 Parameters
 (const PiiRandomAccessMatrix & matrix, UnaryFunction func, CumulativeSumMode mode)
 Overloads
 - (const PiiRandomAccessMatrix & mat, CumulativeSumMode mode)
 - (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- decodeProperties
 
 Decode string-encoded properties into a variant map.
 Parameters
 (const QString & encodedProperties, QChar propertySeparator, QChar valueSeparator, QChar escape, PropertyDecodingFlags flags)
- degToRad
 
 Convert an angle from degrees to radians.
 Parameters
 (double deg)
- deleteAll
 
 Delete all members of a collection.
 Parameters
 (Collection & c)
- determinant
 
 calculate the determinant of a matrix.
 Parameters
 (const PiiMatrix< T > & mat)
- determinant2x2
 
 Calculates determinant of 2x2 matrix with direct calculation.
 Parameters
 (const PiiMatrix< T > & m)
- determinant3x3
 
 Calculates determinant of 3x3 matrix with direct calculation.
 Parameters
 (const PiiMatrix< T > & m)
- diff
 
 Difference and approximate derivative.
 Parameters
 (const PiiMatrix< T > & mat, int step, int order, MatrixDirection direction)
- divide
 
 Divide the elements in m1 by the corresponding elements in m2.
 Parameters
 (PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
- divided
 
 Divide the elements in m1 by the corresponding elements in m2.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
- epsilon
 
 Calculates the distance from abs(value) to the next real number larger in magnitude.
 Parameters
 (Real value)
- equals
 
 Compare two matrices.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & mat1, const PiiConceptualMatrix< Matrix2 > & mat2)
- erf
 
 Returns the value of the inverse normal cumulative distribution function (a.k.a the error function, erf) at p.
 Parameters
 (double p)
- exp
 Returns exp(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- extend
 Extend a matrix by adding new rows/columns to its sides.
 Parameters
 (const PiiMatrix< T > & mat, int amount, ExtendMode mode, int sides)
 Overloads
 - (const PiiMatrix< T > & mat, int topRows, int bottomRows, int leftCols, int rightCols, ExtendMode mode)
- factorial
 
 Returns the factorial of n (n!).
 Parameters
 (T n)
- fastAtan2
 
 A very fast approximation to four-quadrant arctan.
 Parameters
 (float y, float x)
- fastMedian
 
 Returns the median of all elements in data.
 Parameters
 (Iterator data, int len)
- fastMovingAverage
 Fast 2-D moving average.
 Parameters
 (const PiiMatrix< T > & cumulativeSum, int windowRows, int windowColumns)
 Overloads
 - (InputIterator input, int n, OutputIterator output, int windowSize)
- fileList
 
 Fetch a list of files matching a wildcard.
 Parameters
 (const QString & pattern, QDir::Filters filters, QDir::SortFlags sort)
- fill
 
 Sets all values in the range [begin, end) to value.
 Parameters
 (Iterator begin, Iterator end, typename std::iterator_traits< Iterator >::value_type value)
- fillIf
 
 Sets all values in the range [begin, end) for which predicate returns a non-zero value to value.
 Parameters
 (Iterator begin, Iterator end, UnaryPredicate predicate, typename std::iterator_traits< Iterator >::value_type value)
- fillN
 
 Sets all values in the range [begin, begin + b) to value.
 Parameters
 (Iterator begin, int n, typename std::iterator_traits< Iterator >::value_type value)
- find
 Find the row and column coordinates of all elements in mat that match predicate.
 Parameters
 (const PiiMatrix< T > & mat, UnaryPredicate predicate, int cnt)
 Overloads
 - (const PiiMatrix< T > & mat, int cnt)
- findAllParents
 
 Find all parent objects of obj up to maxParents parent objects.
 Parameters
 (const QObject * obj, unsigned int maxParents)
- findCommonParent
 
 Find the object that is the closest common ancestor of obj1 and obj2 in the object hierarchy.
 Parameters
 (const QObject * obj1, const QObject * obj2, int * parentIndex)
- findFirst
 Find the first occurrence of an element that matches Rule.
 Parameters
 (const PiiMatrix< T > & matrix, T value, int & r, int & c)
 Overloads
 - (const PiiMatrix< T > & matrix, T value, int & r, int & c)
- findFirstParent
 
 Find the first parent of obj whose type matches T.
 Parameters
 (const QObject * obj)
- findLast
 Find the last occurrence (bottom to top, right to left) of value in matrix.
 Parameters
 (const PiiMatrix< T > & matrix, T value, int & r, int & c)
 Overloads
 - (const PiiMatrix< T > & matrix, T value, int & r, int & c)
- findMaxima
 
 Find cnt largest values in mat.
 Parameters
 (const PiiMatrix< T > & mat, int cnt)
- findMinima
 
 Find cnt smallest values in mat.
 Parameters
 (const PiiMatrix< T > & mat, int cnt)
- findNeighbors
 
 Recursively connects neighbors given as a list of pairs.
 Parameters
 (QLinkedList< QPair< int, int > > & pairs)
- findSeparator
 
 Returns the index of the first occurrence of separator in str, starting at startIndex.
 Parameters
 (const QString & str, QChar separator, int startIndex, QChar escape)
- findSpecialValue
 
 Find a special value such as maximum or minimum in the range specified by begin and end.
 Parameters
 (InputIterator begin, InputIterator end, BinaryPredicate op, UnaryFunction f)
- firstOneBit
 
 Find the index of the first bit set to one.
 Parameters
 (T c)
- fitPolynomial
 
 Fit a polynomial curve to data.
 Parameters
 (unsigned int order, const PiiMatrix< double > & x, const PiiMatrix< double > & y)
- flip
 
 Flip matrix in place either horizontally, vertically or both.
 Parameters
 (PiiMatrix< T > & matrix, Pii::MatrixDirections directions)
- flipped
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This function doesn't modify the source matrix, but returns a copy.
 Parameters
 (const PiiMatrix< T > & mat, Pii::MatrixDirections directions)
- floatSignBit
 Returns the sign bit of value1 - value2.
 Parameters
 (double value1, float value2)
 Overloads
 - (T value1, float value2)
- floor
 Returns floor(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- forEach
 
 Applies func to each element in the range [begin, end).
 Parameters
 (InputIterator begin, InputIterator end, UnaryFunction func)
- forEachIf
 
 Applies func to each element in the range [begin, end) for which predicate returns a non-zero value.
 Parameters
 (InputIterator begin, InputIterator end, UnaryPredicate predicate, UnaryFunction func)
- gaussian
 
 A Gaussian function.
 Parameters
 (T x, double mu, double sigma)
- gcd
 
 Find the greatest common divisor (gcd) for the given two numbers using Euclid's algorithm.
 Parameters
 (T number1, T number2)
- generate
 
 Sets all values in the range [begin, end) to the value returned by generator.
 Parameters
 (Iterator begin, Iterator end, Generator generator)
- generateN
 
 Sets all values in the range [begin, begin + n) to the value returned by generatore.
 Parameters
 (Iterator begin, int n, Generator generator)
- grayColorTable
 
 Returns a color table with shades of gray from zero to 255.
- hammingDistance
 Calculate the Hamming distance between two binary numbers.
 Parameters
 (unsigned int a, unsigned int b, const unsigned char bits)
 Overloads
 - (unsigned int a, unsigned int b)
- householderTransform
 
 Generates an elementary reflector (a.k.a the Householder transformation).
 Parameters
 (Iterator x, int n, typename std::iterator_traits< Iterator >::value_type * tau, typename std::iterator_traits< Iterator >::value_type * beta)
- hypotenuse
 
 Calculates the hypotenuse given two orthogonal sides of a triangle.
 Parameters
 (T a, T b)
- imag
 Returns the imaginary part of a real number, i.e.
 Parameters
 (T , typename OnlyNumeric< T >::Type )
 Overloads
 - (const std::complex< T > & value)
- innerProduct
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 Parameters
 (const PiiVector< T, D > & v1, const PiiVector< T, D > & v2)
 Overloads
- innerProductN
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Returns the inner product of two n-dimensional vectors.
 Parameters
 (InputIterator1 begin1, int n, InputIterator2 begin2, T initialValue)
- insertionSort
 
 Classical insertion sort.
 Parameters
 (T * data, int size)
- intersect
 
 Find the intersection of two lists.
 Parameters
 (const Collection & list1, const Collection & list2)
- inverse
 
 Invert a matrix.
 Parameters
 (const PiiMatrix< T > & mat)
- isAntiSymmetric
 
 Tests if a matrix is antisymmetric.
 Parameters
 (const PiiMatrix< T > & mat)
- isDiagonal
 
 Test if a matrix is diagonal.
 Parameters
 (const PiiMatrix< T > & mat)
- isInf
 
 Returns true if f equals Inf.
 Parameters
 (T f)
- isNan
 
 Returns true if f is NaN.
 Parameters
 (T f)
- isOrthogonalLike
 Tests whether the given real matrix is "orthogonal-like".
 Parameters
 (const PiiMatrix< T > & mat, const T & tolerance)
 Overloads
 - (const PiiMatrix< T > & mat)
- isParent
 
 Returns true if parent is a parent of child.
 Parameters
 (const QObject * parent, const QObject * child)
- isSingular
 
 Test if a matrix is singular.
 Parameters
 (const PiiMatrix< T > & mat)
- isSquare
 
 Tests whether the given matrix is square matrix.
 Parameters
 (const PiiMatrix< T > & mat)
- isSymmetric
 
 Test if a matrix is symmetric about the diagonal.
 Parameters
 (const PiiMatrix< T > & mat)
- join
 
 Find the union of two lists.
 Parameters
 (const Collection & list1, const Collection & list2)
- kthSmallest
 
 Returns the k:th smallest element from array.
 Parameters
 (T * data, int size, int k)
- lastOneBit
 
 Find the index of the last bit set to one.
 Parameters
 (T c)
- listToMatrix
 
 Converts a collection to a row matrix.
 Parameters
 (const Collection & lst, Pii::MatrixDirection direction)
- listToVariants
 
 Convert a QList to a QVariantList that contains the same values as QVariant objects.
 Parameters
 (const QList< T > & lst)
- log
 Returns log(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- map
 Applies a unary function func to all elements in the range [begin, end), and stores the result in place.
 Parameters
 (Iterator begin, Iterator end, UnaryFunction func)
 Overloads
 - (Iterator1 begin1, Iterator1 end1, Iterator2 begin2, BinaryFunction func)
- mapIf
 
 Applies a unary function func to all elements in the range [begin, end) for which predicate returns a non-zero value.
 Parameters
 (Iterator begin, Iterator end, UnaryPredicate predicate, UnaryFunction func)
- mapMatrix
 
 Applies the unary function func to all elements of matrix.
 Parameters
 (PiiConceptualMatrix< Matrix > & matrix, UnaryFunction func)
- mapMatrixIf
 
 Applies the unary function func to all elements of matrix that match the given predicate.
 Parameters
 (PiiConceptualMatrix< Matrix > & matrix, UnaryPredicate predicate, UnaryFunction func)
- mapN
 Applies a binary function func to all elements in the range [begin1, begin1 + n), and stores the result in place.
 Parameters
 (Iterator1 begin1, int n, Iterator2 begin2, BinaryFunction func)
 Overloads
 - (Iterator begin, int n, UnaryFunction func)
- mappedMatrix
 
 Applies the unary function func to all elements of matrix.
 Parameters
 (PiiConceptualMatrix< Matrix > & matrix, UnaryFunction func)
- mappedMatrixIf
 
 Applies the unary function func to all elements of matrix that match the given predicate.
 Parameters
 (const PiiConceptualMatrix< Matrix > & matrix, UnaryPredicate predicate, UnaryFunction func)
- matchCrontab
 
 Match a list of crontab-like strings against the given time stamp.
 Parameters
 (QStringList list, QDateTime timeStamp)
- matlabParse
 
 Parse a string that describes a matrix in Matlab syntax.
 Parameters
 (const QString & str)
- matlabPrint
 
 Print out a matrix in a matlab-friendly format.
 Parameters
 (Stream & out, const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & mat)
- matrix
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This specialization just returns mat.
 Parameters
 (const PiiMatrix< T > & mat)
- max
 Calculates the maximum among all elements in the specified direction.
 Parameters
 (const PiiMatrix< T > & mat, MatrixDirection direction)
 Overloads
- maxAbsAll
 
 Like maxAll(), but finds the maximum absolute value.
 Parameters
 (const PiiMatrix< T > & mat, int * r, int * c)
- maxAll
 Shorthand for maxAll(collection.begin(), collection.end()).
 Parameters
 (const Collection & collection)
 Overloads
 - (InputIterator begin, InputIterator end)
 - (const PiiMatrix< T > & mat, int * r, int * c)
- mean
 
 Calculates the mean of matrix elements in the specified direction.
 Parameters
 (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- meanAll
 
 Calculates the mean of all entries in a matrix.
 Parameters
 (const PiiConceptualMatrix< Matrix > & mat)
- median
 
 Returns the median of all elements in data.
 Parameters
 (Iterator data, int len)
- median25
 
 Median of 25 values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median3
 
 Median of three values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median5
 
 Median of five values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median7
 
 Median of seven values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median9
 
 Median of nine values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- medianAll
 
 Returns the median of all elements in mat.
 Parameters
 (const PiiMatrix< T > & mat)
- min
 Calculates the minimum among all elements in the specified direction.
 Parameters
 (const PiiMatrix< T > & mat, MatrixDirection direction)
 Overloads
- minAll
 Calculates the minimum of all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, int * r, int * c)
 Overloads
 - (InputIterator begin, InputIterator end)
 - (const Collection & collection)
- minMax
 
 Find the maximum and maximum of all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, T * minimum, T * maximum, int * minR, int * minC, int * maxR, int * maxC)
- mod
 
 Returns the "modulus" of a floating point number.
 Parameters
 (T d1, T d2, typename OnlyFloatingPoint< T >::Type )
- movingAverage
 Calculates the moving average of a sequence bounded by begin and end.
 Parameters
 (Iterator begin, Iterator end, int width)
 Overloads
 - (const PiiMatrix & mat, int width, MatrixDirection direction, EndPointHandling endPointHandling)
- multiplied
 
 Multiplies the elements in m1 and m2.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
- multiply
 Multiply the elements in m1 by the corresponding elements in m2.
 Parameters
 (PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
 Overloads
 - (const PiiMatrix< T > & matrix, InputIterator input, OutputIterator output)
 - (InputIterator input, const PiiMatrix< T > & matrix, OutputIterator output)
- normalize
 
 Normalizes vectors in a matrix.
 Parameters
 (PiiRandomAccessMatrix & mat, MatrixDirection direction)
- normalized
 
 Normalizes vectors in a matrix.
 Parameters
 (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- normalRandom
 
 Returns a random number from a distribution that follows N(0,1) (zero mean, unit variance Gaussian distribution).
- normalRandomMatrix
 
 Returns a rows x columns matrix filled with normally distributed random numbers.
 Parameters
 (int rows, int columns)
- operator<<
 
 Write a QString to an std output stream.
 Parameters
 (std::ostream & out, const QString & str)
- parseTypes
 
 Converts comma-separated type names to a list of type IDs.
 Parameters
 (const QByteArray & types)
- partition
 
 Returns array which is arranged so that; there exist index k which value is restricted to 0 <= k < size.
 Parameters
 (T * data, int size, int pivot)
- pcaDecorrelate
 
 Decorrelates a possibly correlated set of data.
 Parameters
 (const PiiRandomAccessMatrix & X)
- permutations
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 Parameters
 (int n, UnaryFunction func, Storage storage)
 Overloads
 - (int n, UnaryFunction func)
- PII_DECLARE_EXPORTED_FUNCTION_TEMPLATE
 Parameters
 (void , setProperties< QSettings > , (QObject &obj, const QStringList &properties, const QSettings &valueMap, Qt::CaseSensitivity sensitivity, const QString &commentMark) , PII_BUILDING_CORE )
 Overloads
 - (void , setProperties< QVariantMap > , (QObject &obj, const QStringList &properties, const QVariantMap &valueMap, Qt::CaseSensitivity sensitivity, const QString &commentMark) , PII_BUILDING_CORE )
- PII_MATH_MATRIX_TRANSFORM
 Returns a matrix whose elements are absolute values of mat squared.
 Parameters
 (abs2 , Abs2 )
 Overloads
 - (abs , Abs )
- pow
 Raise value to an integer power (n).
 Parameters
 (T value, int n, typename OnlyNumeric< T >::Type )
 Overloads
 - (double value, double n)
 - (float value, float n)
- principalComponents
 
 Returns the PCA base vectors for a data set in X.
 Parameters
 (const PiiRandomAccessMatrix & X, PiiMatrix< typename Matrix::value_type > * S)
- printMatrix
 
 Print matrix in a user-defined format.
 Parameters
 (Stream & out, const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & mat, const ColSeparator & columnSeparator, const RowSeparator & rowSeparator)
- properties
 
 Fetch the properties of a QObject as a map of name-value pairs.
 Parameters
 (const QObject & obj, int propertyOffset, PropertyFlags flags)
- propertyList
 
 Returns the properties of obj as a list.
 Parameters
 (const QObject & obj, int propertyOffset, PropertyFlags flags)
- propertyName
 
 Finds the name of a property in obj that matches name in a case-insensitive manner.
 Parameters
 (const QObject & obj, const QString & name)
- pseudoInverse
 
 Returns the Moore-Penrose pseudoinverse of an m-by-n matrix.
 Parameters
 (const PiiRandomAccessMatrix & A)
- Q_DECLARE_FLAGS
 Parameters
 (MatrixDirections , MatrixDirection )
 Overloads
 - (SvdOptions , SvdOption )
 - (PropertyFlags , PropertyFlag )
- Q_FLAGS
 
 Parameters
 (MatrixDirection MatrixDirections)
- qHash
 
 Hash function for null-terminated C strings.
 Parameters
 (const char * key)
- qrDecompose
 QR decomposition.
 Parameters
 (PiiRandomAccessMatrix & A, PiiMatrix< typename Matrix::value_type > & tau)
 Overloads
 - (PiiRandomAccessMatrix & A, typename Matrix::value_type * tau, typename Matrix::value_type * bfr)
 - (const PiiRandomAccessMatrix & A, PiiMatrix< typename Matrix::value_type > * R, QrUnpackStyle style)
- qrUnpack
 Unpacks the result of QR decomposition.
 Parameters
 (PiiMatrix< Real > & A, const Real * tau, PiiMatrix< Real > & T, PiiMatrix< Real > & gram)
 Overloads
 - (PiiMatrix< Real > & A, const PiiMatrix< Real > & tau, PiiMatrix< Real > * R, QrUnpackStyle style)
- radToDeg
 
 Convert an angle from radians to degrees.
 Parameters
 (double rad)
- randomizeMatrix
 
 Set random elements from range specified by parameters lowerBound and upperBound to matrix.
 Parameters
 (PiiMatrix< T > & mat, const T & lowerBound, const T & upperBound)
- rank
 
 Estimates the number of linearly independent rows or columns of a matrix.
 Parameters
 (const PiiRandomAccessMatrix & mat, typename Matrix::value_type tolerance)
- real
 Returns the real part of a complex number.
 Parameters
 (const std::complex< T > & value)
 Overloads
 - (T value, typename OnlyNumeric< T >::Type )
- reflectColumns
 Applies a reflection transform to a rectangular matrix from the left.
 Parameters
 (PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & A, InputIterator v, typename Matrix::value_type tau, typename Matrix::value_type * bfr)
 Overloads
 - (PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & A, InputIterator v, typename Matrix::value_type tau)
- reflectRows
 
 Applies a reflection transform to a rectangular matrix from the right.
 Parameters
 (PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & A, InputIterator v, typename Matrix::value_type tau)
- replaceVariables
 
 Replaces variables in string and returns a new string.
 Parameters
 (const QString & string, const VariableMap & variables)
- replicate
 
 Replicate a matrix vertical times vertically and horizontal times horizontally.
 Parameters
 (const PiiMatrix< T > & matrix, int vertical, int horizontal)
- rol
 Parameters
 (unsigned short c, const unsigned char n)
 Overloads
- rol< INTBITS >
 
 Parameters
 (unsigned int c, const unsigned char n)
- ror
 Rotate a binary code right by n positions.
 Parameters
 (unsigned int c, const unsigned char n, const unsigned char bits)
 Overloads
- ror< INTBITS >
 
 Parameters
 (unsigned int c, const unsigned char n)
- rotateColumns
 
 Parameters
 (mat , 0 , 1 )
- rotateToMinimum
 Rotate a binary number to its minimum value.
 Parameters
 (unsigned int n, const unsigned char bits)
 Overloads
 - (unsigned int n)
- round
 Rounds a double argument to the closest integer.
 Parameters
 (double value)
 Overloads
 - (T value, typename OnlyNumeric< T >::Type )
- rowToList
 
 Get a row from a matrix as a collection (QList, QVector)
 Parameters
 (const PiiMatrix< T > & matrix, int row)
- scoreOverload
 
 Returns a numerical score for the goodness of a parameter set given a list of expected types.
 Parameters
 (const QVariantList & params, const QList< int > & types)
- seedRandom
 Seeds the random number generator with your favourite value.
 Parameters
 (long value)
 Overloads
 - ()
- selectRandomly
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Randomly selects n distinct integers in [0, max-1] and stores them to indices.
 Parameters
 (QVector< int > & indices, int n, int max)
 Overloads
 - (Collection & target, const Collection & source, int n)
 - (int n, int max)
- sequence
 Assigns sequentially increasing values to the range [begin, end).
 Parameters
 (Iterator begin, Iterator end, typename std::iterator_traits< Iterator >::value_type initialValue)
 Overloads
 - (Iterator begin, Iterator end, typename std::iterator_traits< Iterator >::value_type initialValue, typename std::iterator_traits< Iterator >::value_type step)
- sequenceN
 Assigns sequentially increasing values to the range [begin, end + n).
 Parameters
 (Iterator begin, int n, typename std::iterator_traits< Iterator >::value_type initialValue)
 Overloads
 - (Iterator begin, int n, typename std::iterator_traits< Iterator >::value_type initialValue, typename std::iterator_traits< Iterator >::value_type step)
- setDiagonal
 
 Sets diagonal entries in matrix to the values read from vector.
 Parameters
 (PiiRandomAccessMatrix & matrix, Iterator vector)
- setIdentity
 
 Sets diagonal entries in matrix to ones and other entries to zero.
 Parameters
 (PiiRandomAccessMatrix & matrix)
- setProperties
 Sets many properties in a bunch.
 Parameters
 (QObject & obj, const QVariantMap & lstProperties)
 Overloads
 - (QObject & obj, const QStringList & properties, const Map & valueMap, Qt::CaseSensitivity sensitivity, const QString & commentMark)
- setPropertyList
 
 Parameters
 (QObject & obj, const QList< QPair< QString, QVariant > > & lstProperties)
- setValueAt
 
 Parameters
 (T value, PiiMatrix< T > & img, double dr, double dc)
- shuffle
 Randomize the order of elements in a collection.
 Parameters
 (Collection & lst)
 Overloads
 - (Iterator begin, Iterator end)
- shuffleN
 
 Randomize the order of elements in a sequence.
 Parameters
 (Iterator begin, PII_DIFF_TYPE n)
- sign
 
 Returns the sign of value.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
- signBit
 Returns the sign bit of value1 - value2.
 Parameters
 (T value1, T value2)
 Overloads
 - (float value1, float value2)
 - (double value1, double value2)
- signMask
 Get a binary mask for the sign bit of any integer type.
 Overloads
 - ()
- sin
 Parameters
 (float value)
 Overloads
 - (T value, typename OnlyNumeric< T >::Type )
- sortedRows
 Sort matrix rows.
 Parameters
 (const PiiMatrix< T > & matrix, int column)
 Overloads
 - (const PiiMatrix< T > & matrix, LessThan lessThan, int column)
- sortRows
 
 Sort matrix rows into ascending order based on the value on the specified column.
 Parameters
 (PiiMatrix< T > & matrix, LessThan lessThan, int column)
- splitQuoted
 
 Splits a string in which each part may be quoted.
 Parameters
 (const QString & str, QChar separator, QChar quote, QString::SplitBehavior behavior)
- sqrt
 Returns the square root of value.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- square
 
 Returns the value * value.
 Parameters
 (T value, typename OnlyNumericOrComplex< T >::Type )
- stdAll
 
 Calculates the standard deviation over all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, U * mean)
- stringTo
 
 Convert a string to any type.
 Parameters
 (const QString & number, bool * ok)
- stringTo< double >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< float >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< int >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< long long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< short >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned int >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned long long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned short >
 
 Parameters
 (const QString & number, bool * ok)
- subtract
 
 Create a list that consists of the elements of list1 that are not present in list2.
 Parameters
 (const Collection & list1, const Collection & list2)
- subtractMean
 
 Subtracts sample mean from a data set.
 Parameters
 (PiiRandomAccessMatrix & matrix, Pii::MatrixDirection direction)
- sum
 
 Calculates the sum of matrix elements in the specified direction.
 Parameters
 (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- sumAll
 
 Calculates the sum of all entries in a matrix.
 Parameters
 (const PiiConceptualMatrix< Matrix > & mat)
- swap
 
 Parameters
 (Iterator1 begin1, Iterator1 end1, Iterator2 begin2)
- swapN
 
 Parameters
 (Iterator1 begin1, int n, Iterator2 begin2)
- tan
 Returns tan(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- toDouble
 
 Converts a string into a number.
 Parameters
 (const QString & number, bool * ok)
- transform
 Applies a binary function func to all elements in the range [begin1, end1), using the corresponding element in the range starting at begin2 as the second argument to the function.
 Parameters
 (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, OutputIterator output, BinaryFunction func)
 Overloads
 - (InputIterator begin, InputIterator end, OutputIterator output, UnaryFunction func)
- transformColumns
 
 Performs func on each column of the given matrix.
 Parameters
 (PiiConceptualMatrix< Matrix, RandomAccessMatrix > & matrix, InputIterator input, BinaryFunction func)
- transformedColumns
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Returns a new matrix.
 Parameters
 (const PiiRandomAccessMatrix & matrix, InputIterator input, BinaryFunction func)
- transformedRows
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Returns a new matrix.
 Parameters
 (const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & matrix, InputIterator input, BinaryFunction func)
- transformN
 Applies a unary function func to all elements in the range [begin, begin + n), and stores the returned value to output.
 Parameters
 (InputIterator begin, int n, OutputIterator output, UnaryFunction func)
 Overloads
 - (InputIterator1 begin1, int n, InputIterator2 begin2, OutputIterator output, BinaryFunction func)
- transformRows
 
 Performs func on each row of the given matrix.
 Parameters
 (PiiConceptualMatrix< Matrix, RandomAccessMatrix > & matrix, InputIterator input, BinaryFunction func)
- uniformRandom
 Returns a uniformly distributed random number in [0,1].
 Overloads
 - (double min, double max)
- uniformRandomMatrix
 Returns a rows x columns matrix filled with uniformly distributed random numbers in [0,1].
 Parameters
 (int rows, int columns)
 Overloads
 - (int rows, int columns, double min, double max)
- unpackReflectors
 
 Unpacks a matrix in which a series of elementary reflections are represented as row or column vectors.
 Parameters
 (MatrixDirection direction, const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & V, const typename Matrix::value_type * tau, PiiMatrix< typename Matrix::value_type > & T, PiiMatrix< typename Matrix::value_type > & gram, int diagonal)
- valueAt
 Sample a matrix (typically an image) at continuous positions.
 Parameters
 (const PiiMatrix< T > & img, double dr, double dc)
 Overloads
 - (const PiiMatrix< T > & img, int r, int c)
- var
 
 Calculates the variance of matrix elements in the specified direction.
 Parameters
 (const PiiMatrix< T > & mat, MatrixDirection direction)
- varAll
 
 Calculates the variance over all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, U * mean)
- variantsToList
 
 Converts a list of QVariant objects into a QList of type T.
 Parameters
 (const QVariantList & variants)
- variantsToVector
 
 Convert a list of QVariant objects into a QVector of type T.
 Parameters
 (const QVariantList & variants)
- vectorToVariants
 
 Convert a QVector to a QVariantList that contains the same values as QVariant objects.
 Parameters
 (const QVector< T > & lst)
- windowSum
 
 Calculates the sum of neighbors in a sequence bounded by begin and end.
 Parameters
 (Iterator begin, Iterator end, int width, UnaryFunction function)
▶
Other classes
- PiiArithmeticBase
  A template that adds support for arithmetic operators for any data structure that can be iterated over.
- PiiAsyncCall
  A utility class for calling functions asynchronously.
- PiiBinaryFunctionIterator
  An iterator that uses two iterators in parallel and transforms their values using a binary function.
- PiiCircle
  Stores the center and radius of a circle.
- PiiColor
  A three-channel color.
- PiiColor4
  A four-channel color.
- PiiColor4Traits
  Type information structure for PiiColor4.
- PiiColorBase
  A structure that represents a three-channel color.
- PiiColorBaseTraits
  Type information structure for PiiColorBase.
- PiiColorTraits
  Type information structure for PiiColor.
- PiiConfigurable
  This is an interface class, which can be used for setting and getting the configuration values for the class inherited from this interface.
- PiiConstCharWrapper
  A wrapper structure for const char pointers that can be used with QHash and QMap as a light-weight replacement for QString.
- PiiDefaultConfigurable
  This class adds to the base class PiiConfigurable some functionality related to handling the meta configuration information.
- PiiDelay
  A utility class that reveals the protected msleep() member of QThread so that program flow can be delayed anywhere.
- PiiEventProcessor
  A home-made event loop.
- PiiEventProcessorRunner
  A utility class that automatically starts the event processing thread upon construction and stops it when destructed.
- PiiException
  PiiException is the base class of all exceptions.
- PiiFifoBuffer
  A first in first out I/O device.
- PiiFilteredIterator
  An iterator that picks selected elements out of another iterator.
- PiiFixedPoint
  A replacement for float/double numbers.
- PiiFraction
  A template class that represents fractions.
- PiiInvalidArgumentException
  An exception for situations in which invalid arguments were used in a function or constructor call.
- PiiIOException
  An exception for input/output errors.
- PiiMathException
  PiiMathException is thrown when errors occur in calculations.
- PiiMetaConfigurationValue
  This class provides meta information about a configuration value in the class derived from the interface class PiiConfigurable.
- PiiPoint
  A two-dimensional point.
- PiiProgressController
  An interface for objects that control the functioning of operations that take a long time.
- PiiQImage
  A matrix that shares data with a QImage, and an image that shares data with a PiiMatrix.
- PiiReadWriteLock
  A read-write lock.
- PiiRectangle
  Stores the upper left corner and the size of a rectangle.
- PiiResourceDatabase
  A database that stores statements about resources.
- PiiResourceStatement
  A class used by PiiResourceDatabase to store statements about resources.
- PiiSharedObject
  A shared object.
- PiiSharedPtr
  An implicitly shared pointer.
- PiiSimpleMemoryManager
  A simple segregated storage.
- PiiSize
  Stores the width and height of an area.
- PiiSmartPtr
  A utility class that works as a simple alternative to std::auto_ptr.
- PiiTimer
  PiiTimer uses QTime to achieve microsecond-resolution timing of intervals.
- PiiUnaryFunctionIterator
  An iterator that transforms another iterator using a unary function.
- PiiUndoCommandProducer
  An interface for UI components that support undo/redo functionality.
- PiiUniversalSlot
  An object that can be used as a slot for any signal.
- PiiVariant
  An extensible variant class that can store any data type.
- PiiVector
  A D -dimensional vector.
- PiiVectorTraits
  Type information structure for PiiVector.
- PiiVersionNumber
  A class that can be used to compare version numbers composed of multiple dot-separated parts.
▶
Macros

▶

User interface classes

▶

Matrices and linear algebra

▶
Pii namespace
- Abs
 An adaptable unary function for taking the absolute value.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- Abs2
 An adaptable unary function for taking the absolute value of the square of a real number.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- AbsDiff
 
 An adaptable binary function that calculates the absolute difference of its arguments, .
 Template parameters
 <class T>
- AbsPow
 
 An adaptable binary function that raises the absolute value of its first argument to the power of the second argument.
 Template parameters
 <class T, class U, class R>
- AbsSum
 
 An adaptable binary function that calculates the sum of absolute values, .
 Template parameters
 <class T>
- Acos
 A unary function that returns acos(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- And
 A template that performs a logical AND operation on its boolean template parameters.
 Template parameters
 <bool, bool, bool, bool, bool, bool, bool>
 Specializations
 - < true, true, true, true, true, true, true >
- Asin
 A unary function that returns asin(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- Atan
 A unary function that returns tan(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- Atan2
 An adaptable binary function that calculates the arc tangent of two variables.
 Template parameters
 <class T>
 Specializations
 - < float >
- BinaryAnd
 
 An adaptable binary functor that performs the binary AND operation.
 Template parameters
 <class T>
- BinaryCompose
 
 A unary/binary function adaptor that makes the results of two unary functions the arguments of a binary function.
 Template parameters
 <class AdaptableBinaryFunction, class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
- BinaryFunction
 
 An stl-compatible model for an adaptable binary function.
 Template parameters
 <class, class, class>
- BinaryNot
 
 An adaptable binary unary functor that performs the binary NOT operation.
 Template parameters
 <class T>
- BinaryOr
 
 An adaptable binary functor that performs the binary OR operation.
 Template parameters
 <class T>
- BinaryShiftLeft
 
 An adaptable binary binary functor that shifts the left operand left as many times as indicated by the right operand.
 Template parameters
 <class T>
- BinaryShiftRight
 
 An adaptable binary binary functor that shifts the left operand right as many times as indicated by the right operand.
 Template parameters
 <class T>
- BinaryXor
 
 An adaptable binary functor that performs the binary XOR operation.
 Template parameters
 <class T>
- Bound
 
 A unary function that bounds its argument to a predefined range.
 Template parameters
 <class T>
- Cast
 
 An adaptable unary function that casts its argument from type From to type To.
 Template parameters
 <class From, class To>
- Ceil
 
 A unary function that returns ceil(x).
 Template parameters
 <class T>
- Conj
 
 An adaptable unary function that returns the complex conjugate of a real number (which is the argument itself) or a complex number.
 Template parameters
 <class T>
- Cos
 A unary function that returns cos(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- CountFunction
 
 A unary function that increments/decrements its internal counter by a predefined value each time the function is called.
 Template parameters
 <class T>
- EigenSystem
 
 Implements eigenvalue calculations and stores the results of the calculations (eigenvalues and eigenvectors).
 Template parameters
 <class tT, class tReal>
- Empty
 
 An empty structure.
- Exp
 
 An adaptable unary function for calculating the base-e exponential.
 Template parameters
 <class T>
- False
 
 A structure whose constant boolValue member evaluates to false.
- FastAtan2
 
 An adaptable binary function that uses a fast approximation (0.01 rad accuracy) to calculate the arc tangent of two variables.
 Template parameters
 <class T>
- FastestAtan2
 
 An adaptable binar function that uses a very fast but crude approximation (0.07 rad accuracy) to calculate the arc tangent of two variables.
 Template parameters
 <class T>
- Floor
 
 A unary function that returns floor(x).
 Template parameters
 <class T>
- ForEachFunction
 
 Helper function for algorithms that involve scrolling elements.
 Template parameters
 <class FuItem, class FuMemory>
- Generator
 
 An stl-compatible model for a generator function that takes no arguments.
 Template parameters
 <class>
- Hypotenuse
 An adaptable binary function that calculates the hypotenuse given two orthogonal sides of a triangle, .
 Template parameters
 <class T>
 Specializations
 - < int >
- Id
 
 A structure whose nested type, Type, is T.
 Template parameters
 <class T>
- Identity
 
 A unary function that returns its argument: f(x) = x.
 Template parameters
 <class T>
- IeeeFloat
 
 A class that wraps a floating-point number and allows one to twiddle its bits.
 Template parameters
 <class >
- IeeeFloatTraits< double >
 A traits structure that specifies the bit counts and corresponding integer types for the double type.
 Specializations
 - < double >
 - < float >
- If
 A conditional template.
 Template parameters
 <bool, class, class>
 Specializations
 - < false, Then, Else >
- IfClass
 
 A conditional template that accepts a type name as the condition parameter.
 Template parameters
 <class Condition, class Then, class Else>
- Imag
 A unary function that returns the imaginary part of its argument.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- IntIdentity
 
 Template parameters
 <int>
- Invert
 
 An adaptable unary function that returns the inverse of its argument (1/x).
 Template parameters
 <class T>
- IsArray
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is an array.
 Template parameters
 <class T>
 Specializations
 - < T[]>
- IsBaseOf
 
 A structure whose boolValue member evaluates statically to true if (and only if) Base is a base class of Derived.
 Template parameters
 <class Base, class Derived>
- IsColor
 A type trait for checking the colorness of a type.
 Template parameters
 <class T>
 Specializations
 - < PiiColor4< T > >
 - < PiiColor< T > >
- IsColor3
 Template parameters
 <class T>
 Specializations
 - < PiiColor< T > >
- IsColor4
 Template parameters
 <class T>
 Specializations
 - < PiiColor4< T > >
- IsComplex
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a complex number (std::complex).
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- IsConst
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a const type.
 Template parameters
 <class T>
 Specializations
 - < const T >
- IsFloatingPoint
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a floating point number type.
 Template parameters
 <class T>
 Specializations
- IsInteger
 
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is an integer type (either signed or unsigned).
 Template parameters
 <class T>
- IsNumeric
 
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a numeric primitive (non-bool) type.
 Template parameters
 <class T>
- IsNumericOrComplex
 
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a numeric primitive (non-bool) type or a complex number (std::complex).
 Template parameters
 <class T>
- IsPointer
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a pointer.
 Template parameters
 <class T>
 Specializations
 - < T * >
- IsPrimitive
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a primitive type.
 Template parameters
 <class T>
 Specializations
 - < bool >
- IsReference
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a reference.
 Template parameters
 <class T>
 Specializations
 - < T & >
- IsSame
 A tester struct whose boolValue member evaluates statically to true if the template parameters T and U are the same type.
 Template parameters
 <class T, class U>
 Specializations
 - < T, T >
- IsSigned
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is a signed integer type.
 Template parameters
 <class T>
 Specializations
- IsUnsigned
 A tester struct whose boolValue member evaluates statically to true if the template parameter T is an unsigned integer type.
 Template parameters
 <class T>
 Specializations
- Log
 
 An adaptable unary function for calculating the natural logarithm.
 Template parameters
 <class T>
- MatrixRowAdder
 
 A unary function that adds rows to a matrix.
 Template parameters
 <class T>
- Max
 
 An adaptable binary function that returns the maximum of its two arguments.
 Template parameters
 <class T>
- MaxInt
 
 Template parameters
 <int, int>
- Mean
 
 An adaptable unary function that calculates the sum of its arguments in successive calls and records the number of times the function has been called.
 Template parameters
 <class, class>
- Min
 
 An adaptable binary function that returns the minimum of its two arguments.
 Template parameters
 <class T>
- MinInt
 
 Template parameters
 <int, int>
- NoFunction
 
 A unary function (predicate) that always returns false.
 Template parameters
 <class T>
- Not
 
 Logical not operation.
 Template parameters
 <bool>
- NotClass
 
 Logical not operation.
 Template parameters
 <class T>
- Numeric
 
 Utility for miscellaneous numerical property definitions.
 Template parameters
 <class T>
- OnlyComplex
 
 A structure that has a nested type Type if and only if T is a numeric primitive type.
 Template parameters
 <class T>
- OnlyFloatingPoint
 
 A structure that has a nested type Type if and only if T is a floating-point type.
 Template parameters
 <class T>
- OnlyNumeric
 
 A structure that has a nested type Type if and only if T is a numeric primitive type.
 Template parameters
 <class T>
- OnlyNumericOrComplex
 
 A structure that has a nested type Type if and only if T is a numeric primitive type or a complex number.
 Template parameters
 <class T>
- OnlyPrimitive
 
 A structure that has a nested type Type if and only if T is a primitive type.
 Template parameters
 <class T>
- Or
 A template that performs a logical OR operation on its boolean template parameters.
 Template parameters
 <bool, bool, bool, bool, bool, bool, bool>
 Specializations
 - < false, false, false, false, false, false, false >
- Pow
 
 An adaptable binary function that raises its first argument to the power of the second argument.
 Template parameters
 <class T, class U>
- PtrToValue
 A static functor that converts pointers to values and keeps other types as such.
 Template parameters
 <class T>
 Specializations
 - < T * >
- Real
 A unary function that returns the real part of its argument.
 Template parameters
 <class T>
 Specializations
 - < std::complex< T > >
- RealReturnValue
 A trait structure that converts any input type to a real output type.
 Template parameters
 <class T>
 Specializations
 - < float >
- RefToValue
 A static functor that converts references to values and keeps other types as such.
 Template parameters
 <class T>
 Specializations
 - < T & >
- Round
 
 An adaptable unary function that rounds its argument to the closest integer.
 Template parameters
 <class From, class To>
- SelectFirst
 
 A binary function that returns its first argument: f(x,y) = x.
 Template parameters
 <class T, class U>
- SelectSecond
 
 A binary function that returns its second argument: f(x,y) = y.
 Template parameters
 <class T, class U>
- Sign
 
 A unary function that returns the sign (1, 0, or -1) of its argument.
 Template parameters
 <class T>
- Sin
 A unary function that returns sin(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- Sqrt
 A unary function that returns the square root of its argument.
 Template parameters
 <class T>
 Specializations
 - < float >
- Square
 
 An adaptable unary function that returns the square of its argument.
 Template parameters
 <class T>
- SquaredDiff
 
 An adaptable binary function that calculates the squared difference of its arguments, .
 Template parameters
 <class T>
- Tan
 A unary function that returns tan(x).
 Template parameters
 <class T>
 Specializations
 - < float >
- TernaryFunction
 
 A model for an adaptable ternary function.
 Template parameters
 <class, class, class, class>
- ToFloatingPoint
 Converts a type to a corresponding floating-point type.
 Template parameters
 <class T>
 Specializations
- ToNonConst
 A structure whose member type Type is a non-const version of the template parameter T.
 Template parameters
 <class>
 Specializations
 - < const T >
- ToPointer
 A static functor that converts references to pointers and keeps pointers as such.
 Template parameters
 <class T>
 Specializations
 - < T * >
- ToReference
 A static functor that converts pointers to references and keeps references as such.
 Template parameters
 <class T>
 Specializations
 - < T * >
- True
 
 A structure whose constant boolValue member evaluates to true.
- UnaryCompose
 
 A unary function adaptor that makes the result of one unary function the argument of another.
 Template parameters
 <class AdaptableUnaryFunction1, class AdaptableUnaryFunction2>
- UnaryFunction
 
 An stl-compatible model for an adaptable unary function.
 Template parameters
 <class, class>
- VaArg
 Type for values passed through the va_arg mechanism ("..." in function parameters).
 Template parameters
 <class>
 Specializations
- ValueType
 The Type member typedef of this structure maps to the value_type member type of the type given as the template argument.
 Template parameters
 <class T>
 Specializations
 - < T * >
- YesFunction
 
 A unary function (predicate) that always returns true.
 Template parameters
 <class T>
- abs
 A generic template for absolute value.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
- abs2
 Returns the absolute value ov value squared.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (const std::complex< T > & value)
- accumulate
 
 Loops through all values in the range [begin, end) and applies func to each element and the current value of initialValue.
 Parameters
 (InputIterator begin, InputIterator end, BinaryFunction func, T initialValue)
- accumulateIf
 
 Loops through all values in the range [begin, end) and applies func to each element and the current value of initialValue, if predicate returns a non-zero value for the element.
 Parameters
 (InputIterator begin, InputIterator end, UnaryPredicate predicate, BinaryFunction func, T initialValue)
- accumulateN
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This fuction works in the range [begin, begin + n).
 Parameters
 (InputIterator begin, int n, BinaryFunction func, T initialValue)
- acos
 Parameters
 (T value)
 Overloads
 - (float value)
- alignAddress
 
 Align a memory address.
 Parameters
 (T address, size_t bitMask)
- almostEqual
 Compares each element in the range [begin, end) to the corresponding element in the range starting at begin2.
 Parameters
 (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, typename std::iterator_traits< InputIterator1 >::value_type tolerance)
 Overloads
 - (const PiiConceptualMatrix< Matrix1 > & mat1, const PiiConceptualMatrix< Matrix2 > & mat2, typename Matrix1::value_type tolerance)
- angleDiff
 
 Returns the difference between two angles (in radians).
 Parameters
 (T angle1, T angle2, typename Pii::OnlyFloatingPoint< T >::Type )
- argsToList
 Converts args to to a QVariantList, assuming that each argument is a valid pointer of the type specified by types.
 Parameters
 (const QList< int > & types, void ** args)
 Overloads
 - (int argc, char * argv)
- arrayCopy
 
 Performs array copy of non-overlapping arrays.
 Parameters
 (T * to, const T * from, const size_type itemCount)
- asin
 Parameters
 (float value)
 Overloads
 - (T value)
- atan
 Parameters
 (float value)
 Overloads
 - (T value)
- atan2
 
 A fast (but slower than fastAtan2()) approximation to four-quadrant arctan.
 Parameters
 (float y, float x)
- bdDecompose
 
 Reduces a rectangular matrix to a bidiagonal form.
 Parameters
 (PiiMatrix< Real > & A, PiiMatrix< Real > & tauQ, PiiMatrix< Real > & tauP)
- bdUnpackB
 
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (PiiMatrix< Real > & A)
- bdUnpackDiagonals
 
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (const PiiMatrix< Real > & A, Real * d, Real * e)
- bdUnpackP
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (PiiMatrix< Real > & V, const Real * tauP, const int diagonal, PiiMatrix< Real > & T)
 Overloads
 - (const PiiMatrix< Real > & A, const Real * tauP)
- bdUnpackQ
 Unpacks the result of bidiagonal decomposition.
 Parameters
 (PiiMatrix< Real > & V, const Real * tauQ, const int diagonal, PiiMatrix< Real > & T)
 Overloads
 - (const PiiMatrix< Real > & A, const Real * tauQ)
- calculateArea
 
 Calculates the area of a triangle, given the lenghts of its sides.
 Parameters
 (double a, double b, double c)
- calculateInterveningAngle
 
 Calculates the angle between sides a and b, given the known lengths of the sides and the angle opposite to side a.
 Parameters
 (double a, double b, double angle)
- calculateOppositeAngle
 
 Calculates the angle opposite to side a, given the known lengths of all sides of a triangle.
 Parameters
 (double a, double b, double c)
- calculateThirdSide
 
 Calculates the length of the third side of a triangle, given the lengths of two adjacent sides and the angle between them.
 Parameters
 (double a, double b, double angle)
- ceil
 Returns ceil(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- centralDiff
 
 Calculates two-point central difference.
 Parameters
 (const PiiMatrix & mat, MatrixDirection direction)
- collectionToVariants
 
 Convert any collection to a QVariantList that contains the same values as QVariant objects.
 Parameters
 (const Collection & lst)
- columnToList
 
 Get a column from a matrix as a collection (QList, QVector)
 Parameters
 (const PiiMatrix< T > & matrix, int column)
- combinations
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 Parameters
 (int n, int k, UnaryFunction func, Storage storage)
 Overloads
 - (int n, int k, UnaryFunction func)
- concatenate
 
 Concatenate two matrices.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & mat1, const PiiConceptualMatrix< Matrix2 > & mat2, Pii::MatrixDirection direction)
- conj
 Calculates the complex conjugate of a real number.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (const std::complex< T > & value)
- convertToGray
 
 Converts any color image (rgb/indexed) to gray scale.
 Parameters
 (QImage & img)
- convertToRgba
 
 Converts any image to 32-bit rgb.
 Parameters
 (QImage & img)
- copy
 
 Copies all elements in the range [begin, end) to output.
 Parameters
 (InputIterator begin, InputIterator end, OutputIterator output)
- copyMetaType
 
 Copies the object pointed to by source to the memory location at target.
 Parameters
 (QVariant::Type type, const void * source, void * target)
- copyN
 
 Copies n elements starting at begin to output.
 Parameters
 (InputIterator begin, int n, OutputIterator output)
- copySign
 
 Parameters
 (T value, T sign)
- copyVaArgs
 
 Copies a variable number of arguments to a range of elements bounded by the iterators begin and end.
 Parameters
 (Iterator begin, Iterator end, typename Pii::VaArg< typename std::iterator_traits< Iterator >::value_type >::Type first, ... )
- copyVaList
 
 Copies a variable argument list to a range of elements.
 Parameters
 (Iterator begin, Iterator end, typename Pii::VaArg< typename std::iterator_traits< Iterator >::value_type >::Type first, va_list rest)
- cos
 Returns cos(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- countOnes
 Get the number of ones in a binary number.
 Parameters
 (unsigned int c, const unsigned char bits)
 Overloads
 - (unsigned int c)
- countTransitions
 Get the number of 0-to-1 or 1-to-0 transitions in a binary number.
 Parameters
 (unsigned int c, const unsigned char bits)
 Overloads
 - (unsigned int c)
- covariance
 
 Calculates the covariance matrix for a set of measurements.
 Parameters
 (const PiiMatrix< T > & mat, PiiMatrix< double > * mean)
- createQImage
 Parameters
 (PiiMatrix< T > & matrix)
 Overloads
 - (const PiiMatrix< T > & matrix)
 - (const PiiMatrix< PiiColor< T > > & matrix)
- crossProduct
 
 Calculates the cross product of two vectors m1 and m2.
 Parameters
 (const PiiMatrix< T > & m1, const PiiMatrix< T > & m2)
- cumulativeSum
 Calculates two-dimensional cumulative sum of a matrix.
 Parameters
 (const PiiRandomAccessMatrix & matrix, UnaryFunction func, CumulativeSumMode mode)
 Overloads
 - (const PiiRandomAccessMatrix & mat, CumulativeSumMode mode)
 - (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- decodeProperties
 
 Decode string-encoded properties into a variant map.
 Parameters
 (const QString & encodedProperties, QChar propertySeparator, QChar valueSeparator, QChar escape, PropertyDecodingFlags flags)
- degToRad
 
 Convert an angle from degrees to radians.
 Parameters
 (double deg)
- deleteAll
 
 Delete all members of a collection.
 Parameters
 (Collection & c)
- determinant
 
 calculate the determinant of a matrix.
 Parameters
 (const PiiMatrix< T > & mat)
- determinant2x2
 
 Calculates determinant of 2x2 matrix with direct calculation.
 Parameters
 (const PiiMatrix< T > & m)
- determinant3x3
 
 Calculates determinant of 3x3 matrix with direct calculation.
 Parameters
 (const PiiMatrix< T > & m)
- diff
 
 Difference and approximate derivative.
 Parameters
 (const PiiMatrix< T > & mat, int step, int order, MatrixDirection direction)
- divide
 
 Divide the elements in m1 by the corresponding elements in m2.
 Parameters
 (PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
- divided
 
 Divide the elements in m1 by the corresponding elements in m2.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
- epsilon
 
 Calculates the distance from abs(value) to the next real number larger in magnitude.
 Parameters
 (Real value)
- equals
 
 Compare two matrices.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & mat1, const PiiConceptualMatrix< Matrix2 > & mat2)
- erf
 
 Returns the value of the inverse normal cumulative distribution function (a.k.a the error function, erf) at p.
 Parameters
 (double p)
- exp
 Returns exp(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- extend
 Extend a matrix by adding new rows/columns to its sides.
 Parameters
 (const PiiMatrix< T > & mat, int amount, ExtendMode mode, int sides)
 Overloads
 - (const PiiMatrix< T > & mat, int topRows, int bottomRows, int leftCols, int rightCols, ExtendMode mode)
- factorial
 
 Returns the factorial of n (n!).
 Parameters
 (T n)
- fastAtan2
 
 A very fast approximation to four-quadrant arctan.
 Parameters
 (float y, float x)
- fastMedian
 
 Returns the median of all elements in data.
 Parameters
 (Iterator data, int len)
- fastMovingAverage
 Fast 2-D moving average.
 Parameters
 (const PiiMatrix< T > & cumulativeSum, int windowRows, int windowColumns)
 Overloads
 - (InputIterator input, int n, OutputIterator output, int windowSize)
- fileList
 
 Fetch a list of files matching a wildcard.
 Parameters
 (const QString & pattern, QDir::Filters filters, QDir::SortFlags sort)
- fill
 
 Sets all values in the range [begin, end) to value.
 Parameters
 (Iterator begin, Iterator end, typename std::iterator_traits< Iterator >::value_type value)
- fillIf
 
 Sets all values in the range [begin, end) for which predicate returns a non-zero value to value.
 Parameters
 (Iterator begin, Iterator end, UnaryPredicate predicate, typename std::iterator_traits< Iterator >::value_type value)
- fillN
 
 Sets all values in the range [begin, begin + b) to value.
 Parameters
 (Iterator begin, int n, typename std::iterator_traits< Iterator >::value_type value)
- find
 Find the row and column coordinates of all elements in mat that match predicate.
 Parameters
 (const PiiMatrix< T > & mat, UnaryPredicate predicate, int cnt)
 Overloads
 - (const PiiMatrix< T > & mat, int cnt)
- findAllParents
 
 Find all parent objects of obj up to maxParents parent objects.
 Parameters
 (const QObject * obj, unsigned int maxParents)
- findCommonParent
 
 Find the object that is the closest common ancestor of obj1 and obj2 in the object hierarchy.
 Parameters
 (const QObject * obj1, const QObject * obj2, int * parentIndex)
- findFirst
 Find the first occurrence of an element that matches Rule.
 Parameters
 (const PiiMatrix< T > & matrix, T value, int & r, int & c)
 Overloads
 - (const PiiMatrix< T > & matrix, T value, int & r, int & c)
- findFirstParent
 
 Find the first parent of obj whose type matches T.
 Parameters
 (const QObject * obj)
- findLast
 Find the last occurrence (bottom to top, right to left) of value in matrix.
 Parameters
 (const PiiMatrix< T > & matrix, T value, int & r, int & c)
 Overloads
 - (const PiiMatrix< T > & matrix, T value, int & r, int & c)
- findMaxima
 
 Find cnt largest values in mat.
 Parameters
 (const PiiMatrix< T > & mat, int cnt)
- findMinima
 
 Find cnt smallest values in mat.
 Parameters
 (const PiiMatrix< T > & mat, int cnt)
- findNeighbors
 
 Recursively connects neighbors given as a list of pairs.
 Parameters
 (QLinkedList< QPair< int, int > > & pairs)
- findSeparator
 
 Returns the index of the first occurrence of separator in str, starting at startIndex.
 Parameters
 (const QString & str, QChar separator, int startIndex, QChar escape)
- findSpecialValue
 
 Find a special value such as maximum or minimum in the range specified by begin and end.
 Parameters
 (InputIterator begin, InputIterator end, BinaryPredicate op, UnaryFunction f)
- firstOneBit
 
 Find the index of the first bit set to one.
 Parameters
 (T c)
- fitPolynomial
 
 Fit a polynomial curve to data.
 Parameters
 (unsigned int order, const PiiMatrix< double > & x, const PiiMatrix< double > & y)
- flip
 
 Flip matrix in place either horizontally, vertically or both.
 Parameters
 (PiiMatrix< T > & matrix, Pii::MatrixDirections directions)
- flipped
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This function doesn't modify the source matrix, but returns a copy.
 Parameters
 (const PiiMatrix< T > & mat, Pii::MatrixDirections directions)
- floatSignBit
 Returns the sign bit of value1 - value2.
 Parameters
 (double value1, float value2)
 Overloads
 - (T value1, float value2)
- floor
 Returns floor(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- forEach
 
 Applies func to each element in the range [begin, end).
 Parameters
 (InputIterator begin, InputIterator end, UnaryFunction func)
- forEachIf
 
 Applies func to each element in the range [begin, end) for which predicate returns a non-zero value.
 Parameters
 (InputIterator begin, InputIterator end, UnaryPredicate predicate, UnaryFunction func)
- gaussian
 
 A Gaussian function.
 Parameters
 (T x, double mu, double sigma)
- gcd
 
 Find the greatest common divisor (gcd) for the given two numbers using Euclid's algorithm.
 Parameters
 (T number1, T number2)
- generate
 
 Sets all values in the range [begin, end) to the value returned by generator.
 Parameters
 (Iterator begin, Iterator end, Generator generator)
- generateN
 
 Sets all values in the range [begin, begin + n) to the value returned by generatore.
 Parameters
 (Iterator begin, int n, Generator generator)
- grayColorTable
 
 Returns a color table with shades of gray from zero to 255.
- hammingDistance
 Calculate the Hamming distance between two binary numbers.
 Parameters
 (unsigned int a, unsigned int b, const unsigned char bits)
 Overloads
 - (unsigned int a, unsigned int b)
- householderTransform
 
 Generates an elementary reflector (a.k.a the Householder transformation).
 Parameters
 (Iterator x, int n, typename std::iterator_traits< Iterator >::value_type * tau, typename std::iterator_traits< Iterator >::value_type * beta)
- hypotenuse
 
 Calculates the hypotenuse given two orthogonal sides of a triangle.
 Parameters
 (T a, T b)
- imag
 Returns the imaginary part of a real number, i.e.
 Parameters
 (T , typename OnlyNumeric< T >::Type )
 Overloads
 - (const std::complex< T > & value)
- innerProduct
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 Parameters
 (const PiiVector< T, D > & v1, const PiiVector< T, D > & v2)
 Overloads
- innerProductN
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Returns the inner product of two n-dimensional vectors.
 Parameters
 (InputIterator1 begin1, int n, InputIterator2 begin2, T initialValue)
- insertionSort
 
 Classical insertion sort.
 Parameters
 (T * data, int size)
- intersect
 
 Find the intersection of two lists.
 Parameters
 (const Collection & list1, const Collection & list2)
- inverse
 
 Invert a matrix.
 Parameters
 (const PiiMatrix< T > & mat)
- isAntiSymmetric
 
 Tests if a matrix is antisymmetric.
 Parameters
 (const PiiMatrix< T > & mat)
- isDiagonal
 
 Test if a matrix is diagonal.
 Parameters
 (const PiiMatrix< T > & mat)
- isInf
 
 Returns true if f equals Inf.
 Parameters
 (T f)
- isNan
 
 Returns true if f is NaN.
 Parameters
 (T f)
- isOrthogonalLike
 Tests whether the given real matrix is "orthogonal-like".
 Parameters
 (const PiiMatrix< T > & mat, const T & tolerance)
 Overloads
 - (const PiiMatrix< T > & mat)
- isParent
 
 Returns true if parent is a parent of child.
 Parameters
 (const QObject * parent, const QObject * child)
- isSingular
 
 Test if a matrix is singular.
 Parameters
 (const PiiMatrix< T > & mat)
- isSquare
 
 Tests whether the given matrix is square matrix.
 Parameters
 (const PiiMatrix< T > & mat)
- isSymmetric
 
 Test if a matrix is symmetric about the diagonal.
 Parameters
 (const PiiMatrix< T > & mat)
- join
 
 Find the union of two lists.
 Parameters
 (const Collection & list1, const Collection & list2)
- kthSmallest
 
 Returns the k:th smallest element from array.
 Parameters
 (T * data, int size, int k)
- lastOneBit
 
 Find the index of the last bit set to one.
 Parameters
 (T c)
- listToMatrix
 
 Converts a collection to a row matrix.
 Parameters
 (const Collection & lst, Pii::MatrixDirection direction)
- listToVariants
 
 Convert a QList to a QVariantList that contains the same values as QVariant objects.
 Parameters
 (const QList< T > & lst)
- log
 Returns log(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- map
 Applies a unary function func to all elements in the range [begin, end), and stores the result in place.
 Parameters
 (Iterator begin, Iterator end, UnaryFunction func)
 Overloads
 - (Iterator1 begin1, Iterator1 end1, Iterator2 begin2, BinaryFunction func)
- mapIf
 
 Applies a unary function func to all elements in the range [begin, end) for which predicate returns a non-zero value.
 Parameters
 (Iterator begin, Iterator end, UnaryPredicate predicate, UnaryFunction func)
- mapMatrix
 
 Applies the unary function func to all elements of matrix.
 Parameters
 (PiiConceptualMatrix< Matrix > & matrix, UnaryFunction func)
- mapMatrixIf
 
 Applies the unary function func to all elements of matrix that match the given predicate.
 Parameters
 (PiiConceptualMatrix< Matrix > & matrix, UnaryPredicate predicate, UnaryFunction func)
- mapN
 Applies a binary function func to all elements in the range [begin1, begin1 + n), and stores the result in place.
 Parameters
 (Iterator1 begin1, int n, Iterator2 begin2, BinaryFunction func)
 Overloads
 - (Iterator begin, int n, UnaryFunction func)
- mappedMatrix
 
 Applies the unary function func to all elements of matrix.
 Parameters
 (PiiConceptualMatrix< Matrix > & matrix, UnaryFunction func)
- mappedMatrixIf
 
 Applies the unary function func to all elements of matrix that match the given predicate.
 Parameters
 (const PiiConceptualMatrix< Matrix > & matrix, UnaryPredicate predicate, UnaryFunction func)
- matchCrontab
 
 Match a list of crontab-like strings against the given time stamp.
 Parameters
 (QStringList list, QDateTime timeStamp)
- matlabParse
 
 Parse a string that describes a matrix in Matlab syntax.
 Parameters
 (const QString & str)
- matlabPrint
 
 Print out a matrix in a matlab-friendly format.
 Parameters
 (Stream & out, const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & mat)
- matrix
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This specialization just returns mat.
 Parameters
 (const PiiMatrix< T > & mat)
- max
 Calculates the maximum among all elements in the specified direction.
 Parameters
 (const PiiMatrix< T > & mat, MatrixDirection direction)
 Overloads
- maxAbsAll
 
 Like maxAll(), but finds the maximum absolute value.
 Parameters
 (const PiiMatrix< T > & mat, int * r, int * c)
- maxAll
 Shorthand for maxAll(collection.begin(), collection.end()).
 Parameters
 (const Collection & collection)
 Overloads
 - (InputIterator begin, InputIterator end)
 - (const PiiMatrix< T > & mat, int * r, int * c)
- mean
 
 Calculates the mean of matrix elements in the specified direction.
 Parameters
 (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- meanAll
 
 Calculates the mean of all entries in a matrix.
 Parameters
 (const PiiConceptualMatrix< Matrix > & mat)
- median
 
 Returns the median of all elements in data.
 Parameters
 (Iterator data, int len)
- median25
 
 Median of 25 values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median3
 
 Median of three values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median5
 
 Median of five values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median7
 
 Median of seven values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- median9
 
 Median of nine values optimized to the theoretical maximum efficiency.
 Parameters
 (Iterator data)
- medianAll
 
 Returns the median of all elements in mat.
 Parameters
 (const PiiMatrix< T > & mat)
- min
 Calculates the minimum among all elements in the specified direction.
 Parameters
 (const PiiMatrix< T > & mat, MatrixDirection direction)
 Overloads
- minAll
 Calculates the minimum of all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, int * r, int * c)
 Overloads
 - (InputIterator begin, InputIterator end)
 - (const Collection & collection)
- minMax
 
 Find the maximum and maximum of all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, T * minimum, T * maximum, int * minR, int * minC, int * maxR, int * maxC)
- mod
 
 Returns the "modulus" of a floating point number.
 Parameters
 (T d1, T d2, typename OnlyFloatingPoint< T >::Type )
- movingAverage
 Calculates the moving average of a sequence bounded by begin and end.
 Parameters
 (Iterator begin, Iterator end, int width)
 Overloads
 - (const PiiMatrix & mat, int width, MatrixDirection direction, EndPointHandling endPointHandling)
- multiplied
 
 Multiplies the elements in m1 and m2.
 Parameters
 (const PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
- multiply
 Multiply the elements in m1 by the corresponding elements in m2.
 Parameters
 (PiiConceptualMatrix< Matrix1 > & m1, const PiiConceptualMatrix< Matrix2 > & m2)
 Overloads
 - (const PiiMatrix< T > & matrix, InputIterator input, OutputIterator output)
 - (InputIterator input, const PiiMatrix< T > & matrix, OutputIterator output)
- normalize
 
 Normalizes vectors in a matrix.
 Parameters
 (PiiRandomAccessMatrix & mat, MatrixDirection direction)
- normalized
 
 Normalizes vectors in a matrix.
 Parameters
 (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- normalRandom
 
 Returns a random number from a distribution that follows N(0,1) (zero mean, unit variance Gaussian distribution).
- normalRandomMatrix
 
 Returns a rows x columns matrix filled with normally distributed random numbers.
 Parameters
 (int rows, int columns)
- operator<<
 
 Write a QString to an std output stream.
 Parameters
 (std::ostream & out, const QString & str)
- parseTypes
 
 Converts comma-separated type names to a list of type IDs.
 Parameters
 (const QByteArray & types)
- partition
 
 Returns array which is arranged so that; there exist index k which value is restricted to 0 <= k < size.
 Parameters
 (T * data, int size, int pivot)
- pcaDecorrelate
 
 Decorrelates a possibly correlated set of data.
 Parameters
 (const PiiRandomAccessMatrix & X)
- permutations
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 Parameters
 (int n, UnaryFunction func, Storage storage)
 Overloads
 - (int n, UnaryFunction func)
- PII_DECLARE_EXPORTED_FUNCTION_TEMPLATE
 Parameters
 (void , setProperties< QSettings > , (QObject &obj, const QStringList &properties, const QSettings &valueMap, Qt::CaseSensitivity sensitivity, const QString &commentMark) , PII_BUILDING_CORE )
 Overloads
 - (void , setProperties< QVariantMap > , (QObject &obj, const QStringList &properties, const QVariantMap &valueMap, Qt::CaseSensitivity sensitivity, const QString &commentMark) , PII_BUILDING_CORE )
- PII_MATH_MATRIX_TRANSFORM
 Returns a matrix whose elements are absolute values of mat squared.
 Parameters
 (abs2 , Abs2 )
 Overloads
 - (abs , Abs )
- pow
 Raise value to an integer power (n).
 Parameters
 (T value, int n, typename OnlyNumeric< T >::Type )
 Overloads
 - (double value, double n)
 - (float value, float n)
- principalComponents
 
 Returns the PCA base vectors for a data set in X.
 Parameters
 (const PiiRandomAccessMatrix & X, PiiMatrix< typename Matrix::value_type > * S)
- printMatrix
 
 Print matrix in a user-defined format.
 Parameters
 (Stream & out, const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & mat, const ColSeparator & columnSeparator, const RowSeparator & rowSeparator)
- properties
 
 Fetch the properties of a QObject as a map of name-value pairs.
 Parameters
 (const QObject & obj, int propertyOffset, PropertyFlags flags)
- propertyList
 
 Returns the properties of obj as a list.
 Parameters
 (const QObject & obj, int propertyOffset, PropertyFlags flags)
- propertyName
 
 Finds the name of a property in obj that matches name in a case-insensitive manner.
 Parameters
 (const QObject & obj, const QString & name)
- pseudoInverse
 
 Returns the Moore-Penrose pseudoinverse of an m-by-n matrix.
 Parameters
 (const PiiRandomAccessMatrix & A)
- Q_DECLARE_FLAGS
 Parameters
 (MatrixDirections , MatrixDirection )
 Overloads
 - (SvdOptions , SvdOption )
 - (PropertyFlags , PropertyFlag )
- Q_FLAGS
 
 Parameters
 (MatrixDirection MatrixDirections)
- qHash
 
 Hash function for null-terminated C strings.
 Parameters
 (const char * key)
- qrDecompose
 QR decomposition.
 Parameters
 (PiiRandomAccessMatrix & A, PiiMatrix< typename Matrix::value_type > & tau)
 Overloads
 - (PiiRandomAccessMatrix & A, typename Matrix::value_type * tau, typename Matrix::value_type * bfr)
 - (const PiiRandomAccessMatrix & A, PiiMatrix< typename Matrix::value_type > * R, QrUnpackStyle style)
- qrUnpack
 Unpacks the result of QR decomposition.
 Parameters
 (PiiMatrix< Real > & A, const Real * tau, PiiMatrix< Real > & T, PiiMatrix< Real > & gram)
 Overloads
 - (PiiMatrix< Real > & A, const PiiMatrix< Real > & tau, PiiMatrix< Real > * R, QrUnpackStyle style)
- radToDeg
 
 Convert an angle from radians to degrees.
 Parameters
 (double rad)
- randomizeMatrix
 
 Set random elements from range specified by parameters lowerBound and upperBound to matrix.
 Parameters
 (PiiMatrix< T > & mat, const T & lowerBound, const T & upperBound)
- rank
 
 Estimates the number of linearly independent rows or columns of a matrix.
 Parameters
 (const PiiRandomAccessMatrix & mat, typename Matrix::value_type tolerance)
- real
 Returns the real part of a complex number.
 Parameters
 (const std::complex< T > & value)
 Overloads
 - (T value, typename OnlyNumeric< T >::Type )
- reflectColumns
 Applies a reflection transform to a rectangular matrix from the left.
 Parameters
 (PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & A, InputIterator v, typename Matrix::value_type tau, typename Matrix::value_type * bfr)
 Overloads
 - (PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & A, InputIterator v, typename Matrix::value_type tau)
- reflectRows
 
 Applies a reflection transform to a rectangular matrix from the right.
 Parameters
 (PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & A, InputIterator v, typename Matrix::value_type tau)
- replaceVariables
 
 Replaces variables in string and returns a new string.
 Parameters
 (const QString & string, const VariableMap & variables)
- replicate
 
 Replicate a matrix vertical times vertically and horizontal times horizontally.
 Parameters
 (const PiiMatrix< T > & matrix, int vertical, int horizontal)
- rol
 Parameters
 (unsigned short c, const unsigned char n)
 Overloads
- rol< INTBITS >
 
 Parameters
 (unsigned int c, const unsigned char n)
- ror
 Rotate a binary code right by n positions.
 Parameters
 (unsigned int c, const unsigned char n, const unsigned char bits)
 Overloads
- ror< INTBITS >
 
 Parameters
 (unsigned int c, const unsigned char n)
- rotateColumns
 
 Parameters
 (mat , 0 , 1 )
- rotateToMinimum
 Rotate a binary number to its minimum value.
 Parameters
 (unsigned int n, const unsigned char bits)
 Overloads
 - (unsigned int n)
- round
 Rounds a double argument to the closest integer.
 Parameters
 (double value)
 Overloads
 - (T value, typename OnlyNumeric< T >::Type )
- rowToList
 
 Get a row from a matrix as a collection (QList, QVector)
 Parameters
 (const PiiMatrix< T > & matrix, int row)
- scoreOverload
 
 Returns a numerical score for the goodness of a parameter set given a list of expected types.
 Parameters
 (const QVariantList & params, const QList< int > & types)
- seedRandom
 Seeds the random number generator with your favourite value.
 Parameters
 (long value)
 Overloads
 - ()
- selectRandomly
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Randomly selects n distinct integers in [0, max-1] and stores them to indices.
 Parameters
 (QVector< int > & indices, int n, int max)
 Overloads
 - (Collection & target, const Collection & source, int n)
 - (int n, int max)
- sequence
 Assigns sequentially increasing values to the range [begin, end).
 Parameters
 (Iterator begin, Iterator end, typename std::iterator_traits< Iterator >::value_type initialValue)
 Overloads
 - (Iterator begin, Iterator end, typename std::iterator_traits< Iterator >::value_type initialValue, typename std::iterator_traits< Iterator >::value_type step)
- sequenceN
 Assigns sequentially increasing values to the range [begin, end + n).
 Parameters
 (Iterator begin, int n, typename std::iterator_traits< Iterator >::value_type initialValue)
 Overloads
 - (Iterator begin, int n, typename std::iterator_traits< Iterator >::value_type initialValue, typename std::iterator_traits< Iterator >::value_type step)
- setDiagonal
 
 Sets diagonal entries in matrix to the values read from vector.
 Parameters
 (PiiRandomAccessMatrix & matrix, Iterator vector)
- setIdentity
 
 Sets diagonal entries in matrix to ones and other entries to zero.
 Parameters
 (PiiRandomAccessMatrix & matrix)
- setProperties
 Sets many properties in a bunch.
 Parameters
 (QObject & obj, const QVariantMap & lstProperties)
 Overloads
 - (QObject & obj, const QStringList & properties, const Map & valueMap, Qt::CaseSensitivity sensitivity, const QString & commentMark)
- setPropertyList
 
 Parameters
 (QObject & obj, const QList< QPair< QString, QVariant > > & lstProperties)
- setValueAt
 
 Parameters
 (T value, PiiMatrix< T > & img, double dr, double dc)
- shuffle
 Randomize the order of elements in a collection.
 Parameters
 (Collection & lst)
 Overloads
 - (Iterator begin, Iterator end)
- shuffleN
 
 Randomize the order of elements in a sequence.
 Parameters
 (Iterator begin, PII_DIFF_TYPE n)
- sign
 
 Returns the sign of value.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
- signBit
 Returns the sign bit of value1 - value2.
 Parameters
 (T value1, T value2)
 Overloads
 - (float value1, float value2)
 - (double value1, double value2)
- signMask
 Get a binary mask for the sign bit of any integer type.
 Overloads
 - ()
- sin
 Parameters
 (float value)
 Overloads
 - (T value, typename OnlyNumeric< T >::Type )
- sortedRows
 Sort matrix rows.
 Parameters
 (const PiiMatrix< T > & matrix, int column)
 Overloads
 - (const PiiMatrix< T > & matrix, LessThan lessThan, int column)
- sortRows
 
 Sort matrix rows into ascending order based on the value on the specified column.
 Parameters
 (PiiMatrix< T > & matrix, LessThan lessThan, int column)
- splitQuoted
 
 Splits a string in which each part may be quoted.
 Parameters
 (const QString & str, QChar separator, QChar quote, QString::SplitBehavior behavior)
- sqrt
 Returns the square root of value.
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- square
 
 Returns the value * value.
 Parameters
 (T value, typename OnlyNumericOrComplex< T >::Type )
- stdAll
 
 Calculates the standard deviation over all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, U * mean)
- stringTo
 
 Convert a string to any type.
 Parameters
 (const QString & number, bool * ok)
- stringTo< double >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< float >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< int >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< long long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< short >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned int >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned long long >
 
 Parameters
 (const QString & number, bool * ok)
- stringTo< unsigned short >
 
 Parameters
 (const QString & number, bool * ok)
- subtract
 
 Create a list that consists of the elements of list1 that are not present in list2.
 Parameters
 (const Collection & list1, const Collection & list2)
- subtractMean
 
 Subtracts sample mean from a data set.
 Parameters
 (PiiRandomAccessMatrix & matrix, Pii::MatrixDirection direction)
- sum
 
 Calculates the sum of matrix elements in the specified direction.
 Parameters
 (const PiiRandomAccessMatrix & mat, MatrixDirection direction)
- sumAll
 
 Calculates the sum of all entries in a matrix.
 Parameters
 (const PiiConceptualMatrix< Matrix > & mat)
- swap
 
 Parameters
 (Iterator1 begin1, Iterator1 end1, Iterator2 begin2)
- swapN
 
 Parameters
 (Iterator1 begin1, int n, Iterator2 begin2)
- tan
 Returns tan(value).
 Parameters
 (T value, typename OnlyNumeric< T >::Type )
 Overloads
 - (float value)
- toDouble
 
 Converts a string into a number.
 Parameters
 (const QString & number, bool * ok)
- transform
 Applies a binary function func to all elements in the range [begin1, end1), using the corresponding element in the range starting at begin2 as the second argument to the function.
 Parameters
 (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, OutputIterator output, BinaryFunction func)
 Overloads
 - (InputIterator begin, InputIterator end, OutputIterator output, UnaryFunction func)
- transformColumns
 
 Performs func on each column of the given matrix.
 Parameters
 (PiiConceptualMatrix< Matrix, RandomAccessMatrix > & matrix, InputIterator input, BinaryFunction func)
- transformedColumns
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Returns a new matrix.
 Parameters
 (const PiiRandomAccessMatrix & matrix, InputIterator input, BinaryFunction func)
- transformedRows
 
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Returns a new matrix.
 Parameters
 (const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & matrix, InputIterator input, BinaryFunction func)
- transformN
 Applies a unary function func to all elements in the range [begin, begin + n), and stores the returned value to output.
 Parameters
 (InputIterator begin, int n, OutputIterator output, UnaryFunction func)
 Overloads
 - (InputIterator1 begin1, int n, InputIterator2 begin2, OutputIterator output, BinaryFunction func)
- transformRows
 
 Performs func on each row of the given matrix.
 Parameters
 (PiiConceptualMatrix< Matrix, RandomAccessMatrix > & matrix, InputIterator input, BinaryFunction func)
- uniformRandom
 Returns a uniformly distributed random number in [0,1].
 Overloads
 - (double min, double max)
- uniformRandomMatrix
 Returns a rows x columns matrix filled with uniformly distributed random numbers in [0,1].
 Parameters
 (int rows, int columns)
 Overloads
 - (int rows, int columns, double min, double max)
- unpackReflectors
 
 Unpacks a matrix in which a series of elementary reflections are represented as row or column vectors.
 Parameters
 (MatrixDirection direction, const PiiConceptualMatrix< Matrix, RandomAccessMatrix > & V, const typename Matrix::value_type * tau, PiiMatrix< typename Matrix::value_type > & T, PiiMatrix< typename Matrix::value_type > & gram, int diagonal)
- valueAt
 Sample a matrix (typically an image) at continuous positions.
 Parameters
 (const PiiMatrix< T > & img, double dr, double dc)
 Overloads
 - (const PiiMatrix< T > & img, int r, int c)
- var
 
 Calculates the variance of matrix elements in the specified direction.
 Parameters
 (const PiiMatrix< T > & mat, MatrixDirection direction)
- varAll
 
 Calculates the variance over all elements in a matrix.
 Parameters
 (const PiiMatrix< T > & mat, U * mean)
- variantsToList
 
 Converts a list of QVariant objects into a QList of type T.
 Parameters
 (const QVariantList & variants)
- variantsToVector
 
 Convert a list of QVariant objects into a QVector of type T.
 Parameters
 (const QVariantList & variants)
- vectorToVariants
 
 Convert a QVector to a QVariantList that contains the same values as QVariant objects.
 Parameters
 (const QVector< T > & lst)
- windowSum
 
 Calculates the sum of neighbors in a sequence bounded by begin and end.
 Parameters
 (Iterator begin, Iterator end, int width, UnaryFunction function)
▶
Other classes
- PiiBinaryMatrixTransform
 A matrix that models the matrix concept by using a binary function that operates on two other matrices.
- PiiConceptualMatrix
 A superclass for classes that implement the matrix concept.
- PiiFilteredMatrix
 A model of the matrix concept that accesses selected elements of another matrix.
- PiiMatrix< T,-1,-1 >
 A two-dimensional array that models the matrix concept.
- PiiMatrixValue
 A structure that stores a value and its location in a matrix.
- PiiPlaneRotation
 Represents a rotation parallel to a plane spanned by two coordinates axes.
- PiiSubmatrix
 A matrix that provides a mutable reference to a PiiMatrix.
- PiiTransposedMatrix
 Transposed matrix.
- PiiTypelessMatrix
 A two-dimensional dynamic array of non-typed data.
- PiiUnaryMatrixTransform
 A matrix that models the matrix concept by applying a unary function to another matrix.

▶

Networking

▶

Base plug-in

▶
Operations
- PiiAbsoluteOperation
  An operation that calculates the absolute value of any numeric or complex type or a matrix containing such types.
- PiiArithmeticOperation
  An operation that performs simple arithmetic like adding and subtracting values.
- PiiAverageOperation
  Calculate the average of all values in a matrix.
- PiiClock
  An operation that emits current time whenever a trigger is received or whenever a timer times out.
- PiiComparisonOperation
  Compare two values and output a binary outcome.
- PiiDebugOperation
  An operation that prints all objects passing through it to the debug console.
- PiiDiffOperation
  Calculates the difference between two successive input objects.
- PiiFileSystemScanner
  Scans directory hierarchies finding files that match filters.
- PiiFileSystemWatcher
  An operation for monitoring directories for new files.
- PiiIdGenerator
  On operation for generating running IDs.
- PiiLogOperation
  An operation that calculates the logarithm of its input.
- PiiLookupTable
  An operation that maps integers into arbitrary data.
- PiiMathematicalFunction
  An operation that applies a mathematical function to its input.
- PiiMatrixCombiner
  An operation that puts multiple matrices into a grid that produces a larger matrix.
- PiiMatrixComposer
  Composes an output matrix from N inputs of primitive data types.
- PiiMatrixDecomposer
  Decomposes input matrix so that each row element corresponds one output.
- PiiMatrixFlipper
  Flip a matrix vertically or horizontally.
- PiiMatrixNormalizer
  Scale the values in a matrix so that its values are limited to a predefined range.
- PiiMinMaxOperation
  Calculates the minimum/maximum of two arguments, or the minimum/maximum value in a matrix.
- PiiMovingAverageOperation
  Calculate the moving average over a window of a predefined size.
- PiiObjectCapturer
  Emits a received objects as a Qt signal.
- PiiObjectCounter
  Counts received objects.
- PiiRegExpMatcher
  An operation that splits strings into pieces based on a regular expression.
- PiiSequenceGenerator
  An operation that generates sequences of numbers.
- PiiStringConverter
  Converts strings to numbers.
- PiiStringFormatter
  An operation that composes formatted strings out of data read from a configurable number of inputs.
- PiiStringizer
  Convert (almost) any type to a string.
- PiiTriggerSource
  A source operation that can be triggered with Qt's signals.
- PiiTypeCastingOperation
  An operation that converts the data type of a matrix.

▶

Calibration plug-in

▶
PiiCalibration namespace
- CameraParameters
 
 A structure that stores all intrinsic camera parameters estimated by the calibration functions.
- RelativePosition
 
 A structure that stores the extrinsic parameters related to a scene viewed.
- calculateCameraPosition
 
 Calculate the position of the camera reference frame with respect to the world coordinate system.
 Parameters
 (const PiiMatrix< double > & worldPoints, const PiiMatrix< double > & imagePoints, const CameraParameters & intrinsic)
- calculateRelativePosition
 
 Calculate the relative position of camera2 with respect to camera1.
 Parameters
 (const RelativePosition & camera1, const RelativePosition & camera2)
- calibrateCamera
 
 Calibrate a camera.
 Parameters
 (const QList< PiiMatrix< double > > & worldPoints, const QList< PiiMatrix< double > > & imagePoints, CameraParameters & intrinsic, QList< RelativePosition > * extrinsic, CalibrationOptions options)
- cameraToPixelCoordinates
 
 Transforms points from camera reference frame to pixel coordinates.
 Parameters
 (const PiiMatrix< double > & points, const CameraParameters & intrinsic)
- cameraToWorldCoordinates
 
 Transform points from camera reference frame to world coordinates.
 Parameters
 (const PiiMatrix< double > & points, const RelativePosition & extrinsic)
- normalizedToPixelCoordinates
 Transforms a point from normalized image coordinates to pixel coordinates.
 Parameters
 (const CameraParameters & intrinsic, double x, double y, double * newX, double * newY)
 Overloads
 - (const PiiMatrix< double > & points, const CameraParameters & intrinsic)
- perspectiveProjection
 
 Perform perspective projection on points.
 Parameters
 (const PiiMatrix< double > & points, double zValue)
- Q_DECLARE_FLAGS
 
 Parameters
 (CalibrationOptions , CalibrationOption )
- rotationMatrixToVector
 
 Convert a rotation matrix to a rotation vector.
 Parameters
 (const PiiMatrix< double > & matrix)
- rotationVectorToMatrix
 
 Convert a rotation vector rotation to a rotation matrix.
 Parameters
 (const PiiVector< double, 3 > & rotation)
- undistort
 Converts pixel coordinates to normalized image coordinates.
 Parameters
 (const CameraParameters & intrinsic, double x, double y, double * newX, double * newY)
 Overloads
 - (const PiiMatrix< double > & distorted, const CameraParameters & intrinsic, double zValue)
- undistortImage
 
 Removes lens distortions from sourceImage.
 Parameters
 (const PiiMatrix< T > & sourceImage, const CameraParameters & intrinsic)
- undistortMap
 
 Creates a coordinate map that converts distorted pixel coordinates to undistorted ones.
 Parameters
 (int rows, int columns, const CameraParameters & intrinsic)
- undistortMapInt
 
 Creates a coordinate map that converts distorted pixel coordinates to undistorted ones.
 Parameters
 (int rows, int columns, const CameraParameters & intrinsic)
- worldToCameraCoordinates
 
 Transform points from world coordinate system to the camera reference frame.
 Parameters
 (const PiiMatrix< double > & points, const RelativePosition & extrinsic)
- worldToPixelCoordinates
 
 Transform points from world coordinates to pixel coordinates.
 Parameters
 (const PiiMatrix< double > & points, const RelativePosition & extrinsic, const CameraParameters & intrinsic)
▶
Operations
- PiiUndistortOperation
  Corrects lens distortion.
▶
Other classes
- PiiCalibrationPointFinder
  A class that can be used to find calibration points in a set of unreliable detections.
- PiiStereoTriangulator
  A class that calculates 3D world coordinates for objects seen from 2 to N viewpoints.

▶

Camera plug-in

▶
PiiCamera namespace
- BayerDecoder
 
 A structure used for handling different Bayer encoding schemes with bayerToRgb().
 Template parameters
 <class, class, class, class, class, class, class, class, class, class, class, class>
- BggrDecoder
 
 Bayer decoding structure for BGGR color ordering.
 Template parameters
 <class T>
- BluePixel
 
 A Bayer decoding functor that extracts the blue channel only.
 Template parameters
 <class T>
- CenterInterpolator
 
 An interpolation functor that always returns the value of the center of a neighborhood without interpolation.
 Template parameters
 <class T>
- DiagonalInterpolator
 
 An interpolation functor that calculates the value of a color channel by averaging the four diagonal neighbors of a pixel.
 Template parameters
 <class T>
- GrayPixel
 
 A Bayer decoding functor that directly converts the image to gray levels by averaging RGB channels.
 Template parameters
 <class T>
- GrbgDecoder
 
 Bayer decoding structure for GRBG color ordering.
 Template parameters
 <class T>
- GreenPixel
 
 A Bayer decoding functor that extracts the green channel only.
 Template parameters
 <class T>
- HorizontalInterpolator
 
 An interpolation functor that calculates the value of a color channel by averaging the two horizontal neighbors of a pixel.
 Template parameters
 <class T>
- NoInterpolator
 
 An interpolation functor that does nothing.
- RedPixel
 
 A Bayer decoding functor that extracts the red channel only.
 Template parameters
 <class T>
- Rgb4Pixel
 
 Four-channel rgb color pixel type functor for Bayer decoding.
 Template parameters
 <class T>
- RgbPixel
 
 Rgb color pixel type functor for Bayer decoding.
 Template parameters
 <class T>
- RggbDecoder
 
 Bayer decoding structure for RGGB color ordering.
 Template parameters
 <class T>
- StraightInterpolator
 
 An interpolation functor that calculates the value of a color channel by averaging the four straight neighbors of a pixel.
 Template parameters
 <class T>
- VerticalInterpolator
 
 An interpolation functor that calculates the value of a color channel by averaging the two vertical neighbors of a pixel.
 Template parameters
 <class T>
- bayerToRgb
 
 Convert a Bayer-encoded color image to RGB colors.
 Parameters
 (const PiiMatrix< T > & encoded, Decoder decoder, Pixel pixel)
- grbgToRgb
 
 A convenience function that decodes a GRBG-encoded 8-bit image into a 32-bit RGB color image.
 Parameters
 (const PiiMatrix< unsigned char > & encoded)
- rggbToRgb
 
 A convenience function that decodes an RGGB-encoded 8-bit image into a 32-bit RGB color image.
 Parameters
 (const PiiMatrix< unsigned char > & encoded)
▶
Operations
- PiiCameraOperation
  PiiCameraOperation description.
- PiiFireWireOperation
  An operation for reading frames from IEEE1394 cameras.
- PiiNetworkCameraOperation
  A camera interface that reads images from a network camera.
▶
Other classes
- PiiCameraDriver
  A common interface for cameras that read images into a frame buffer.
- PiiFireWireInterface
  An interface to IEEE-1394 cameras.
- PiiMultiCamDriver
  An implementation of the PiiCameraDriver interface for EureSys grabber boards.
- PiiSequenceFile
  Stores and restores captured frames to/from a sequence file.
- PiiSequenceFileListener
  A listener for PiiCameraDriver that writes received frames into a sequence file.

▶

Classification plug-in

▶
PiiClassification namespace
- FeatureReader< PiiMatrix< T > >
 
 A function object that reads an input socket and converts the incoming object to a PiiMatrix<T>, if possible.
- adaptVector
 
 Adapt a code vector towards sample with the given strength alpha.
 Parameters
 (FeatureIterator code, ConstFeatureIterator sample, int length, double alpha)
- calculateDistanceMatrix
 
 Generate a distance matrix.
 Parameters
 (const SampleSet & samples, const DistanceMeasure & measure, bool symmetric, bool calculateDiagonal)
- calculateError
 
 Calculates classification error.
 Parameters
 (const QVector< double > & knownLabels, const QVector< double > & hypothesis, const QVector< double > & weights)
- countLabels
 
 Counts the number of distinct labels in labels.
 Parameters
 (const QVector< double > & labels)
- countLabelsInt
 
 Counts the number of distinct integer labels in labels.
 Parameters
 (const QVector< double > & labels)
- createConfusionMatrix
 
 Create a confusion matrix.
 Parameters
 (const QVector< double > & knownLabels, const QVector< double > & hypothesis)
- createDartBoard
 
 Creates a non-linearly separable binary sample set so that the samples in class one are surrounded by those in the other one.
 Parameters
 (int samples1, int samples2, PiiMatrix< double > & samples, QVector< double > & labels)
- createDoubleSpiral
 
 Creates a non-linearly separable sample set in which two classes spiral around each other on a plane.
 Parameters
 (int samplesPerSet, double rounds, PiiMatrix< double > & samples, QVector< double > & labels)
- createRandomSampleSet
 
 Create a random sample set.
 Parameters
 (int samples, int features, double minimum, double maximum)
- fillMissingLabels
 
 Go through the row matrix labels and replace each -1 with the label of the closest code vector in codeBook.
 Parameters
 (const PiiMatrix< int > & labels, const PiiMatrix< T > & codeBook, DistanceMeasure measure)
- findClosestMatch
 
 Find the closest match for sample in modelSet.
 Parameters
 (typename PiiSampleSet::Traits< SampleSet >::ConstFeatureIterator sample, const SampleSet & modelSet, const DistanceMeasure & measure, double * distance)
- findClosestMatches
 
 Find the n closest matches for sample in modelSet.
 Parameters
 (typename PiiSampleSet::Traits< SampleSet >::ConstFeatureIterator sample, const SampleSet & modelSet, const DistanceMeasure & measure, int n)
- kMeans
 
 K-means clustering algorithm.
 Parameters
 (const SampleSet & samples, unsigned int k, const DistanceMeasure & measure, unsigned int maxIterations)
- knnClassify
 
 Classify a sample using the k nearest neighbors rule.
 Parameters
 (typename PiiSampleSet::Traits< SampleSet >::ConstFeatureIterator sample, const SampleSet & modelSet, const QVector< double > & labels, const DistanceMeasure & measure, int k, double * distance, int * closestIndex)
- Q_DECLARE_FLAGS
 
 Parameters
 (LearnerCapabilities , LearnerCapability )
- Q_DECLARE_OPERATORS_FOR_FLAGS
 
 Parameters
 (LearnerCapabilities )
- somHexagonalDistance
 
 Calculate the squared distance between two nodes in a SOM with a hexagonal topology.
 Parameters
 (int bx, int by, int tx, int ty)
- somSquareDistance
 
 Calculate the squared distance between two nodes in a SOM with a square topology.
 Parameters
 (int bx, int by, int tx, int ty)
▶
PiiSampleSet namespace
- Traits< PiiMatrix< T > >
 
 Defines the traits of any PiiMatrix when used as a sample set.
- append
 
 Adds sample to the and of a sample set.
 Parameters
 (PiiMatrix< T > & samples, const T * sample)
- capacity
 
 Returns the number of samples a sample set can hold without reallocation.
 Parameters
 (const PiiMatrix< T > & samples)
- clear
 
 Clears a sample set.
 Parameters
 (PiiMatrix< T > & samples)
- create
 
 Creates a new sample set with sampleCount samples and featureCount features.
 Parameters
 (int sampleCount, int featureCount)
- equals
 
 Returns true if set1 is equal to set2, and false otherwise.
 Parameters
 (PiiMatrix< T > & set1, PiiMatrix< T > & set2)
- featureCount
 
 Returns the number of features in a sample set.
 Parameters
 (const PiiMatrix< T > & samples)
- remove
 
 Removes the sample at index.
 Parameters
 (PiiMatrix< T > & samples, int index)
- reserve
 
 Reserves space for sampleCount samples with featureCount features.
 Parameters
 (PiiMatrix< T > & samples, int sampleCount, int featureCount)
- resize
 
 Resizes a sample set to hold sampleCount samples with featureCount features.
 Parameters
 (PiiMatrix< T > & samples, int sampleCount, int featureCount)
- sampleAt
 Parameters
 (PiiMatrix< T > & samples, int index)
 Overloads
 - (const PiiMatrix< T > & samples, int index)
- sampleCount
 
 Returns the number of samples in a sample set.
 Parameters
 (const PiiMatrix< T > & samples)
- setSampleAt
 
 Replaces the feature vector at index in samples with features.
 Parameters
 (PiiMatrix< T > & samples, int index, const T * features)
▶
Operations
- PiiBoostClassifierOperation
  An operation that classifies samples using a boosted cascade of weak classifiers.
- PiiClassifierOperation
  A superclass for classifier operations.
- PiiClassIndexMapper
  An operation that maps indices into other indices.
- PiiClassInfoMapper
  An operation that maps class indices to arbitrary data.
- PiiConfusionMatrixBuilder
  An operation that builds a confusion matrix out of classification results.
- PiiDistributionNormalizer
  An operation that divides incoming feature vectors by their sum.
- PiiFeatureCombiner
  Feature combiner is an operation that combines feature vectors into a larger compound feature vector.
- PiiKnnClassifierOperation
  An operation that classifies samples according to the k nearest neighbors rule.
- PiiPerceptronOperation
  An Ydin-compatible Perceptron classifier operation.
- PiiSampleBalancer
  An operation that balances training sets by giving more weight to rare samples.
- PiiSampleRandomizer
  An operation that stores names of samples belonging to N different classes.
- PiiSomOperation
  An Ydin-compatible SOM classifier operation.
- PiiTableLabelerOperation
  PiiTableLabelerOperation can be used for classification where the classification rules are given in a table format.
- PiiVectorQuantizerOperation
  A superclass for classifier operations that use classifiers derived from PiiVectorQuantizer.
▶
Other classes
- PiiDistanceMeasure::Impl
  A template that implements the PiiDistanceMeasure interface by using Measure as the distance measure implementation.
- PiiBoostClassifier
  An generic implementation of a boosted classifier.
- PiiClassificationException
  PiiClassificationException is thrown when errors occur in classification.
- PiiClassifier
  An interface for classification and regression algorithms.
- PiiConfusionMatrix
  Confusion matrix is a handy tool for inspecting classification results.
- PiiDecisionStump
  A primitive learner that works by thresholding a single feature.
- PiiDefaultClassifierFactory
  Default implementation of PiiBoostClassifier::Factory.
- PiiGaussianKernel
  Gaussian kernel function.
- PiiKdTree
  K-dimensional tree.
- PiiKernelAdatron
  An implementation of the Kernel Adatron algorithm.
- PiiKernelPerceptron
  An implementation of the Kernel Perceptron algorithm.
- PiiKnnClassifier
  K nearest neighbors classifier.
- PiiLearningAlgorithm
  An interface for learning algorithms.
- PiiMultiFeatureDistance
  A distance measure that combines many distance measures into one.
- PiiPerceptron
  Implementation of the Perceptron algorithm.
- PiiSampleSetCollector
  A learning algorithm that just collects all incoming data into a sample set.
- PiiSom
  An implementation of the self-organizing map (Kohonen map).
- PiiVectorQuantizer
  A vector quantizer.

▶

Colors plug-in

▶
PiiColors namespace
- CorrectGamma
 
 An adaptable binary function that performs gamma correction.
 Template parameters
 <class T>
- CorrectGammaScaled
 
 An adaptable binary function that performs gamma correction on scaled image channels.
 Template parameters
 <class T>
- GenericConversion
 
 An adaptable binary function that multiplies a color with a 3-by-3 matrix.
 Template parameters
 <class Clr>
- HsvToRgb
 
 An adaptable unary function that converts an HSV color to an RGB color.
 Template parameters
 <class Clr>
- LabToXyz
 
 An adaptable binary function that converts an L*a*b* color to an XYZ color, given the white point of the imaging equipment in XYZ.
 Template parameters
 <class Clr>
- LikelihoodFunction
 
 A unary function for converting color distances to "likelihoods".
- ReverseColors
 
 An adaptable unary function that inverses the order of color channels.
 Template parameters
 <class Clr>
- RgbToHsv
 
 An adaptable unary function that converts an RGB color to an HSV color.
 Template parameters
 <class Clr>
- RgbToY709
 
 An adaptable binary function that converts a non-linear RGB color to Y709 luminance.
 Template parameters
 <class Clr>
- RgbToYcbcr
 
 An adaptable unary function for converting from non-linear RGB to Y'CbCr.
 Template parameters
 <class T>
- RgbToYpbpr
 
 An adaptable unary function for converting from non-linear RGB to Y'PbPr.
 Template parameters
 <class T>
- XyzToLab
 
 An adaptable binary function that converts an XYZ color to an L*a*b* color, given the white point of the imaging equipment in XYZ.
 Template parameters
 <class Clr>
- YcbcrToRgb
 
 An adaptable unary function for converting from Y'CbCr to non-linear RGB.
 Template parameters
 <class T>
- YpbprToRgb
 
 An adaptable unary function for converting from Y'PbPr to non-linear RGB.
 Template parameters
 <class T>
- autocorrelogram
 Calculate the autocorrelogram of an indexed color image.
 Parameters
 (const PiiMatrix< int > & image, int maxDistance, int levels)
 Overloads
 - (const PiiMatrix< int > & image, const QList< int > & distances, int levels)
- correctGamma
 Apply gamma correction to a color channel.
 Parameters
 (T value, double gamma, double maximum)
 Overloads
- genericConversion
 
 Convert all colors in an image with a generic conversion matrix.
 Parameters
 (const PiiMatrix< Clr > & colorImage, const PiiMatrix< float > & conversionMatrix)
- hsvToRgb
 Convert a color in an HSV color space into an RGB color space.
 Parameters
 (const Clr & hsvColor)
 Overloads
 - (const PiiMatrix< Clr > & hsvColorImage)
- labToXyz
 Convert a color in the CIE 1976 L*a*b* color space into the CIE XYZ color space.
 Parameters
 (const Clr & labColor, const Clr & whitePoint)
 Overloads
 - (const PiiMatrix< Clr > & labColorImage, const Clr & whitePoint)
- measureColorDistribution
 
 Measure the distribution of colors in an image.
 Parameters
 (const PiiMatrix< ColorType > & clrImage, PiiMatrix< double > & baseVectors, PiiMatrix< double > & center, int maxPixels)
- normalizeColorDistribution
 
 Project colors into a new base and translate to a new center.
 Parameters
 (const PiiMatrix< ColorType > & clrImage, const PiiMatrix< double > & baseVectors, const PiiMatrix< double > & center)
- normalizedRgb
 
 Convert an RGB color image to normalized RGB and separate two of the normalized color layers.
 Parameters
 (const PiiMatrix< T > & image, PiiMatrix< typename T::Type > & ch1, PiiMatrix< typename T::Type > & ch2, float multiplier, int ch1Index, int ch2Index)
- reverseColor
 
 Reverse the order of color channels.
 Parameters
 (const Clr & color)
- reverseColors
 
 Reverse the order of color channels in a color image.
 Parameters
 (const PiiMatrix< Clr > & clrImage)
- rgbToHsv
 Convert an RGB color image into an HSV color image.
 Parameters
 (const PiiMatrix< Clr > & rgbColorImage)
 Overloads
 - (const Clr & rgbColor)
- rgbToY709
 Convert a color image from a non-linear RGB color space to Y709 luminance.
 Parameters
 (const PiiMatrix< Clr > & clrImage)
 Overloads
 - (const Clr & clr)
- rgbToYcbcr
 Convert a non-linear (gamma-adjusted) RGB color into Y'CbCr.
 Parameters
 (const Clr & clr, double maximum)
 Overloads
 - (const PiiMatrix< T > & image, double maximum)
- rgbToYpbpr
 Convert a non-linear (gamma-adjusted) RGB color into Y'PbPr.
 Parameters
 (const Clr & clr)
 Overloads
 - (const PiiMatrix< T > & image)
- toIndexed
 
 Convert a color image into indexed colors.
 Parameters
 (const PiiMatrix< ColorType > & clrImage, int redLevels, int greenLevels, int blueLevels)
- xyzToLab
 Convert an XYZ color image into an L*a*b* color image.
 Parameters
 (const PiiMatrix< Clr > & xyzColorImage, const Clr & whitePoint)
 Overloads
 - (const Clr & xyzColor, const Clr & whitePoint)
- ycbcrToRgb
 Convert a color image in a Y'CbCr space to non-linear RGB.
 Parameters
 (const PiiMatrix< T > & image, double maximum)
 Overloads
 - (const Clr & clr, double maximum)
- ypbprToRgb
 Convert a color image in a Y'PbPr space to non-linear RGB.
 Parameters
 (const PiiMatrix< T > & image)
 Overloads
 - (const Clr & clr)
▶
Operations
- PiiColorChannelSetter
  Sets indidivual color channels in images.
- PiiColorChannelSplitter
  An operation that splits color images into channels.
- PiiColorConverter
  Convert color spaces.
- PiiColorCorrelogramOperation
  Calculate the color autocorrelogram of an image.
- PiiColorModelMatcher
  An operation that converts a color image into an intensity map.
- PiiColorPercentiles
  An operation that calculates percentiles from color histograms.
- PiiImageConversionSwitch
  PiiImageConversionSwitch is an operation which convert a receiving image from the color/gray to the gray/color type if necessary.
- PiiRgbNormalizer
  An operation that converts images to normalized RGB.

▶

Database plug-in

▶

Dsp plug-in

▶
PiiDsp namespace
- Peak
 
 A structure that stores information about a peak detected by findPeaks().
- convolution
 
 Two-dimensional convolution of two matrices.
 Parameters
 (const PiiMatrix< T > & a, const PiiMatrix & b, FilterMode mode)
- correlation
 
 Two-dimensional correlation of two matrices.
 Parameters
 (const PiiMatrix< T > & a, const PiiMatrix & b, FilterMode mode)
- createScalingWavelets
 
 Create an orthogonal wavelet filter set from the given scaling filter.
 Parameters
 (const PiiMatrix< T > & filter)
- daubechiesScalingFilter
 
 Get the indexth Daubechies scaling wavelet.
 Parameters
 (int index)
- downSample
 
 Perform a dyadic downsampling on the input matrix.
 Parameters
 (const PiiMatrix< T > & mat, Pii::MatrixDirections directions, int odd)
- dwt
 Performs a two-dimensional one-level discrete wavelet transform on the input matrix.
 Parameters
 (const PiiMatrix< T > & mat, const PiiMatrix< T > & lo, const PiiMatrix< T > & hi)
 Overloads
 - (const PiiMatrix< T > & mat, WaveletFamily wavelet, int familyMember)
- fftShift
 
 Swap opposing halves or quadrands of a matrix.
 Parameters
 (const PiiMatrix< T > & matrix, bool inverse)
- filter
 
 Two-dimensional filter of two matrices.
 Parameters
 (const PiiMatrix< T > & a, const PiiMatrix & b, FilterMode mode)
- findPeaks
 
 Find peaks in noisy one-dimensional data.
 Parameters
 (const PiiMatrix< double > & data, double levelThreshold, double sharpnessThreshold, int smoothWidth, int windowWidth)
- keep
 
 Take the central part of a matrix.
 Parameters
 (const PiiMatrix< T > & mat, int rows, int cols)
- normalizedCorrelation
 
 Normalized cross-correlation of two-dimensional signals.
 Parameters
 (const PiiMatrix< T > & a, const PiiMatrix & b, FilterMode mode)
- quadratureMirror
 
 Compute a quadrature mirror filter for a filter.
 Parameters
 (const PiiMatrix< T > & filter, int odd)
- scalingFilter
 
 Get the wavelet scaling filter for a certain mother wavelet.
 Parameters
 (WaveletFamily wavelet, int member)
▶
Operations
- PiiFourierTransform
  An operation that calculates the fast fourier transform for any matrix.
- PiiPeakDetector
  Detect peaks in noisy data.
- PiiWaveletTransform
  Discrete wavelet decomposition in two dimensions.
▶
Other classes
- PiiFft
  A class for performing forward and inverse FFT for 1D and 2D signals.

▶

▶

▶

▶

▶
PiiImage namespace
- AdaptiveThresholdFunction
 
 Template parameters
 <class ThresholdFunc>
- AlphaRoi
 A region-of-interest function object that returns true if the alpha channel has a non-zero value at (r,c) and false otherwise.
 Template parameters
 <class T>
 Specializations
 - < PiiColor4< T > >
- ColorToGray
 
 Template parameters
 <class Clr>
- CutFunction
 
 CutFunction compares value to a threshold and outputs either value or threshold based on the comparison result.
 Template parameters
 <class T, class U>
- DefaultLabelingLimiter
 
 A class that collects object labels as the labelImage() function processes the input image.
- DefaultRoi
 
 Default region-of-interest function object for feature extraction and image analysis methods that support ROI processing.
- DefaultSweepFunction
 
 A Default struct which is used in line sweeper.
 Template parameters
 <class ResultType, class ImageType>
- DropFunction
 
 DropFunction compares value to a threshold and outputs either value - threshold or 0 based on the comparison result.
 Template parameters
 <class T, class U>
- FloatTraits
 
 Traits for floating-point images.
 Template parameters
 <class T>
- GrayToGray
 
 Template parameters
 <class T>
- IntegerTraits
 
 Traits for integer-valued images.
 Template parameters
 <class T>
- InverseCutFunction
 
 InverseCutFunction compares value to a threshold and outputs either value or threshold based on the comparison result.
 Template parameters
 <class T, class U>
- InverseThresholdFunction
 
 InverseThresholdFunction compares two values and outputs either 0 or 1 based on the comparison result.
 Template parameters
 <class T, class U>
- InverseTwoLevelThresholdFunction
 
 InverseTwoLevelThresholdFunction works analogously to TwoLevelThresholdFunction, but inverses the result.
 Template parameters
 <class T, class U>
- MeanStdThresholdFunction
 
 A function that calculates a local threshold t as , where r stands for relativeThreshold.
 Template parameters
 <class BinaryFunction, class UnaryFunction>
- ObjectSizeLimiter
 
 An object size limiter for labelImage().
- RadiansToPoints
 
 A unary function that converts radians to points of the compass.
 Template parameters
 <class T>
- SauvolaThresholdFunction
 
 A function that calculates a local threshold t as , where r stands for relativeThreshold and for the maximum possible standard deviation.
 Template parameters
 <class BinaryFunction, class UnaryFunction>
- SweepCollectorFunction
 
 A Functional that collects points which intensity is higher then given threshold.
 Template parameters
 <class ResultType, class ImageType>
- ThresholdFunction
 
 ThresholdFunction compares two values and outputs either 0 or 1 based on the comparison result.
 Template parameters
 <class, class>
- ToGray
 
 Template parameters
 <class T>
- Traits
 The Traits structure specifies default properties of different image types.
 Template parameters
 <class T>
 Specializations
 - < PiiColor4< T > >
 - < PiiColor< T > >
- TwoLevelThresholdFunction
 
 TwoLevelThresholdFunction compares its input argument to two thresholds and returns one if the argument is in between them (inclusive).
 Template parameters
 <class T, class U>
- ZeroAboveFunction
 
 ZeroAboveFunction works analogously to ZeroBelowFunction, but outputs zero for values that are above or equal to the threshold.
 Template parameters
 <class T, class U>
- ZeroBelowFunction
 
 ZeroBelowFunction compares value to a threshold and outputs either value or 0 based on the comparison result.
 Template parameters
 <class T, class U>
- adaptiveThreshold
 Threshold an image adaptively.
 Parameters
 (const PiiRandomAccessMatrix & image, BinaryFunction func, float relativeThreshold, float absoluteThreshold, int windowRows, int windowColumns)
 Overloads
 - (const PiiRandomAccessMatrix & image, BinaryFunction func, int windowRows, int windowColumns)
 - (const PiiRandomAccessMatrix & image, const PiiMatrix< bool > & roiMask, BinaryFunction func, int windowRows, int windowColumns)
- adaptiveThresholdFunction
 
 Parameters
 (const ThresholdFunc & func, float relativeThreshold, float absoluteThreshold)
- alphaToMask
 
 Returns the alpha channel of image as a boolean mask.
 Parameters
 (const PiiMatrix< PiiColor4< T > > & image)
- backProject
 Two-dimensional histogram backprojection.
 Parameters
 (const PiiMatrix< T > & ch1, const PiiMatrix< T > & ch2, const PiiMatrix & histogram)
 Overloads
 - (const PiiMatrix< T > & img, const PiiMatrix & histogram)
- border
 
 Extract the border of binary objects.
 Parameters
 (const PiiMatrix< T > & image)
- bottomHat
 
 Bottom-hat transform.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask)
- calculateDirection
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This function takes a decision function as a parameter.
 Parameters
 (const PiiMatrix< T > & mat, UnaryFunction decisionRule, double * length, double * width, int * pixels)
 Overloads
 - (const PiiMatrix< T > & mat, T label, double * length, double * width, int * pixels, typename Pii::OnlyNumeric< T >::Type )
- calculateProperties
 
 Calculate areas, centroids and bounding boxes for labeled objects.
 Parameters
 (const PiiMatrix< T > & mat, int labels, PiiMatrix< int > & areas, PiiMatrix< int > & centroids, PiiMatrix< int > & bbox)
- close
 
 Morphological closing.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask)
- collectCoordinates
 
 Parameters
 (const PiiRandomAccessMatrix & image, UnaryFunction decisionRule)
- colorChannel
 
 Extract a channel from a color image.
 Parameters
 (const PiiMatrix< ColorType > & image, int channel)
- createMask
 Create a morphological mask.
 Parameters
 (MaskType type, int rows, int columns)
 Overloads
 - (MaskType type, PiiMatrix< T > & mask)
- createRoiMask
 
 Creates a binary ROI mask out of a set of rectangular regions.
 Parameters
 (int rows, int columns, const PiiMatrix< int > & rectangles)
- createRotationTransform
 Creates a transform that rotates a coordinate system theta radians around its origin.
 Parameters
 (float theta)
 Overloads
 - (float theta, float centerX, float centerY)
- createScalingTransform
 
 Creates a transform that scales a coordinate system by scaleX horizontally and by scaleY vertically.
 Parameters
 (float scaleX, float scaleY)
- createShearingTransform
 
 Creates a transform that shears a coordinate system by shearX horizontally and by shearY vertically.
 Parameters
 (float shearX, float shearY)
- createTranslationTransform
 
 Creates a transform that translates a coordinate system by x horizontally and by y vertically.
 Parameters
 (float x, float y)
- crop
 
 Crop a rectangular area out of a transformed image, in which the target may not appear as a rectangular object.
 Parameters
 (const PiiMatrix< T > & image, int x, int y, int width, int height, const PiiMatrix< float > & transform)
- cumulative
 
 Calculate the cumulative frequency distribution of the given frequency distribution (histogram).
 Parameters
 (const PiiMatrix< T > & histogram)
- cut
 
 Cut gray levels.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
- detectEdges
 
 Detect edges in a gray-level image.
 Parameters
 (const PiiMatrix< T > & image, int smoothWidth, T lowThreshold, T highThreshold)
- detectFastCorners
 
 Detects corners in image using the FAST corner detector.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
- dilate
 
 Dilation.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask)
- equalize
 
 Histogram equalization.
 Parameters
 (const PiiMatrix< T > & img, unsigned int levels)
- erode
 
 Perform a morphological erosion operation on a image.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask, bool handleBorders)
- filter
 Filter an image with the given filter.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & filter, Pii::ExtendMode mode)
 Overloads
 - (const PiiMatrix< T > & image, const PiiMatrix & horizontalFilter, const PiiMatrix & verticalFilter, Pii::ExtendMode mode)
 - (const PiiMatrix< ImageType > & image, PrebuiltFilterType type, Pii::ExtendMode mode, int filterSize)
- gradientDirection
 
 Calculate gradient angle from gradient magnitude components.
 Parameters
 (const PiiMatrix< T > & gradX, const PiiMatrix< T > & gradY)
- gradientMagnitude
 
 Calculate total gradient magnitude from gradient magnitude components.
 Parameters
 (const PiiMatrix< T > & gradX, const PiiMatrix< T > & gradY, bool fast)
- handleRoiInput
 
 Parameters
 (PiiInputSocket * input, RoiType roiType, const PiiMatrix< T > & image, Processor & process)
- histogram
 Calculate the histogram of a one-channel image.
 Parameters
 (const PiiMatrix & image, const Roi & roi, const PiiQuantizer & quantizer)
 Overloads
- hitAndMiss
 
 Hit-and-miss transform.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask, const PiiMatrix & significance)
- hysteresisThreshold
 
 Perform hysteresis thresholding on image.
 Parameters
 (const PiiMatrix< T > & image, T lowThreshold, T highThreshold, Connectivity connectivity)
- intFilter
 Filters an integer image by a double-valued filter.
 Parameters
 (const PiiMatrix< int > & image, const PiiMatrix< double > & doubleFilter, Pii::ExtendMode mode, double scale)
 Overloads
 - (const PiiMatrix< int > & image, const PiiMatrix< double > & horizontalFilter, const PiiMatrix< double > & verticalFilter, Pii::ExtendMode mode, double scale)
- inverseCut
 
 Inversely cut gray levels.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
- inverseHysteresisThreshold
 
 Inverse hysteresis thresholding.
 Parameters
 (const PiiMatrix< T > & image, T lowThreshold, T highThreshold, Connectivity connectivity)
- inverseThreshold
 
 Threshold and invert an image.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
- labelImage
 Label image using 4-connectivity.
 Parameters
 (const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat, UnaryOp rule, Limiter limiter, int * labelCount)
 Overloads
 - (const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat, int * labelCount)
 - (const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat, UnaryOp1 rule1, UnaryOp2 rule2, Connectivity connectivity, int labelIncrement, int * labelCount)
- labelLargerThan
 
 Label all 4-connected objects whose size (in pixels) is larger than sizeLimit.
 Parameters
 (const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat, int sizeLimit, int * labelCount)
- makeFilter
 
 Create an image filter.
 Parameters
 (PrebuiltFilterType type, unsigned int size)
- makeGaussian
 
 Create a size-by-size Gaussian low-pass filter.
 Parameters
 (unsigned int size)
- makeLoGaussian
 
 Create a size-by-size Laplacian-of-Gaussian filter.
 Parameters
 (unsigned int size)
- medianFilter
 
 Filters an image with a median filter.
 Parameters
 (const PiiMatrix< T > & image, int filterRows, int filterColumns, Pii::ExtendMode mode)
- morphology
 
 Perform a morphological operation on an image.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask, MorphologyOperation type, bool handleBorders)
- normalize
 
 Normalize the given histogram so that its elements sum up to one.
 Parameters
 (const PiiMatrix & histogram)
- open
 
 Morphological opening.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask)
- otsuThreshold
 
 The Otsu method is used in automatically selecting an optimal threshold.
 Parameters
 (const PiiMatrix< T > & histogram)
- overlapping
 
 Returns true if any two of the given rectangles overlap each other and false otherwise.
 Parameters
 (const PiiMatrix< int > & rectangles)
- percentile
 
 Find the index of the first entry in a cumulative frequency distribution that exceeds or equals to the given value.
 Parameters
 (const PiiMatrix< T > & cumulative, T value)
- PII_DECLARE_EXPORTED_FUNCTION_TEMPLATE
 
 Create a morphological mask.
 Parameters
 (PiiMatrix< unsigned char > , createMask< unsigned char > , (MaskType type, int rows, int columns) , PII_BUILDING_IMAGE )
- remap
 
 Transforms image according to the given coordinate map.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix< PiiPoint > & map)
- rotate
 
 Rotates image theta radians around its center.
 Parameters
 (const PiiMatrix< T > & image, double theta, TransformedSize handling, T backgroundColor)
- scale
 Scales image to a specified size.
 Parameters
 (const PiiMatrix< T > & image, int rows, int columns, Pii::Interpolation interpolation)
 Overloads
 - (const PiiMatrix< T > & image, double scaleRatio, Pii::Interpolation interpolation)
- separateChannels
 
 Split a color image into channels.
 Parameters
 (const PiiMatrix< ColorType > & image, PiiMatrix< typename ColorType::Type > * channelImages, int channels)
- separateFilter
 
 Decompose a two-dimensional filter into two one-dimensional filters.
 Parameters
 (const PiiMatrix< T > & filter, PiiMatrix< T > & horizontalFilter, PiiMatrix< T > & verticalFilter)
- setColorChannel
 Set a color channel.
 Parameters
 (PiiMatrix< ColorType > & image, int channel, const PiiMatrix< typename ColorType::Type > & values)
 Overloads
 - (PiiMatrix< ColorType > & image, int channel, typename ColorType::Type value)
- shrink
 
 Remove object borders.
 Parameters
 (const PiiMatrix< T > & image, int amount)
- sweepLine
 
 A Line sweeper.
 Parameters
 (const PiiMatrix< ImageType > & image, const PiiMatrix< double > & coordinates, SweepFunction function, int radius)
- thin
 
 Thin binary objects towards a skeleton.
 Parameters
 (const PiiMatrix< T > & image, int amount)
- threshold
 
 Threshold an image.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
- to8Bit
 Parameters
 (const PiiMatrix< unsigned char > & image)
 Overloads
 - (const PiiMatrix< T > & image)
 - (const PiiMatrix< float > & image)
- toFloat
 An explicit specialization of the toFloat() function.
 Parameters
 (const PiiMatrix< float > & image)
 Overloads
 - (const PiiMatrix< T > & image)
- toGray
 Parameters
 (const PiiMatrix< PiiColor4< T > > & image)
 Overloads
 - (const PiiMatrix< PiiColor< T > > & image)
 - (const PiiMatrix< T > & image)
- topHat
 
 Top-hat transform.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix & mask)
- toRoiMask
 
 Converts any integer matrix to a boolean matrix.
 Parameters
 (const PiiVariant & obj)
- transform
 
 Applies an arbitrary geometric transform to image.
 Parameters
 (const PiiMatrix< T > & image, const PiiMatrix< float > & transform, TransformedSize handling, T backgroundColor)
- transformHomogeneousPoint
 
 Transforms a 2D point using transform.
 Parameters
 (const PiiMatrix< T > & transform, T sourceX, T sourceY, T * transformedX, T * transformedY)
- transformHomogeneousPoints
 
 Transforms 2D point coordinates using transform.
 Parameters
 (const PiiMatrix< T > & transform, const PiiMatrix & points)
- unwarpCylinder
 
 Straighten an image that is wrapped around a cylinder.
 Parameters
 (const PiiMatrix< T > & warpedImage, double focalLength, double center, double * cameraDistance, double * radius, double * sectorAngle, double * startAngle)
- zeroAbove
 
 Zero values above or equal to threshold.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
- zeroBelow
 
 Zero values below threshold.
 Parameters
 (const PiiMatrix< T > & image, T threshold)
▶
Operations
- PiiBackgroundExtractor
  An operation that models static background of a scene with moving objects.
- PiiBoundaryFinderOperation
  Extracts boundaries of connected objects in images.
- PiiCornerDetector
  Detects corners in gray-level images using the FAST corner detector.
- PiiEdgeDetector
  Detect edges on images.
- PiiFeatureRangeLimiter
  Operation cuts features from feature-vectors by using the first one as a reference.
- PiiHistogramBackProjector
  Perform histogram back-projection.
- PiiHistogramEqualizer
  Histogram equalizer.
- PiiHistogramOperation
  An operation that calculates the histogram of a gray-scale or a color image.
- PiiImageAnnotator
  An operation that draws graphics primitives on an image.
- PiiImageCropper
  An operation that takes a piece of an image or any other matrix.
- PiiImageFileReader
  An operation for reading images from files.
- PiiImageFileWriter
  An operation that writes images into files in standard image formats.
- PiiImageFilterOperation
  An operation that implements basic image filtering operations.
- PiiImagePieceJoiner
  An operation that combines adjacent sub-images to larger compounds.
- PiiImageReaderOperation
  A base class for image sources.
- PiiImageRotationOperation
  Rotate images to arbitrary angles in two dimension.
- PiiImageScaleOperation
  Scale images to arbitrary sizes.
- PiiImageSplitter
  An operation for splitting images into pieces.
- PiiImageUnwarpOperation
  An operation that straightens cylindrically warped images.
- PiiLabelingOperation
  Basic labeling operations.
- PiiMaskGenerator
  An operation that creates binary mask images.
- PiiMorphologyOperation
  Basic binary morphology operations.
- PiiObjectPropertyExtractor
  Calculates geometric properties for labeled objects.
- PiiQuantizerOperation
  Quantizes any numeric matrix to discrete levels.
- PiiThresholdingOperation
  A threshold operation with one threshold value.
▶
Other classes
- PiiBoundaryFinder
  An algorithm that traverses object boundaries.
- PiiCloudFractalGenerator
  A class that generates two-dimensional cloud-like fractal pictures.
- PiiQuantizer
  A class that quantizes (floating point) values to integers.

▶

Io plug-in

▶

Matching plug-in

MultiCamDriver plug-in

MultiCamIoDriver plug-in

▶

▶

▶

▶

▶

▶

▶

▶

▶

Serialization library

▶
PiiSerialization namespace
- Accessor
  
  A proxy through which calls to serialization member functions are passed.
- Void
- isDynamicType
  
  This function is used to check if the real type of the class is known at compile time or not.
  Parameters
  (const void * )
- serialize
  
  Default implementation of a serialization function.
  Parameters
  (Archive & archive, T & value, const unsigned int version)
▶
PiiSerializationTraits namespace
- ClassInfo
 Class information trait.
 Template parameters
 <class T>
 Specializations
 - < const T >
- ClassName
 Class name trait.
 Template parameters
 <class T>
 Specializations
 - < const T >
- IsAbstract
 A type trait for checking the abstractness of a type.
 Template parameters
 <class T>
 Specializations
 - < const T >
- IsPrimitive
 A type trait for checking the primitiveness of a type.
 Template parameters
 <class T>
 Specializations
 - < QString >
- Tracking
 Pointer tracking trait.
 Template parameters
 <class T>
 Specializations
 - < const T >
- Version
 Class version trait.
 Template parameters
 <class T>
 Specializations
 - < const T >
- PII_NAME_TYPE
 Parameters
 (char )
 Overloads
▶
Other classes
- PiiGenericInputArchive::Impl
  Default implementation of the generic input archive interface.
- PiiArchive
  Common base class for all archive types.
- PiiBaseClass
  A wrapper for serializing a base class.
- PiiBinaryInputArchive
  PiiBinaryInputArchive reads raw binary data.
- PiiBinaryObject
  A serialization wrapper for binary data.
- PiiBinaryOutputArchive
  Binary output archive stores data in a raw binary format.
- PiiGenericInputArchive
  A polymorphic implementation of the archive interface.
- PiiGenericOutputArchive
  A polymorphic implementation of the archive interface.
- PiiInputArchive
  A base class for input archive implementations.
- PiiMetaObject
  Meta objects store information specific to a certain data type.
- PiiNameValuePair
  A template that wraps a name and a value into a pair.
- PiiOutputArchive
  A base class for output archive implementations.
- PiiQVariantWrapper
  A serialization wrapper for user types in QVariants.
- PiiSerializationException
  Thrown when an error occurs in (de)serializing data.
- PiiSerializer
  Serializer is an object that takes care of serializing objects.
- PiiSerializerTemplate
  A template class that is statically instantiated to add serializable classes to an archive's serializer registry.
- PiiTextInputArchive
  TextInputArchive reads space-separated textual data.
- PiiTextOutputArchive
  Text output archive stores data in a space-separated textual format.
- PiiTrackedPointerHolder
  A class that is used by PiiOutputArchive to store tracked pointers while serializing them.
- PiiQVariantWrapper::Template
  A template that is instantiated for all user types intended to be serialized as QVariants.

▶

Ydin execution engine

▶
Operations
- PiiBasicOperation
  A bare bones implementation of the PiiOperation interface.
- PiiDefaultOperation
  A functional implementation of the PiiOperation interface.
- PiiEngine
  An execution engine.
- PiiOperation
  A superclass for operations that can be run by Ydin.
- PiiOperationCompound
  PiiOperationCompound is a class that controls a set of operations.
▶
Other classes
- PiiAbstractInputSocket
  An abstract superclass for input sockets.
- PiiAbstractOutputSocket
  An abstract superclass for output sockets.
- PiiAbstractSocket
  A superclass for socket interfaces.
- PiiConfigurationWidget
  An interface that provides different UI components a way of communicating with the controlling program.
- PiiDefaultFlowController
  The default flow controller handles inter-operation synchronization by grouping synchronous sockets and injecting special synchronization tags into the sockets.
- PiiExecutionException
  Thrown when an operation cannot be started, or an error is detected during execution.
- PiiFlowController
  An interface for algorithms that synchronize object flow in sockets.
- PiiInputController
  An interface for classes that receive objects from input sockets.
- PiiInputSocket
  Default implementation of an input socket.
- PiiLayerParser
  This class provides an interface for handling a data structure called a .
- PiiLoadException
  Thrown when the loading of a plug-in fails.
- PiiOneGroupFlowController
  A flow controller that synchronizes a group of sockets with the same group ID.
- PiiOneInputFlowController
  A flow controller that does not handle synchronization between sibling sockets.
- PiiOperationTest
  A class that makes it easier to write unit tests for operations.
- PiiOutputSocket
  An output socket.
- PiiProbeInput
  An input socket that works without a controlling operation.
- PiiProxySocket
  An input-output socket.
- PiiResourceConnector
  An interface for classes that connect resource instances together.
- PiiSocket
  Socket is a connection point between operations.
- PiiSocketState
  A structure that stores information about a socket's state at run time.
- PiiWaitCondition
  Provides waiting/waking conditions between two threads.

Documentation

namespace referencePiiImage

Definitions and operations for handling images.

This namespace contains functions and definitions for creating digital image filters and for applying them to images, thresholding, labeling binary images, connected component analysis, edge detection, and histogram handling.

Classes

struct	PiiImage::AdaptiveThresholdFunction
struct	PiiImage::AlphaRoi A region-of-interest function object that returns `true` if the alpha channel has a non-zero value at (r,c) and `false` otherwise.
struct	PiiImage::AlphaRoi< PiiColor4< T > >
struct	PiiImage::ColorToGray
struct	PiiImage::CutFunction CutFunction compares `value` to a `threshold` and outputs either `value` or `threshold` based on the comparison result.
class	PiiImage::DefaultLabelingLimiter A class that collects object labels as the labelImage() function processes the input image.
struct	PiiImage::DefaultRoi Default region-of-interest function object for feature extraction and image analysis methods that support ROI processing.
struct	PiiImage::DefaultSweepFunction A Default struct which is used in line sweeper.
struct	PiiImage::DropFunction DropFunction compares `value` to a `threshold` and outputs either `value` - `threshold` or 0 based on the comparison result.
struct	PiiImage::FloatTraits Traits for floating-point images.
struct	PiiImage::GrayToGray
struct	PiiImage::IntegerTraits Traits for integer-valued images.
struct	PiiImage::InverseCutFunction InverseCutFunction compares `value` to a `threshold` and outputs either `value` or `threshold` based on the comparison result.
struct	PiiImage::InverseThresholdFunction InverseThresholdFunction compares two values and outputs either 0 or 1 based on the comparison result.
class	PiiImage::InverseTwoLevelThresholdFunction InverseTwoLevelThresholdFunction works analogously to TwoLevelThresholdFunction, but inverses the result.
struct	PiiImage::MeanStdThresholdFunction A function that calculates a local threshold t as , where r stands for `relativeThreshold`.
class	PiiImage::ObjectSizeLimiter An object size limiter for labelImage().
struct	PiiImage::RadiansToPoints A unary function that converts radians to points of the compass.
struct	PiiImage::SauvolaThresholdFunction A function that calculates a local threshold t as , where r stands for `relativeThreshold` and for the maximum possible standard deviation.
struct	PiiImage::SweepCollectorFunction A Functional that collects points which intensity is higher then given threshold.
struct	PiiImage::ThresholdFunction ThresholdFunction compares two values and outputs either 0 or 1 based on the comparison result.
struct	PiiImage::ToGray
struct	PiiImage::Traits The Traits structure specifies default properties of different image types.
struct	PiiImage::Traits< PiiColor4< T > > Specialization for four-channel colors.
struct	PiiImage::Traits< PiiColor< T > > Specialization for three-channel colors.
class	PiiImage::TwoLevelThresholdFunction TwoLevelThresholdFunction compares its input argument to two thresholds and returns one if the argument is in between them (inclusive).
struct	PiiImage::ZeroAboveFunction ZeroAboveFunction works analogously to ZeroBelowFunction, but outputs zero for values that are above or equal to the threshold.
struct	PiiImage::ZeroBelowFunction ZeroBelowFunction compares `value` to a `threshold` and outputs either `value` or 0 based on the comparison result.

Enumerations

enum	Connectivity { Connect4, Connect8 } Pixel connectivitity modes for operations such as labeling and boundary finding.
enum	MaskType { RectangularMask, EllipticalMask, DiamondMask } Predefined types for structuring elements.
enum	MorphologyOperation { Erode, Dilate, Open, Close, TopHat, BottomHat } Binary morphology operations:
enum	PrebuiltFilterType { SobelXFilter, SobelYFilter, PrewittXFilter, PrewittYFilter, RobertsXFilter, RobertsYFilter, UniformFilter, GaussianFilter, LoGFilter } Prebuilt filter types.
enum	RoiType { AutoRoi, MaskRoi, RectangleRoi, NoRoi } Region-of-interest types.
enum	TransformedSize { RetainOriginalSize, ExpandAsNecessary } Border handling methods for geometric image transforms.

Functions

template<class Matrix, class BinaryFunction> PiiMatrix< typename BinaryFunction::result_type >	adaptiveThreshold ( const PiiRandomAccessMatrix & image BinaryFunction func float relativeThreshold float absoluteThreshold int windowRows int windowColumns = 0 ) Threshold an image adaptively.
template<class Matrix, class BinaryFunction> PiiMatrix< typename BinaryFunction::result_type >	adaptiveThreshold ( const PiiRandomAccessMatrix & image BinaryFunction func int windowRows int windowColumns = 0 )
template<class Matrix, class BinaryFunction> PiiMatrix< typename BinaryFunction::result_type >	adaptiveThreshold ( const PiiRandomAccessMatrix & image const PiiMatrix< bool > & roiMask BinaryFunction func int windowRows int windowColumns = 0 )
template<class ThresholdFunc> AdaptiveThresholdFunction< ThresholdFunc >	adaptiveThresholdFunction ( const ThresholdFunc & func float relativeThreshold float absoluteThreshold )
template<class T> PiiMatrix< bool >	alphaToMask ( const PiiMatrix< PiiColor4< T > > & image ) Returns the alpha channel of `image` as a boolean mask.
template<class T, class U> PiiMatrix< U >	backProject ( const PiiMatrix< T > & ch1 const PiiMatrix< T > & ch2 const PiiMatrix< U > & histogram ) Two-dimensional histogram backprojection.
template<class T, class U> PiiMatrix< U >	backProject ( const PiiMatrix< T > & img const PiiMatrix< U > & histogram ) Histogram backprojection.
template<class T> PiiMatrix< T >	border ( const PiiMatrix< T > & image ) Extract the border of binary objects.
template<class T, class U> PiiMatrix< T >	bottomHat ( const PiiMatrix< T > & image const PiiMatrix< U > & mask ) Bottom-hat transform.
template<class T, class UnaryFunction> PiiMatrix< double >	calculateDirection ( const PiiMatrix< T > & mat UnaryFunction decisionRule double * length = 0 double * width = 0 int * pixels = 0 ) This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This function takes a decision function as a parameter.
template<class T> PiiMatrix< double >	calculateDirection ( const PiiMatrix< T > & mat T label double * length = 0 double * width = 0 int * pixels = 0 typename Pii::OnlyNumeric< T >::Type = 0 ) Calculate the "direction" of an object in `mat`.
template<class T> void	calculateProperties ( const PiiMatrix< T > & mat int labels PiiMatrix< int > & areas PiiMatrix< int > & centroids PiiMatrix< int > & bbox ) Calculate areas, centroids and bounding boxes for labeled objects.
template<class T, class U> PiiMatrix< T >	close ( const PiiMatrix< T > & image const PiiMatrix< U > & mask ) Morphological closing.
template<class T, class Matrix, class UnaryFunction> PiiMatrix< T >	collectCoordinates ( const PiiRandomAccessMatrix & image UnaryFunction decisionRule )
template<class ColorType> PiiMatrix< typename ColorType::Type >	colorChannel ( const PiiMatrix< ColorType > & image int channel ) Extract a channel from a color image.
template<class T> PiiMatrix< T >	createMask ( MaskType type int rows int columns = 0 ) Create a morphological mask.
template<class T> void	createMask ( MaskType type PiiMatrix< T > & mask ) Writes a morphological structuring element to mask.
PII_IMAGE_EXPORT PiiMatrix< bool >	createRoiMask ( int rows int columns const PiiMatrix< int > & rectangles ) Creates a binary ROI mask out of a set of rectangular regions.
PII_IMAGE_EXPORT PiiMatrix< float >	createRotationTransform ( float theta ) Creates a transform that rotates a coordinate system `theta` radians around its origin.
PII_IMAGE_EXPORT PiiMatrix< float >	createRotationTransform ( float theta float centerX float centerY ) Creates a transform that rotates a coordinate system `theta` radians around the specified center point.
PII_IMAGE_EXPORT PiiMatrix< float >	createScalingTransform ( float scaleX float scaleY ) Creates a transform that scales a coordinate system by `scaleX` horizontally and by `scaleY` vertically.
PII_IMAGE_EXPORT PiiMatrix< float >	createShearingTransform ( float shearX float shearY ) Creates a transform that shears a coordinate system by `shearX` horizontally and by `shearY` vertically.
PII_IMAGE_EXPORT PiiMatrix< float >	createTranslationTransform ( float x float y ) Creates a transform that translates a coordinate system by `x` horizontally and by `y` vertically.
template<class T> PiiMatrix< T >	crop ( const PiiMatrix< T > & image int x int y int width int height const PiiMatrix< float > & transform ) Crop a rectangular area out of a transformed image, in which the target may not appear as a rectangular object.
template<class T> PiiMatrix< T >	cumulative ( const PiiMatrix< T > & histogram ) Calculate the cumulative frequency distribution of the given frequency distribution (histogram).
template<class T> PiiMatrix< T >	cut ( const PiiMatrix< T > & image T threshold ) Cut gray levels.
template<class T> PiiMatrix< int >	detectEdges ( const PiiMatrix< T > & image int smoothWidth = 0 T lowThreshold = 0 T highThreshold = 0 ) Detect edges in a gray-level image.
template<class T> PiiMatrix< int >	detectFastCorners ( const PiiMatrix< T > & image T threshold = 25 ) Detects corners in image using the FAST corner detector.
template<class T, class U> PiiMatrix< T >	dilate ( const PiiMatrix< T > & image const PiiMatrix< U > & mask ) Dilation.
template<class T> PiiMatrix< T >	equalize ( const PiiMatrix< T > & img unsigned int levels = 0 ) Histogram equalization.
template<class T, class U> PiiMatrix< T >	erode ( const PiiMatrix< T > & image const PiiMatrix< U > & mask bool handleBorders = false ) Perform a morphological erosion operation on a image.
template<class ResultType, class T, class U> PiiMatrix< ResultType >	filter ( const PiiMatrix< T > & image const PiiMatrix< U > & filter Pii::ExtendMode mode = Pii::ExtendReplicate ) Filter an image with the given filter.
template<class ResultType, class T, class U> PiiMatrix< ResultType >	filter ( const PiiMatrix< T > & image const PiiMatrix< U > & horizontalFilter const PiiMatrix< U > & verticalFilter Pii::ExtendMode mode = Pii::ExtendReplicate ) Filter an image with two one-dimensional filters.
template<class ResultType, class ImageType> PiiMatrix< ResultType >	filter ( const PiiMatrix< ImageType > & image PrebuiltFilterType type Pii::ExtendMode mode = Pii::ExtendReplicate int filterSize = 3 ) Same as above, but filters the image with a named filter.
template<class T> PiiMatrix< float >	gradientDirection ( const PiiMatrix< T > & gradX const PiiMatrix< T > & gradY ) Calculate gradient angle from gradient magnitude components.
template<class T> PiiMatrix< T >	gradientMagnitude ( const PiiMatrix< T > & gradX const PiiMatrix< T > & gradY bool fast = true ) Calculate total gradient magnitude from gradient magnitude components.
template<class T, class Processor> void	handleRoiInput ( PiiInputSocket * input RoiType roiType const PiiMatrix< T > & image Processor & process )
template<class T, class U, class Roi> PiiMatrix< T >	histogram ( const PiiMatrix< U > & image const Roi & roi const PiiQuantizer< U > & quantizer ) Calculate the histogram of a one-channel image.
template<class T, class Roi> PiiMatrix< int >	histogram ( const PiiMatrix< T > & image const Roi & roi const PiiQuantizer< T > & quantizer ) Calculate the histogram of a one-channel image.
template<class T, class Roi> PiiMatrix< int >	histogram ( const PiiMatrix< T > & image const Roi & roi unsigned int levels ) Calculate the histogram of a one-channel image.
template<class T> PiiMatrix< int >	histogram ( const PiiMatrix< T > & image const PiiQuantizer< T > & quantizer ) Calculate the histogram of a one-channel image.
template<class T, class U, class Roi> PiiMatrix< T >	histogram ( const PiiMatrix< U > & image const Roi & roi unsigned int levels ) Calculate the histogram of a one-channel image.
template<class T> PiiMatrix< int >	histogram ( const PiiMatrix< T > & image unsigned int levels = 0 ) Calculate the histogram of a one-channel image.
template<class T, class U> PiiMatrix< T >	hitAndMiss ( const PiiMatrix< T > & image const PiiMatrix< U > & mask const PiiMatrix< U > & significance ) Hit-and-miss transform.
template<class T> PiiMatrix< int >	hysteresisThreshold ( const PiiMatrix< T > & image T lowThreshold T highThreshold Connectivity connectivity = Connect8 ) Perform hysteresis thresholding on image.
PII_IMAGE_EXPORT PiiMatrix< int >	intFilter ( const PiiMatrix< int > & image const PiiMatrix< double > & doubleFilter Pii::ExtendMode mode = Pii::ExtendReplicate double scale = 0 ) Filters an integer image by a double-valued filter.
PII_IMAGE_EXPORT PiiMatrix< int >	intFilter ( const PiiMatrix< int > & image const PiiMatrix< double > & horizontalFilter const PiiMatrix< double > & verticalFilter Pii::ExtendMode mode = Pii::ExtendReplicate double scale = 0 ) Filters an integer image by a double-valued separable filter.
template<class T> PiiMatrix< T >	inverseCut ( const PiiMatrix< T > & image T threshold ) Inversely cut gray levels.
template<class T> PiiMatrix< int >	inverseHysteresisThreshold ( const PiiMatrix< T > & image T lowThreshold T highThreshold Connectivity connectivity = Connect8 ) Inverse hysteresis thresholding.
template<class T> PiiMatrix< T >	inverseThreshold ( const PiiMatrix< T > & image T threshold ) Threshold and invert an image.
template<class Matrix, class UnaryOp, class Limiter> PiiMatrix< int >	labelImage ( const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat UnaryOp rule Limiter limiter int * labelCount = 0 ) Label image using 4-connectivity.
template<class Matrix> PiiMatrix< int >	labelImage ( const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat int * labelCount = 0 ) Label image using 4-connectivity.
template<class Matrix, class UnaryOp1, class UnaryOp2> PiiMatrix< int >	labelImage ( const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat UnaryOp1 rule1 UnaryOp2 rule2 Connectivity connectivity int labelIncrement = 1 int * labelCount = 0 ) Label connected components.
template<class Matrix> PiiMatrix< int >	labelLargerThan ( const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat int sizeLimit int * labelCount = 0 ) Label all 4-connected objects whose size (in pixels) is larger than `sizeLimit`.
template<class T> PiiMatrix< T >	makeFilter ( PrebuiltFilterType type unsigned int size = 3 ) Create an image filter.
PII_IMAGE_EXPORT PiiMatrix< double >	makeGaussian ( unsigned int size ) Create a size-by-size Gaussian low-pass filter.
PII_IMAGE_EXPORT PiiMatrix< double >	makeLoGaussian ( unsigned int size ) Create a size-by-size Laplacian-of-Gaussian filter.
template<class T> PiiMatrix< T >	medianFilter ( const PiiMatrix< T > & image int filterRows = 3 int filterColumns = 0 Pii::ExtendMode mode = Pii::ExtendZeros ) Filters an image with a median filter.
template<class T, class U> PiiMatrix< T >	morphology ( const PiiMatrix< T > & image const PiiMatrix< U > & mask MorphologyOperation type bool handleBorders = false ) Perform a morphological operation on an image.
template<class T, class U> PiiMatrix< T >	normalize ( const PiiMatrix< U > & histogram ) Normalize the given histogram so that its elements sum up to one.
template<class T, class U> PiiMatrix< T >	open ( const PiiMatrix< T > & image const PiiMatrix< U > & mask ) Morphological opening.
template<class T> int	otsuThreshold ( const PiiMatrix< T > & histogram ) The Otsu method is used in automatically selecting an optimal threshold.
PII_IMAGE_EXPORT bool	overlapping ( const PiiMatrix< int > & rectangles ) Returns `true` if any two of the given rectangles overlap each other and `false` otherwise.
template<class T> int	percentile ( const PiiMatrix< T > & cumulative T value ) Find the index of the first entry in a cumulative frequency distribution that exceeds or equals to the given value.
	PII_DECLARE_EXPORTED_FUNCTION_TEMPLATE ( PiiMatrix< unsigned char > createMask< unsigned char > (MaskType type, int rows, int columns) PII_BUILDING_IMAGE ) Create a morphological mask.
template<class T, class U> PiiMatrix< T >	remap ( const PiiMatrix< T > & image const PiiMatrix< PiiPoint< U > > & map ) Transforms image according to the given coordinate map.
template<class T> PiiMatrix< T >	rotate ( const PiiMatrix< T > & image double theta TransformedSize handling = ExpandAsNecessary T backgroundColor = T(0) ) Rotates image `theta` radians around its center.
template<class T> PiiMatrix< T >	scale ( const PiiMatrix< T > & image int rows int columns Pii::Interpolation interpolation = Pii::LinearInterpolation ) Scales image to a specified size.
template<class T> PiiMatrix< T >	scale ( const PiiMatrix< T > & image double scaleRatio Pii::Interpolation interpolation = Pii::LinearInterpolation ) Scales image according to a scale ratio.
template<class ColorType> void	separateChannels ( const PiiMatrix< ColorType > & image PiiMatrix< typename ColorType::Type > * channelImages int channels = 3 ) Split a color image into channels.
template<class T> bool	separateFilter ( const PiiMatrix< T > & filter PiiMatrix< T > & horizontalFilter PiiMatrix< T > & verticalFilter ) Decompose a two-dimensional filter into two one-dimensional filters.
template<class ColorType> void	setColorChannel ( PiiMatrix< ColorType > & image int channel const PiiMatrix< typename ColorType::Type > & values ) Set a color channel.
template<class ColorType> void	setColorChannel ( PiiMatrix< ColorType > & image int channel typename ColorType::Type value ) Set a color channel to a constant value.
template<class T> PiiMatrix< T >	shrink ( const PiiMatrix< T > & image int amount = 1 ) Remove object borders.
template<class ImageType, class SweepFunction> SweepFunction	sweepLine ( const PiiMatrix< ImageType > & image const PiiMatrix< double > & coordinates SweepFunction function int radius = 0 ) A Line sweeper.
template<class T> PiiMatrix< T >	thin ( const PiiMatrix< T > & image int amount = 1 ) Thin binary objects towards a skeleton.
template<class T> PiiMatrix< T >	threshold ( const PiiMatrix< T > & image T threshold ) Threshold an image.
PiiMatrix< unsigned char >	to8Bit ( const PiiMatrix< unsigned char > & image )
template<class T> PiiMatrix< unsigned char >	to8Bit ( const PiiMatrix< T > & image ) Convert the gray values of an image to 8-bit gray.
PiiMatrix< unsigned char >	to8Bit ( const PiiMatrix< float > & image ) Convert the gray values of an image to 8-bit gray.
PiiMatrix< float >	toFloat ( const PiiMatrix< float > & image ) An explicit specialization of the toFloat() function.
template<class T> PiiMatrix< float >	toFloat ( const PiiMatrix< T > & image ) Convert the gray values of an image to floating point.
template<class T> PiiMatrix< T >	toGray ( const PiiMatrix< PiiColor4< T > > & image )
template<class T> PiiMatrix< T >	toGray ( const PiiMatrix< PiiColor< T > > & image )
template<class T> const PiiMatrix< T > &	toGray ( const PiiMatrix< T > & image )
template<class T, class U> PiiMatrix< T >	topHat ( const PiiMatrix< T > & image const PiiMatrix< U > & mask ) Top-hat transform.
PII_IMAGE_EXPORT PiiMatrix< bool >	toRoiMask ( const PiiVariant & obj ) Converts any integer matrix to a boolean matrix.
template<class T> PiiMatrix< T >	transform ( const PiiMatrix< T > & image const PiiMatrix< float > & transform TransformedSize handling = ExpandAsNecessary T backgroundColor = T(0) ) Applies an arbitrary geometric transform to `image`.
template<class T> void	transformHomogeneousPoint ( const PiiMatrix< T > & transform T sourceX T sourceY T * transformedX T * transformedY ) Transforms a 2D point using transform.
template<class T, class U> PiiMatrix< U >	transformHomogeneousPoints ( const PiiMatrix< T > & transform const PiiMatrix< U > & points ) Transforms 2D point coordinates using transform.
template<class T> PiiMatrix< T >	unwarpCylinder ( const PiiMatrix< T > & warpedImage double focalLength = 1e100 double center = NAN double * cameraDistance = 0 double * radius = 0 double * sectorAngle = 0 double * startAngle = 0 ) Straighten an image that is wrapped around a cylinder.
template<class T> PiiMatrix< T >	zeroAbove ( const PiiMatrix< T > & image T threshold ) Zero values above or equal to threshold.
template<class T> PiiMatrix< T >	zeroBelow ( const PiiMatrix< T > & image T threshold ) Zero values below threshold.

Variables

PII_IMAGE_EXPORT PiiMatrix< int >	borderMasks [8][2] Masks for detecting border pixels in binary objects.
PII_IMAGE_EXPORT PiiMatrix< int >	prewittX Predefined filter masks for the x and y components of the Prewitt edge finder.
PII_IMAGE_EXPORT PiiMatrix< int >	prewittY
PII_IMAGE_EXPORT PiiMatrix< int >	robertsX Predefined filter masks for the x and y components of the Roberts edge finder.
PII_IMAGE_EXPORT PiiMatrix< int >	robertsY
PII_IMAGE_EXPORT PiiMatrix< int >	sobelX Predefined filter masks for the x and y components of the Sobel edge finder.
PII_IMAGE_EXPORT PiiMatrix< int >	sobelY

Enumeration details

enum Connectivity
Pixel connectivitity modes for operations such as labeling and boundary finding.
- Connect4 - the four horizontal and vertical neighbors of a pixel are treated as connected pixels.
- Connect8 - all neighbors (horizontal, vertical and diagonal) of a pixel are treated as connected pixels.
  4-connected 8-connected +---+---+---+ +---+---+---+ | | X | | | X | X | X | +---+---+---+ +---+---+---+ | X | o | X | | X | o | X | +---+---+---+ +---+---+---+ | | X | | | X | X | X | +---+---+---+ +---+---+---+

enum MaskType

Predefined types for structuring elements.

RectangularMask - the whole mask is filled with ones.
EllipticalMask - circle or ellipse, depending on the size of the mask.
DiamondMask - a diamond

Examples of 5-by-5 masks:

 Rectangular  Elliptical   Diamond
  1 1 1 1 1   0 1 1 1 0   0 0 1 0 0
  1 1 1 1 1   1 1 1 1 1   0 1 1 1 0
  1 1 1 1 1   1 1 1 1 1   1 1 1 1 1
  1 1 1 1 1   1 1 1 1 1   0 1 1 1 0
  1 1 1 1 1   0 1 1 1 0   0 0 1 0 0

enum MorphologyOperation
Binary morphology operations:
- Erode - erosion
- Dilate - dilation
- Open - dilation after erosion
- Close - erosion after dilation
- Tophat - original minus opened
- Bottomhat - closed minus original
enum PrebuiltFilterType
Prebuilt filter types.
- SobelXFilter - Sobel's edge detection filter in x direction
- SobelYFilter - Sobel's edge detection filter in y direction
- PrewittXFilter - Prewitt's edge detection filter in x direction
- PrewittYFilter - Prewitt's edge detection filter in y direction
- RobertsXFilter - Robert's edge detection filter in x direction
- RobertsYFilter - Robert's edge detection filter in y direction
- UniformFilter - a moving average filter. Every element in the filter matrix is equal.
- GaussianFilter - Gaussian low-pass filter.
- LoGFilter - Laplacian-of-Gaussian edge detection filter
enum RoiType
Region-of-interest types.
- AutoRoi - the type of the ROI is automatically determined. If the ROI object is a PiiMatrix<int>, RectangleRoi will be used. Otherwise, MaskRoi will be used.
- MaskRoi - the ROI is represented as a binary matrix (PiiMatrix<bool>) in which non-zero (true) entries represent interesting pixels. The size of the ROI mask must be equal to that of the processed image.
- RectangleRoi - the ROI is a set of rectangles, each represented by a four-dimensional vector (x, y, width, height). The rectangles are stored in an N-by-4 PiiMatrix<int>.
- NoRoi - ROI is disabled. Even if there is a ROI present, the whole image will be processed.
enum TransformedSize
Border handling methods for geometric image transforms.
- RetainOriginalSize - crop the transformed image to the size of the source image. Any border areas visible in the final image will be left black. If the image is translated, the whole result may be left black. (Figure A)
- ExpandAsNecessary - create a smaller/larger image that frames all transformed pixels. Translation won't affect the result as it will always be centered. (Figure B)
```
                ______ 
    /\         |  /\  |
 +-/--\-+      | /  \ |
 |/    \|      |/    \|
 |\    /|      |\    /|
 +-\--/-+      | \  / |
    \/         |__\/__|

    A             B
```
In the figures, the diamond shape denotes the transformed image. The boxed area shows the size of the result image.

Function details

template<class Matrix, class BinaryFunction>

PiiMatrix< typename BinaryFunction::result_type > adaptiveThreshold
(
- const PiiRandomAccessMatrix & image
- BinaryFunction func
- float relativeThreshold
- float absoluteThreshold
- int windowRows
- int windowColumns = 0
)
#include <PiiThresholding.h>

Threshold an image adaptively.
The threshold is calculated separately for each pixel based on the local mean. The local mean is calculated over an area determined by windowRows and windowColumns. The final threshold t is obtained by , where r denotes relativeThreshold and a absoluteThreshold. If windowColumns is non-positive, the same value will be used for both window dimensions.

Window size has no effect on processing time.
```
 using namespace PiiImage;
 PiiMatrix<float> img;
 // Threshold at 0.8 times the local mean. Using
 // InverseThresholdFunction as function sets values lower than
 // the threshold to one.
 img = adaptiveThreshold(img, InverseThresholdFunction<float>(), 0.8, 0.0, 65);
```
If the input image is integer-typed, you can avoid rounding errors by providing a different input type for the thresholding function, for example ThresholdFunction<float,int>.
Parameters

image

the input image
func

a binary function whose return value replaces the pixel value in image. Invoked as , where is the value of a pixel and t is a locally calculated threshold. The type of the threshold is float for all other image types except double, in which case a double will be passed.
relativeThreshold

multiply local average with this value
absoluteThreshold

add this value to the multiplication result
windowRows

the number of rows in the local averaging window
windowColumns

the number of columns in the local averaging window. If this value is non-positive, a windowRows - by - windowRows square window will be used.
template<class Matrix, class BinaryFunction>

PiiMatrix< typename BinaryFunction::result_type > adaptiveThreshold
(
- const PiiRandomAccessMatrix & image
- BinaryFunction func
- int windowRows
- int windowColumns = 0
)
#include <PiiThresholding.h>
template<class Matrix, class BinaryFunction>

PiiMatrix< typename BinaryFunction::result_type > adaptiveThreshold
(
- const PiiRandomAccessMatrix & image
- const PiiMatrix< bool > & roiMask
- BinaryFunction func
- int windowRows
- int windowColumns = 0
)
#include <PiiThresholding.h>
template<class ThresholdFunc>

AdaptiveThresholdFunction< ThresholdFunc > adaptiveThresholdFunction
(
- const ThresholdFunc & func
- float relativeThreshold
- float absoluteThreshold
)
#include <PiiThresholding.h>
template<class T>

PiiMatrix< bool > alphaToMask
(
- const PiiMatrix< PiiColor4< T > > & image
)
#include <PiiRoi.h>

Returns the alpha channel of image as a boolean mask.

Non-zero entries in the alpha channel will be true in the returned mask.
template<class T, class U>

PiiMatrix backProject
(
- const PiiMatrix< T > & ch1
- const PiiMatrix< T > & ch2
- const PiiMatrix & histogram
)
#include <PiiHistogram.h>

Two-dimensional histogram backprojection.
This function is analogous to the previous one, but uses a two-dimensional histogram for backprojection. It is provided just for convenience as two-dimensional distributions can be converted to one dimension.
The sizes of ch1 and ch2 must be equal.
```
 // Backproject a two-dimensional RG histogram
 PiiMatrix<int> histogram(256,256);
 PiiMatrix<unsigned char> redChannel(100,100);
 PiiMatrix<unsigned char> greenChannel(100,100);
 PiiMatrix<int> backProjected(PiiImage::backProject(redChannel, greenChannel, histogram));
```
Parameters

ch1

first channel (indexes rows in histogram, maximum value N-1)
ch2

second channel (indexes columns in histogram, maximum value M-1)
histogram

two-dimensional histogram (N-by-M)
template<class T, class U>

PiiMatrix backProject
(
- const PiiMatrix< T > & img
- const PiiMatrix & histogram
)
#include <PiiHistogram.h>

Histogram backprojection.
In backprojection, each pixel in img is replaced by the corresponding value in histogram. Despite histogram backprojection this function can be used to convert indexed images to color images.
The function makes no boundary checks for performance reasons. If you aren't sure about your data, you must check that histogram.columns() is larger than the maximum value in img and that there are no negative values in img.
Since pixels in img are used as indices in histogram, they will be converted to integers. Using floating-point types in the img parameter is not suggested.
```
 // Normal backprojection
 PiiMatrix<int> histogram(1,256);
 PiiMatrix<unsigned char> img(100,100);
 PiiMatrix<int> backProjected(PiiImage::backProject(img,histogram));

 // Color mapping
 PiiMatrix<PiiColor<> > colorMap(1,256);
 PiiMatrix<unsigned char> indexedImg(100,100);
 PiiMatrix<PiiColor<> > colorImg(PiiImage::backProject(indexedImg, colorMap);
```
Parameters

img

input image
histogram

the histogram. A 1-by-N matrix.
template<class T>

PiiMatrix< T > border
(
- const PiiMatrix< T > & image
)
#include <PiiMorphology.h>

Extract the border of binary objects.

Parameters

image

input image

Returns

an image in which only the borders of binary objects are retained.

template<class T, class U>

PiiMatrix< T > bottomHat

(

const PiiMatrix< T > & image
const PiiMatrix & mask

)

#include <PiiMorphology.h>

Bottom-hat transform.

Also known as the black top-hat transform. The bottom-hat transform extracts small dark elements from images. It is defined as the difference between the closing of an imput image and the input image itself.

 PiiMatrix<int> source(8,8,
                       0,0,0,0,0,0,0,0,
                       1,1,1,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,1,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,1,1,0,0,0,0,
                       0,0,0,0,0,0,0,0);
 
 PiiMatrix<int> mask(3,3,
                     1,1,1,
                     1,1,1,
                     1,1,1);

 PiiMatrix<int> result(PiiImage::bottomHat(source,mask));
 //Output
 // 0,0,0,0,0,0,0,0,
 // 0,0,0,0,0,0,0,0,
 // 0,0,1,0,0,0,0,0,
 // 0,0,1,0,0,0,0,0,
 // 0,0,0,0,0,0,0,0,
 // 0,0,1,0,0,0,0,0,
 // 0,0,0,0,0,0,0,0,
 // 0,0,0,0,0,0,0,0

Parameters

image: a binary image.
mask: structuring element.

Returns

bottom-hat transform

template<class T, class UnaryFunction>

PiiMatrix< double > calculateDirection
(
- const PiiMatrix< T > & mat
- UnaryFunction decisionRule
- double * length = 0
- double * width = 0
- int * pixels = 0
)
#include <PiiObjectProperty.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. This function takes a decision function as a parameter.
```
 PiiMatrix<int> matInput;
 // All pixels with a gray level higher than 3 are foreground
 PiiMatrix<double> matDir(Pii::calculateDirection(matInput,
 std::bind2nd(std::greater<int>(), 3));
```
template<class T>

PiiMatrix< double > calculateDirection
(
- const PiiMatrix< T > & mat
- T label
- double * length = 0
- double * width = 0
- int * pixels = 0
- typename Pii::OnlyNumeric< T >::Type = 0
)
#include <PiiObjectProperty.h>

Calculate the "direction" of an object in mat.

This function uses PCA to find the most prominent orientation of the object marked with label in image.

Parameters

mat

labeled image
label

the object to be inspected
length

an output parameter that will store the relative length of the object
width

an output parameter that will store the relative width of the object
pixels

an output parameter that will store the number of pixels used for estimation

Returns

a 2-by-2 matrix consisting of orthonormal row vectors. The first one is aligned to the most prominent direction. For example (1,0) means right and (0,1) up. If there are less than two pixels that match the label, the matrix will be [1 0; 0 1], and length/width will be set to zero.
template<class T>

void calculateProperties
(
- const PiiMatrix< T > & mat
- int labels
- PiiMatrix< int > & areas
- PiiMatrix< int > & centroids
- PiiMatrix< int > & bbox
)
#include <PiiObjectProperty.h>

Calculate areas, centroids and bounding boxes for labeled objects.

Parameters

mat

labeled matrix
labels

number of labeled objects. Must equal to the maximum value in mat. Set to zero if unknown.
areas

the number of pixels in each labeled object. A N-by-1 matrix, where N is the number of labels.
centroids

center of mass for each labeled object. A N-by-2 matrix in which each row stores the column and row coordinates of the object's centroid, in this order.
bbox

the bounding boxes of found objects. A N-by-4 matrix in which each row represent the x (column), y (row), width and height of a labeled object, in this order.
template<class T, class U>

PiiMatrix< T > close
(
- const PiiMatrix< T > & image
- const PiiMatrix & mask
)
[inline]
#include <PiiMorphology.h>

Morphological closing.
template<class T, class Matrix, class UnaryFunction>

PiiMatrix< T > collectCoordinates
(
- const PiiRandomAccessMatrix & image
- UnaryFunction decisionRule
)
#include <PiiImage.h>
template<class ColorType>

PiiMatrix< typename ColorType::Type > colorChannel
(
- const PiiMatrix< ColorType > & image
- int channel
)
#include <PiiImage.h>

Extract a channel from a color image.
This is a generic template function that works with any color type.
```
 PiiMatrix<PiiColor4<> > image(5,5);
 PiiMatrix<unsigned char> ch1(PiiImage::colorChannel(image, 1)); // Green channel

 PiiMatrix<PiiColor<unsigned short> > image2(5,5);
 PiiMatrix<unsigned short> ch2(PiiImage::colorChannel(image2, 2)); // Blue channel
```
Parameters

image

the input image
channel

the zero-based index of the color channel

Returns

the channel as a matrix whose dimensions equal to the input image.
template<class T>

PiiMatrix< T > createMask
(
- MaskType type
- int rows
- int columns = 0
)
#include <PiiMorphology.h>

Create a morphological mask.

A template implementation that can be used to create binary masks with any content type.
This is the default version of this function with no template arguments that returns a PiiMatrix<int>.

Parameters

type

a predefined mask type
rows

the number of rows in the mask
columns

the number of columns in the mask (0 means equal to rows)

Returns

a mask suitable for morphological operations
template<class T>

void createMask
(
- MaskType type
- PiiMatrix< T > & mask
)
#include <PiiMorphology.h>

Writes a morphological structuring element to mask.

The implementation writes only non-zero values to mask. One usually needs to make sure the mask is initially zeros.

Parameters

type

mask

a matrix to be filled with the morphological mask.
PII_IMAGE_EXPORT PiiMatrix< bool > createRoiMask
(
- int rows
- int columns
- const PiiMatrix< int > & rectangles
)
#include <PiiRoi.h>

Creates a binary ROI mask out of a set of rectangular regions.

Parameters

rows

the number of rows in the result image
columns

the number of columns in the result image
rectangles

a N-by-4 matrix in which each row represents a rectangle (x, y, width, height). If a rectangle exceeds the boundaries of the result image, it will be ignored.

Returns

a rows -by- columns binary image in which all pixels that are in any of the rectangles will be set to true.
PII_IMAGE_EXPORT PiiMatrix< float > createRotationTransform
(
- float theta
)
#include <PiiImage.h>

Creates a transform that rotates a coordinate system theta radians around its origin.

In the image coordinate system, angles grow clockwise.

See also
- transform()

PII_IMAGE_EXPORT PiiMatrix< float > createRotationTransform

(

float theta
float centerX
float centerY

)

#include <PiiImage.h>

Creates a transform that rotates a coordinate system theta radians around the specified center point.

 // Rotate 45 degrees around image center
 PiiMatrix<int> img(100,100);
 PiiMatrix<float> matRotation = createRotationTransform(M_PI/4,
                                                        img.columns()/2.0,
                                                        img.rows()/2.0);
 img = transform(img, matRotation);

In the image coordinate system, angles grow clockwise.

PiiMatrix< T > crop

(

const PiiMatrix< T > & image
int x
int y
int width
int height
const PiiMatrix< float > & transform

)

#include <PiiImage.h>

Crop a rectangular area out of a transformed image, in which the target may not appear as a rectangular object.

This function makes it possible to cut parts rectangular pars of an image even if the image was transformed with an affine transform.

 PiiMatrix<int> image(5, 5,
                      0, 0, 1, 0, 0,
                      0, 0, 2, 0, 0,
                      0, 0, 3, 0, 0,
                      0, 0, 4, 0, 0,
                      0, 0, 5, 0, 0);

 // This transformation rotates 90 degrees clockwise around
 // origin (in image coordinates, y down) and translates
 // 3 steps to the right and one step down.
 PiiMatrix<float> matTransform(3, 3,
                               0.0, -1.0, 3.0,
                               1.0, 0.0, 1.0,
                               0.0, 0.0, 1.0);

 // The original area is a 3-by-3 square the upper left corner.
 PiiMatrix<int> matCropped = PiiImage::crop(image,
                                            0, 0, 3, 3,
                                            matTransform);

 // matCropped = 0 0 0
 //              2 3 4
 //              0 0 0

Parameters

image: the source image
x: the x coordinate of the original upper left corner of the rectangle
y: the y coordinate of the original upper left corner of the rectangle
width: the width of the rectangle to cut out of the image
height: the height of the rectangle to cut out of the image
transform: a 3-by-3 transformation matrix A that relates the coordinates of the result r to the image i: Ar = i. The function uses homogeneous coordinates.

template<class T>

PiiMatrix< T > cumulative
(
- const PiiMatrix< T > & histogram
)
[inline]
#include <PiiHistogram.h>

Calculate the cumulative frequency distribution of the given frequency distribution (histogram).
The histogram must be represented as a row vector. If the input matrix has many rows, the cumulative histogram for each row is calculated.
```
 PiiMatrix<int> histogram(1,5, 1,2,3,4,5);
 PiiMatrix<int> cum(PiiImage::cumulative(histogram)); // sic!
 // cum = (1,3,6,10,15)
```
See also
- Pii::cumulativeSum()
template<class T>

PiiMatrix< T > cut
(
- const PiiMatrix< T > & image
- T threshold
)
[inline]
#include <PiiThresholding.h>

Cut gray levels.

Every pixel above threshold will be set to threshold.

See also
- CutFunction
template<class T>

PiiMatrix< int > detectEdges
(
- const PiiMatrix< T > & image
- int smoothWidth = 0
- T lowThreshold = 0
- T highThreshold = 0
)
#include <PiiImage.h>

Detect edges in a gray-level image.

This function implements the Canny edge detector.

Parameters

image

a gray-level image in which edges are to be found
smoothWidth

the width of a Gaussian smoothing window
lowThreshold

the low threshold value for hysteresis thresholding. If zero, 0.4 * highThreshold will be used.
highThreshold

the high threshold value for hysteresis thresholding. If zero, mean+2*std of the gradient magnitude will be used.

Returns

a binary image in which detected edges are ones and other pixels zeros.
template<class T>

PiiMatrix< int > detectFastCorners
(
- const PiiMatrix< T > & image
- T threshold = 25
)
#include <PiiImage.h>

Detects corners in image using the FAST corner detector.

Parameters

image

the input image
threshold

detection threshold. This value affects both the number of detections and the detection speed. A high value accepts only strong corners. The lower the value, the more corners are detected, which also means lower processing speed.

Returns

a N-by-2 matrix in which each row stores the (x,y) coordinates of a detected corner.

template<class T, class U>

PiiMatrix< T > dilate

(

const PiiMatrix< T > & image
const PiiMatrix & mask

)

#include <PiiMorphology.h>

Dilation.

 PiiMatrix<int> source(8,8,
                       0,0,0,0,0,0,0,0,
                       1,1,1,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,1,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,1,1,0,0,0,0,
                       0,0,0,0,0,0,0,0);

 PiiMatrix<int> mask(3,3,
                     1,1,1,
                     1,1,1,
                     1,1,1);
 
 PiiMatrix<int> result = PiiImage::dilate(source, mask);
 Pii::matlabPrint(std::cout,result);
 //Output
 //1,1,1,1,1,1,1,1,
 //1,1,1,1,1,1,1,1,
 //1,1,1,1,1,1,1,1,
 //0,1,1,1,1,1,1,1,
 //0,1,1,1,1,1,1,1,
 //0,1,1,1,1,1,1,1,
 //0,1,1,1,1,1,1,1,
 //0,1,1,1,1,0,0,0

Parameters

image: is orginal binary image.
mask: is structuring element.

Returns

the binary image which is result of dilation.

template<class T>

PiiMatrix< T > equalize
(
- const PiiMatrix< T > & img
- unsigned int levels = 0
)
#include <PiiHistogram.h>

Histogram equalization.

Enhances the contrast of img by making its gray levels as uniformly distributed as possible.

Parameters

img

the input image
levels

the number of quantization levels. If this value is omitted, the maximum value found in image will be used. If levels is smaller than the maximum value, the latter will be used.

Returns

an image with enhanced contrast

template<class T, class U>

PiiMatrix< T > erode

(

const PiiMatrix< T > & image
const PiiMatrix & mask
bool handleBorders = false

)

#include <PiiMorphology.h>

Perform a morphological erosion operation on a image.

 PiiMatrix<int> source(8,8,
                        0,0,0,0,0,0,0,0,
                        1,1,1,1,1,1,1,1,
                        0,0,0,1,1,1,1,1,
                        0,0,0,1,1,1,1,1,
                        0,0,1,1,1,1,1,1,
                        0,0,0,1,1,1,1,1,
                        0,0,1,1,0,0,0,0,
                        0,0,0,0,0,0,0,0);

 PiiMatrix<int> mask(3,4,
                     1,1,1,1,
                     1,1,1,1,
                     1,1,1,1); // mask origin now (1,2)

 PiiMatrix<int> result = PiiImage::erode(source, mask,false);
 Pii::matlabPrint(std::cout, result);

 //Output
 //0,0,0,0,0,0,0,0,
 //0,0,0,0,0,0,0,0,
 //0,0,0,0,0,1,1,0,
 //0,0,0,0,0,1,1,0,
 //0,0,0,0,0,1,1,0,
 //0,0,0,0,0,1,1,0,
 //0,0,0,0,0,0,0,0,
 //0,0,0,0,0,0,0,0

 //Padding example:
 PiiMatrix<int> source(8,8,
                       1,1,0,0,0,0,0,1,
                       1,1,1,1,1,1,1,0,
                       1,1,0,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,1,1,1,1,1,0,
                       0,0,0,1,1,1,1,0,
                       0,0,1,1,0,0,0,0,
                       1,0,0,0,0,0,0,0);

 PiiMatrix<int> mask(3,3,
                     1,1,1,
                     1,1,1,
                     1,1,1);
 
 PiiMatrix<int> result = PiiImage::erode(source, mask, true);
 Pii::matlabPrint(std::cout, result);
 //Output
 //1,0,0,0,0,0,0,0,
 //1,0,0,0,0,0,0,0,
 //0,0,0,0,1,1,0,0,
 //0,0,0,0,1,1,0,0,
 //0,0,0,0,1,1,0,0,
 //0,0,0,0,0,0,0,0,
 //0,0,0,0,0,0,0,0,
 //0,0,0,0,0,0,0,0

Parameters

image: is orginal binary image.
mask: is structuring element.
handleBorders: is flag that determines whether image borders are handled with a padding technique. If this flag is false (the default), zeros are assumed outside of the image.

Returns

the binary image which is result of erosion

template<class ResultType, class T, class U>

PiiMatrix< ResultType > filter
(
- const PiiMatrix< T > & image
- const PiiMatrix & filter
- Pii::ExtendMode mode = Pii::ExtendReplicate
)
#include <PiiImage.h>

Filter an image with the given filter.
This is equivalent to PiiDsp::filter(), except for the mode parameter.
```
 // Gaussian low-pass filtering assuming zeros outside of the image.
 PiiMatrix<float> filtered = PiiImage::filter<float>(image,
 PiiImage::makeFilter<float>(PiiImage::GaussianFilter),
 Pii::ExtendZeros);
```
It is not a good idea to use unsigned char as the result type. If the filters are double, use double as the output type.
Parameters

image

the image to be filtered
filter

the filter
mode

"extension" mode, i.e. the way of handling border effects.
template<class ResultType, class T, class U>

PiiMatrix< ResultType > filter
(
- const PiiMatrix< T > & image
- const PiiMatrix & horizontalFilter
- const PiiMatrix & verticalFilter
- Pii::ExtendMode mode = Pii::ExtendReplicate
)
#include <PiiImage.h>

Filter an image with two one-dimensional filters.
If a two-dimensional filter can be decomposed into two one-dimensional ones, the filtering operation is much faster. Use separateFilter() to find the decomposition.
```
 // Convolution with a 23-by-23 filter is (informally) O(N * 23^2)
 // Convolution with two 23-by-1 filters is O(N * 23*2)
 // In theory, the processing time can go down to one 11th
 PiiMatrix<int> filter = PiiImage::makeFilter(PiiImage::UniformFilter, 23);
 PiiMatrix<int> hFilter, vFilter;
 PiiImage::separateFilter(filter, hFilter, vFilter);
 PiiMatrix<int> filtered = PiiImage::filter<int>(image, hFilter, vFilter);
```
It is not a good idea to use unsigned char as the result type. If the filters are double, use double as the output type.
Parameters

image

the image to be filtered
horizontalFilter

a row matrix representing the horizontal component of a decomposed filter
verticalFilter

a column matrix representing the vertical component of a decomposed filter
mode

"extension" mode, i.e. the way of handling border effects.

Returns

filtered image. If horizontalFilter is not a row vector or verticalFilter is not a column vector, a clone of the input image will be returned.
template<class ResultType, class ImageType>

PiiMatrix< ResultType > filter
(
- const PiiMatrix< ImageType > & image
- PrebuiltFilterType type
- Pii::ExtendMode mode = Pii::ExtendReplicate
- int filterSize = 3
)
#include <PiiImage.h>

Same as above, but filters the image with a named filter.
See makeFilter() for information about filter names. This function determines suitable data types for the filtering operation based on the filter type and decomposes the filter if possible.
```
 // First template parameter is the type of the result
 PiiMatrix<int> smoothed = PiiImage::filter<int>(image,
 PiiImage::GaussianFilter,
 Pii::ExtendSymmetric);
```
Parameters

image

input image
type

filter type
mode

how to handle image borders
filterSize

the size of the filter, ignored by some filter types

See also
- makeFilter()
template<class T>

PiiMatrix< float > gradientDirection
(
- const PiiMatrix< T > & gradX
- const PiiMatrix< T > & gradY
)
#include <PiiImage.h>

Calculate gradient angle from gradient magnitude components.
```
 using namespace PiiImage;
 PiiMatrix<float> directions = gradientDirection(filter(image, SobelXFilter),
 filter(image, SobelYFilter));
```
Parameters

gradX

horizontal gradient magnitude
gradY

vertical gradient magnitude

Returns

gradient angle for each pixel ( ), or an empty matrix if gradX and gradY are of different size.
template<class T>

PiiMatrix< T > gradientMagnitude
(
- const PiiMatrix< T > & gradX
- const PiiMatrix< T > & gradY
- bool fast = true
)
#include <PiiImage.h>

Calculate total gradient magnitude from gradient magnitude components.
```
 using namespace PiiImage;
 PiiMatrix<int> image; // construct somewhere
 // Use built-in filter masks directly
 PiiMatrix<int> magnitude = gradientMagnitude(filter<int>(image, sobelX), filter<int>(image, sobelY));
```
Parameters

gradX

horizontal gradient magnitude
gradY

vertical gradient magnitude
fast

a flag that determines whether a fast approximation is used (default is true). The real magnitude is (fast == false). In fast mode, the magnitude is approximated with .

Returns

gradient magnitude for each pixel, or an empty matrix if gradX and gradY are of different size.
template<class T, class Processor>

void handleRoiInput
(
- PiiInputSocket * input
- RoiType roiType
- const PiiMatrix< T > & image
- Processor & process
)
#include <PiiRoi.h>
template<class T, class U, class Roi>

PiiMatrix< T > histogram
(
- const PiiMatrix & image
- const Roi & roi
- const PiiQuantizer & quantizer
)
#include <PiiHistogram.h>

Calculate the histogram of a one-channel image.

The result will be a row matrix containing the frequencies of all values in the input image. The return type is determined by the T template parameter.

Parameters

image

the input image. All integer types are supported. If another type is used, each element is casted to an int in processing. The minimum value of the image must not be negative.
roi

region-of-interest. See PiiImage.
quantizer

a quantizer that converts image pixels into quantized values.
template<class T, class Roi>

PiiMatrix< int > histogram
(
- const PiiMatrix< T > & image
- const Roi & roi
- const PiiQuantizer< T > & quantizer
)
[inline]
#include <PiiHistogram.h>

Calculate the histogram of a one-channel image.

This is a shorthand for histogram<int>(image, quantizer).
template<class T, class Roi>

PiiMatrix< int > histogram
(
- const PiiMatrix< T > & image
- const Roi & roi
- unsigned int levels
)
[inline]
#include <PiiHistogram.h>

Calculate the histogram of a one-channel image.

This is a shorthand for histogram<int>(image, roi, levels).
template<class T>

PiiMatrix< int > histogram
(
- const PiiMatrix< T > & image
- const PiiQuantizer< T > & quantizer
)
[inline]
#include <PiiHistogram.h>

Calculate the histogram of a one-channel image.

This is a shorthand for histogram<int>(image, quantizer, PiiImage::DefaultRoi()).
template<class T, class U, class Roi>

PiiMatrix< T > histogram
(
- const PiiMatrix & image
- const Roi & roi
- unsigned int levels
)
#include <PiiHistogram.h>

Calculate the histogram of a one-channel image.

The result will be a row matrix containing the frequencies of all values in the input image. The return type is determined by the T template parameter.

Parameters

image

the input image. All integer types are supported. If another type is used, each element is casted to an int in processing. The minimum value of the image must not be negative.
roi

region-of-interest. See PiiImage.
levels

the number of distinct levels in the image. If zero is given, the maximum value of the image will be found. For 8 bit gray-scale images, use 256.

Returns

the histogram as a PiiMatrix<T>
template<class T>

PiiMatrix< int > histogram
(
- const PiiMatrix< T > & image
- unsigned int levels = 0
)
[inline]
#include <PiiHistogram.h>

Calculate the histogram of a one-channel image.

This is a shorthand for histogram<int>(image, PiiImage::DefaultRoi(), levels).

template<class T, class U>

PiiMatrix< T > hitAndMiss

(

const PiiMatrix< T > & image
const PiiMatrix & mask
const PiiMatrix & significance

)

#include <PiiMorphology.h>

Hit-and-miss transform.

The transform slides mask over all pixels in the input image. The mask is compared to image data only on the pixels that have the corresponding significance mask entry set to a non-zero value. The result is one if all such pixels match, and zero otherwise.

Locate north-east pointing corners in the image:

 PiiMatrix<int> image(5,5,
                      0,0,0,0,0,
                      0,1,1,1,0,
                      0,1,1,1,0,
                      0,1,1,1,0,
                      0,0,0,0,0);

 PiiMatrix<int> m(3,3
                  0,0,0,
                  1,1,0,
                  1,1,0),
 PiiMatrix<int> s(3,3
                  1,1,0,
                  1,1,1,
                  1,1,1)

 PiiMatrix<int> result = PiiImage::hitAndMiss(image, m, s);
 // Result equals to:
 // PiiMatrix<int> result(5,5,
 //                       0,0,0,0,0,
 //                       0,0,0,1,0,
 //                       0,0,0,0,0,
 //                       0,0,0,0,0,
 //                       0,0,0,0,0);

Parameters

image: input image
mask: structuring element
significance: "significance" mask for the structuring element. Non-zero values in this mask mark the pixels in structure that we should care about.

Returns

transformed image

template<class T>

PiiMatrix< int > hysteresisThreshold
(
- const PiiMatrix< T > & image
- T lowThreshold
- T highThreshold
- Connectivity connectivity = Connect8
)
[inline]
#include <PiiThresholding.h>

Perform hysteresis thresholding on image.

This is a convenience function that uses labelImage() to find connected components in which the gray level of all pixels is greater than or equal to lowThreshold and and at least one pixel is greater than or equal to highThreshold.

Parameters

image

a gray-level image
lowThreshold

low threshold value
highThreshold

high threshold value
connectivity

the type of connected components

Returns

a matrix in which all thresholded pixels are ones and others are zeros.
PII_IMAGE_EXPORT PiiMatrix< int > intFilter
(
- const PiiMatrix< int > & image
- const PiiMatrix< double > & doubleFilter
- Pii::ExtendMode mode = Pii::ExtendReplicate
- double scale = 0
)
#include <PiiImage.h>

Filters an integer image by a double-valued filter.
The filter is first scaled and rounded to integers. The image is then filtered with the integer-valued filter, and the result is rescaled. This is more efficient (and less accurate) than performing the convolution with doubles.
```
 PiiMatrix<int> filtered = PiiImage::intFilter(image, PiiImage::makeGaussian(5));
```
Beware of overflows! If the input image contains large entries and scale is not set carefully, the operation may easily overflow int.
Parameters

image

input image
doubleFilter

the filter
mode

how to deal with borders
scale

a scaling factor for the filter. If scale is zero, the function uses 256/max(abs(filter)).
PII_IMAGE_EXPORT PiiMatrix< int > intFilter
(
- const PiiMatrix< int > & image
- const PiiMatrix< double > & horizontalFilter
- const PiiMatrix< double > & verticalFilter
- Pii::ExtendMode mode = Pii::ExtendReplicate
- double scale = 0
)
#include <PiiImage.h>

Filters an integer image by a double-valued separable filter.

See intFilter() and filter() for details.

Beware of overflows! If the input image contains large entries and scale is not set carefully, the operation may easily overflow int.

Parameters

image

input image
horizontalFilter

horizontal component of a decomposed filter
verticalFilter

vertical component of a decomposed filter
mode

how to deal with borders
scale

a scaling factor for the filters. If scale is zero, the function uses 64/max(abs(filter)) for both.
template<class T>

PiiMatrix< T > inverseCut
(
- const PiiMatrix< T > & image
- T threshold
)
[inline]
#include <PiiThresholding.h>

Inversely cut gray levels.

Every pixel below threshold will be set to threshold.

See also
- InverseCutFunction
template<class T>

PiiMatrix< int > inverseHysteresisThreshold
(
- const PiiMatrix< T > & image
- T lowThreshold
- T highThreshold
- Connectivity connectivity = Connect8
)
[inline]
#include <PiiThresholding.h>

Inverse hysteresis thresholding.

Works inversely to hysteresisThreshold(): connected components in which all gray levels are below highThreshold and at least one gray level is below lowThreshold will be set to one. Note that the result is not the same as inverting the result of hysteresisThreshold().

Parameters

image

a gray-level image
lowThreshold

low threshold value
highThreshold

high threshold value
connectivity

the type of connected components

Returns

a matrix in which all thresholded pixels are ones and others are zeros.
template<class T>

PiiMatrix< T > inverseThreshold
(
- const PiiMatrix< T > & image
- T threshold
)
[inline]
#include <PiiThresholding.h>

Threshold and invert an image.

Parameters

image

original image.
threshold

gray level value for thresholding the original image

Returns

thresholded binary image

See also
- InverseThresholdFunction
template<class Matrix, class UnaryOp, class Limiter>

PiiMatrix< int > labelImage
(
- const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat
- UnaryOp rule
- Limiter limiter
- int * labelCount = 0
)
#include <PiiLabeling.h>

Label image using 4-connectivity.
This function uses the two-pass algorithm found in most computer vision textbooks.
```
 PiiMatrix<float> img;
 int iLabelCount = 0;
 // Every pixel with an intensity greater than 0.5 is an object.
 PiiImage::labelImage(img,
 std::bind2nd(std::greater<float>(), 0.5f),
 PiiImage::DefaultLabelingLimiter(),
 &iLabelCount));
```
Parameters

mat

a matrix to be labeled. All non-zero values are treated as objects.
rule

find objects by applying this unary predicate. All pixels to which op(pixel) returns true are treated as object pixels.
limiter

a template class that selects which objects to accept for labeling
labelCount

an optional output-value parameter that stores the number of labels found

Returns

a labeled image, whose maximum value equals to labelCount

See also
- DefaultLabelingLimiter
 ObjectSizeLimiter
template<class Matrix>

PiiMatrix< int > labelImage
(
- const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat
- int * labelCount = 0
)
#include <PiiLabeling.h>

Label image using 4-connectivity.

Parameters

mat

a matrix to be labeled. All non-zero values are treated as objects.
labelCount

an optional output-value parameter that stores the number of labels found

Returns

a labeled image, whose maximum value equals to labelCount
template<class Matrix, class UnaryOp1, class UnaryOp2>

PiiMatrix< int > labelImage
(
- const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat
- UnaryOp1 rule1
- UnaryOp2 rule2
- Connectivity connectivity
- int labelIncrement = 1
- int * labelCount = 0
)
#include <PiiLabeling.h>

Label connected components.
This function uses a recursive algorithm for finding connected components. It supports both 8-connected and 4-connected components. This function performs not only labeling but also hysteresis thresholding.
```
 PiiMatrix<bool> binaryImg;
 PiiMatrix<int> labels;
 // Label all 8-connected non-zero pixels
 labels = PiiImage::labelImage(binaryImg,
 std::bind2nd(std::equal_to<bool>(), true),
 std::bind2nd(std::equal_to<bool>(), true),
 PiiImage::Connect8);

 // Hysteresis thresholding:
 // Mark all 4-connected components whose gray levels are larger than
 // 50 and there is at least one pixel whose gray level is above 100.
 PiiMatrix<int> grayImg;
 labels = PiiImage::labelImage(grayImg,
 std::bind2nd(std::greater<int>(), 50),
 std::bind2nd(std::greater<int>(), 100),
 PiiImage::Connect4,
 0);
```
Parameters

mat

the matrix to be labeled
rule1

a unary predicate that determines if a pixel in mat is an object pixel candidate. A pixel candidate is not necessarily an object pixel unless at least one pixel in the object matches rule2.
rule2

a unary predicate that each connected component must meet at least once. If a connected component only has pixels that match rule1, it won't be labeled. If any of the pixels matches rule2, the whole component will be labeled.
connectivity

the connectivity type
labelIncrement

increment the label counter this much every time a new connected component is found. Set to zero to just mark all found objects with ones.
labelCount

an optional output value parameter that stores the maximum label. If labelIncrement is one, this value equals to the number of objects labeled.

See also
- hysteresisThreshold()
template<class Matrix>

PiiMatrix< int > labelLargerThan
(
- const PiiConceptualMatrix< Matrix, Pii::RandomAccessMatrix > & mat
- int sizeLimit
- int * labelCount = 0
)
#include <PiiLabeling.h>

Label all 4-connected objects whose size (in pixels) is larger than sizeLimit.

Parameters

mat

a matrix to be labeled. All non-zero values are treated as objects.
sizeLimit

only label objects larger than this. Smaller objects will be set to zero.
labelCount

an optional output-value parameter that stores the number of labels found

Returns

a labeled image, whose maximum value equals to labelCount
template<class T>

PiiMatrix< T > makeFilter
(
- PrebuiltFilterType type
- unsigned int size = 3
)
#include <PiiImage.h>

Create an image filter.
This function can be used to create well-known filters for many image processing tasks.

UniformFilter, GaussianFilter, and LoGFilter cannot be represented as integers. Use float or double as the data type.
```
 // Create a 5-by-5 gaussian filter
 PiiMatrix<double> filter = PiiImage::makeFilter<double>(PiiImage::GaussianFilter, 5);
```
Parameters

type

the type of the filter
size

the size of the filter. Some filters (Sobel, Roberts, Prewitt) are fixed in size, and this value will be ignored.

Returns

a square-shaped image filter matrix
PII_IMAGE_EXPORT PiiMatrix< double > makeGaussian
(
- unsigned int size
)
#include <PiiImage.h>

Create a size-by-size Gaussian low-pass filter.

Size must be odd. The filter is cut at approximately and normalized so that it sums up to unity.
PII_IMAGE_EXPORT PiiMatrix< double > makeLoGaussian
(
- unsigned int size
)
#include <PiiImage.h>

Create a size-by-size Laplacian-of-Gaussian filter.

Size must be odd. The filter is cut at approximately and normalized so that it sums up to zero.
template<class T>

PiiMatrix< T > medianFilter
(
- const PiiMatrix< T > & image
- int filterRows = 3
- int filterColumns = 0
- Pii::ExtendMode mode = Pii::ExtendZeros
)
#include <PiiImage.h>

Filters an image with a median filter.

Parameters

image

the input image
filterRows

filter size in vertical direction
filterColumns

filter size in horizontal direction. If this value is less than one, filterRows will be used instead.
mode

the method of handling image borders
template<class T, class U>

PiiMatrix< T > morphology
(
- const PiiMatrix< T > & image
- const PiiMatrix & mask
- MorphologyOperation type
- bool handleBorders = false
)
#include <PiiMorphology.h>

Perform a morphological operation on an image.

Parameters

image

is original binary image.
mask

structuring element
type

type of moprhological operation
handleBorders
template<class T, class U>

PiiMatrix< T > normalize
(
- const PiiMatrix & histogram
)
#include <PiiHistogram.h>

Normalize the given histogram so that its elements sum up to one.
If the matrix has many rows, each row is normalized. The return type may be different from the input type. Typically, float or double is used as the return type. If all values in a row equal to zero, they are left as such.
```
 PiiMatrix<int> histogram(1,4, 1,2,3,4);
 PiiMatrix<double> normalized(PiiImage::normalize<double>(histogram));
 //normalized = (0.1, 0.2, 0.3, 0.4)
```
template<class T, class U>

PiiMatrix< T > open
(
- const PiiMatrix< T > & image
- const PiiMatrix & mask
)
[inline]
#include <PiiMorphology.h>

Morphological opening.
template<class T>

int otsuThreshold
(
- const PiiMatrix< T > & histogram
)
#include <PiiThresholding.h>

The Otsu method is used in automatically selecting an optimal threshold.
The Otsu method works best with histograms that have two modes: dark objects on bright background or vice-versa.
```
 using namespace PiiImage;
 int iThreshold = otsuThreshold(normalize<float>(histogram(image)));
```
Parameters

histogram

normalized histogram

Returns

optimal threshold for separating the two modes
PII_IMAGE_EXPORT bool overlapping
(
- const PiiMatrix< int > & rectangles
)
#include <PiiRoi.h>

Returns true if any two of the given rectangles overlap each other and false otherwise.
template<class T>

int percentile
(
- const PiiMatrix< T > & cumulative
- T value
)
#include <PiiHistogram.h>

Find the index of the first entry in a cumulative frequency distribution that exceeds or equals to the given value.
For normalized cumulative distributions, value should be between 0 and 1.
```
 PiiMatrix<double> cumulative(1,4, 0.1, 0.3, 0.6, 1.0);
 int p = percentile(cumulative, 0.5);
 //p = 2
```
Parameters

cumulative

a cumulative frequency distribution. A row matrix with monotonically increasing values.
value

the percentile value, which should be smaller than or equal to the maximum value in cumulative.

Returns

the index of the first element exceeding or equal to value, or -1 if no such element was found
PII_DECLARE_EXPORTED_FUNCTION_TEMPLATE
(
- PiiMatrix< unsigned char >
- createMask< unsigned char >
- (MaskType type, int rows, int columns)
- PII_BUILDING_IMAGE
)
#include <PiiMorphology.h>

Create a morphological mask.

This version returns a 8-bit matrix.
template<class T, class U>

PiiMatrix< T > remap
(
- const PiiMatrix< T > & image
- const PiiMatrix< PiiPoint > & map
)
#include <PiiImage.h>

Transforms image according to the given coordinate map.

The size of the resulting image will be equal to the size of the map. Each pixel in the result image will be sampled from image according to map. For example, if map(0,0) is (1,2), the pixel at (0,0) in the result image will be taken from image(1,2). If the mapping would result in accessing image outside of its boundaries, the corresponding pixel in the result image will be left black. If the map coordinates are given as doubles, this function samples image using bilinear interpolation.
template<class T>

PiiMatrix< T > rotate
(
- const PiiMatrix< T > & image
- double theta
- TransformedSize handling = ExpandAsNecessary
- T backgroundColor = T(0)
)
#include <PiiImage.h>

Rotates image theta radians around its center.

Parameters

image

the image to be rotated
theta

rotation angle in radians. The angle grows clockwise, zero pointing to the right.
handling

clipping style.
backgroundColor

the color used for the parts of the output image that are outside of the input image.

Returns

rotated image
template<class T>

PiiMatrix< T > scale
(
- const PiiMatrix< T > & image
- int rows
- int columns
- Pii::Interpolation interpolation = Pii::LinearInterpolation
)
#include <PiiImage.h>

Scales image to a specified size.

Parameters

image

input image
rows

the number of pixel rows in the result image
columns

the number of pixel columns in the result image
interpolation

interpolation mode
template<class T>

PiiMatrix< T > scale
(
- const PiiMatrix< T > & image
- double scaleRatio
- Pii::Interpolation interpolation = Pii::LinearInterpolation
)
#include <PiiImage.h>

Scales image according to a scale ratio.

Parameters

image

input image
scaleRatio

scale ratio, which must be larger than zero.
interpolation

interpolation mode
template<class ColorType>

void separateChannels
(
- const PiiMatrix< ColorType > & image
- PiiMatrix< typename ColorType::Type > * channelImages
- int channels = 3
)
#include <PiiImage.h>

Split a color image into channels.

This function is equivalent to but faster than calling colorChannel() channels times in sequence.

Parameters

image

the color image to be split into channels
channelImages

an array of at least channels images. The images will be automatically resized to the size of the input image.
channels

the number of color channels to extract. Either three or four.
template<class T>

bool separateFilter
(
- const PiiMatrix< T > & filter
- PiiMatrix< T > & horizontalFilter
- PiiMatrix< T > & verticalFilter
)
#include <PiiImage.h>

Decompose a two-dimensional filter into two one-dimensional filters.
This function decomposes a matrix A into a row vector H and column vector V so that A = VH.
Decomposition is useful in speeding up convolution because one-dimensional convolution is much faster than two-dimensional, but not all filters are separable. Prominent examples of separable filters are the two-dimensional Gaussian function (the only separable, circularly symmetric filter), the Sobel filters, and the moving average filter. These can be created with the makeFilter() function using GaussianFilter, SobelXFilter, SobelYFilter, or UniformFilter as the filter type, respectively.
```
 PiiMatrix<int> filter = PiiImage::makeFilter<int>(PiiImage::SobelXFilter);
 PiiMatrix<int> h, v;
 PiiImage::separateFilter(filter, h, v);
 QVERIFY(filter.equals(v*h));
```
A filter with floating-point coefficients may not be separable if it is not stored accurately enough. This applies especially to the Gaussian filter.
```
 PiiMatrix<float> h, v;
 // Returns false, must use double as the data type
 PiiImage::separateFilter(PiiImage::makeFilter<float>(PiiImage::GaussianFilter), h, v);
```
Parameters

filter

a two-dimensional filter mask
horizontalFilter

the horizontal component of the decomposition, a row vector. Output-value parameter.
verticalFilter

the vertical component of the decomposition, a column vector. Output-value parameter.

Returns

true if the decomposition was successful, false otherwise.
template<class ColorType>

void setColorChannel
(
- PiiMatrix< ColorType > & image
- int channel
- const PiiMatrix< typename ColorType::Type > & values
)
#include <PiiImage.h>

Set a color channel.
This is a generic template that works with any color type. If the sizes of image and value do not match, the function does nothing.
```
 PiiMatrix<PiiColor4<> > image(5,5);
 PiiMatrix<unsigned char> red(5,5);
 red = 255;
 PiiImage::setColorChannel(image, 0, red);
```
Parameters

image

the color image
channel

index of the color channel to modify
values

new values for the channel
template<class ColorType>

void setColorChannel
(
- PiiMatrix< ColorType > & image
- int channel
- typename ColorType::Type value
)
#include <PiiImage.h>

Set a color channel to a constant value.
Works analogously to the above function but uses the same value for each pixel.
```
 PiiMatrix<PiiColor4<> > image(5,5);
 PiiImage::setColorChannel(image, 0, unsigned char(255));
```
template<class T>

PiiMatrix< T > shrink
(
- const PiiMatrix< T > & image
- int amount = 1
)
#include <PiiMorphology.h>

Remove object borders.

This operation is equivalent to subtracting border() from the original image.

Parameters

image

input image
amount

the number of iterations.

Returns

an image in which the borders of binary objects have been removed.
template<class ImageType, class SweepFunction>

SweepFunction sweepLine
(
- const PiiMatrix< ImageType > & image
- const PiiMatrix< double > & coordinates
- SweepFunction function
- int radius = 0
)
#include <PiiObjectProperty.h>

A Line sweeper.

Function goes through given segment of a line and sweeps line from both side going through line perpendicular vector. For each point which is inside of given radius, function calls type (note this is done also for line point) object operator(), with params point coordinates (x,y) and intensity.

Parameters

image

a gray-level image.
coordinates

is a row matrix which contains line segment begin and end point (x1,y1,x2,y2).
function

is a object which operator() is called with point coordinates (x,y) and intensity and which returns value which is saved in result matrix.
radius

is length of perpendicular vector.
template<class T>

PiiMatrix< T > thin
(
- const PiiMatrix< T > & image
- int amount = 1
)
#include <PiiMorphology.h>

Thin binary objects towards a skeleton.

Parameters

image

input image
amount

the number of iterations. On each iteration, one border pixel will be removed. If amount < 0, the operation loops until the binary objects have converged to one-pixel wide skeletons.

Returns

thinned image
template<class T>

PiiMatrix< T > threshold
(
- const PiiMatrix< T > & image
- T threshold
)
[inline]
#include <PiiThresholding.h>

Threshold an image.

Parameters

image

original image.
threshold

gray level value for thresholding the original image

Returns

thresholded binary image

See also
- ThresholdFunction
PiiMatrix< unsigned char > to8Bit
(
- const PiiMatrix< unsigned char > & image
)
[inline]
#include <PiiImage.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<class T>

PiiMatrix< unsigned char > to8Bit
(
- const PiiMatrix< T > & image
)
[inline]
#include <PiiImage.h>

Convert the gray values of an image to 8-bit gray.

The default implementation just casts the type.
PiiMatrix< unsigned char > to8Bit
(
- const PiiMatrix< float > & image
)
[inline]
#include <PiiImage.h>

Convert the gray values of an image to 8-bit gray.

This function multiplies floating-point gray values by 255.
PiiMatrix< float > toFloat
(
- const PiiMatrix< float > & image
)
[inline]
#include <PiiImage.h>

An explicit specialization of the toFloat() function.

Returns the argument without modifications.
template<class T>

PiiMatrix< float > toFloat
(
- const PiiMatrix< T > & image
)
[inline]
#include <PiiImage.h>

Convert the gray values of an image to floating point.

This function divides 8-bit gray levels by 255.
template<class T>

PiiMatrix< T > toGray
(
- const PiiMatrix< PiiColor4< T > > & image
)
[inline]
#include <PiiImage.h>
template<class T>

PiiMatrix< T > toGray
(
- const PiiMatrix< PiiColor< T > > & image
)
[inline]
#include <PiiImage.h>
template<class T>

const PiiMatrix< T > & toGray
(
- const PiiMatrix< T > & image
)
[inline]
#include <PiiImage.h>
template<class T, class U>

PiiMatrix< T > topHat
(
- const PiiMatrix< T > & image
- const PiiMatrix & mask
)
#include <PiiMorphology.h>

Top-hat transform.

Top-hat transform is an operation that extracts small bright elements from images. The top-hat transform is defined as the difference between the input image and its opening by a structuring element.
PII_IMAGE_EXPORT PiiMatrix< bool > toRoiMask
(
- const PiiVariant & obj
)
#include <PiiRoi.h>

Converts any integer matrix to a boolean matrix.

If obj is an invalid variant, an empty matrix will be returned.

Exceptions

PiiExecutionException&

if the type of the object is not suitable for a ROI.
template<class T>

PiiMatrix< T > transform
(
- const PiiMatrix< T > & image
- const PiiMatrix< float > & transform
- TransformedSize handling = ExpandAsNecessary
- T backgroundColor = T(0)
)
#include <PiiImage.h>

Applies an arbitrary geometric transform to image.

Homogeneous coordinates are used in calculations to allow simultaneous translations. Image coordinates are represented as a column vector . The transformed coordinates are obtained by , where A is the transformation matrix. For example, a transformation that rotates the image radians, is specified as follows:
Transformation matrices are most easily created by createRotationTransform(), createScalingTransform(), createTranslationTransform, and createShearingTransform(). Transformations can be chained by simply multiplying the transformation matrices. Assume R is a rotation transform and S is a shear transform. Shear after rotate transform is obtained with .

Parameters

image

the image to be transformed
transform

a 3-by-3 matrix specifying a geometric transform of original image coordinates to a new domain.
handling

clipping style.
backgroundColor

the color used for the parts of the output image that are outside of the input image.

Returns

the transformed image

Exceptions

PiiMathException&

if the transform matrix is invalid (singular) and cannot be inverted.
template<class T>

void transformHomogeneousPoint
(
- const PiiMatrix< T > & transform
- T sourceX
- T sourceY
- T * transformedX
- T * transformedY
)
#include <PiiImage.h>

Transforms a 2D point using transform.

The source point is represented in homogeneous coordinates; it is assumed that the third coordinate is one.

Parameters

transform

a 3-by-3 transformation matrix
sourceX

the x coordinate of the source point
sourceY

the y coordinate of the source point
transformedX

an output value argument that will store the transformed x coordinate.
transformedY

an output value argument that will store the transformed y coordinate.
template<class T, class U>

PiiMatrix transformHomogeneousPoints
(
- const PiiMatrix< T > & transform
- const PiiMatrix & points
)
#include <PiiImage.h>

Transforms 2D point coordinates using transform.

This function applies transformHomogeneousPoint() to all rows in points and returns the transformed points in a new matrix. points must have two columns.
template<class T>

PiiMatrix< T > unwarpCylinder
(
- const PiiMatrix< T > & warpedImage
- double focalLength = 1e100
- double center = NAN
- double * cameraDistance = 0
- double * radius = 0
- double * sectorAngle = 0
- double * startAngle = 0
)
#include <PiiImageDistortions.h>

Straighten an image that is wrapped around a cylinder.

Parameters

warpedImage

distorted input image. It is assumed that the optical axis of the camera is perpendicular to the surface of the cylinder and that the cylinder is vertical in the image (image is compressed towards left and right borders). The image must contain the full visible width of the cylinder and no background.
focalLength

the focal length of the camera. See Intrinsic Parameters for more information. Use a large value to approximate a telecentric lens.
center

the location of the optical center in the image. If the optical axis of the camera is perpendicular to the surface, it hits the cylider at its center, and the center of the cylinder is at the center of the image. If the center of the cylinder is not at the center of the image, the translation must be taken into account in the transformation. The location of the optical center is expressed in pixels so that the center of the leftmost pixel is at zero, and the center of the rightmost pixel at image width - 1. The default value (NaN) places the optical center at the center of the image.
cameraDistance

the physical distance between camera aperture and the cylinder center, in user-defined units. This is an input-output parameter. If cameraDistance is a null pointer or zero, it will be automatically calculated.
radius

an optional input/output parameter that specifies the physical radius of the cylinder, in the same units as cameraDistance. If radius is a null pointer or zero, it will be automatically calculated. If both cameraDistance and radius are zero, 100 will be used as the radius because both cannot be solved simultaneously.
sectorAngle

an optional input/output parameter. If this parameter is given and its value is positive, the value will be used as the maximum sector angle (in radians). If the value is smaller than the calculated angle of the visible sector, cylinder boundaries will be cut off. Upon return, the value will store the angle of the visible sector, or sectorAngle, whichever is smaller.
startAngle

an optional output-value parameter. If this value is non-zero, if the angle at which the left side of the sector is seen will be stored into the pointed memory. If the center of the cylinder is at optical axis, the minimum value is 0 (full 180 degrees visible). This value grows as sectorAngle decreases.

Returns

the image that was wrapped around a cylinder, as if it was straightened.
template<class T>

PiiMatrix< T > zeroAbove
(
- const PiiMatrix< T > & image
- T threshold
)
[inline]
#include <PiiThresholding.h>

Zero values above or equal to threshold.

See also
- ZeroAboveFunction
template<class T>

PiiMatrix< T > zeroBelow
(
- const PiiMatrix< T > & image
- T threshold
)
[inline]
#include <PiiThresholding.h>

Zero values below threshold.

See also
- ZeroBelowFunction

Variable details

PII_IMAGE_EXPORT PiiMatrix< int > borderMasks [8][2]
Masks for detecting border pixels in binary objects.
This array consists of eight masks suitable for use with the hitAndMiss() function. Each mask detects borders in one direction. The masks are numbered as follows:
- 0 - north
- 1 - north-east
- 2 - east
- 3 - south-east
- 4 - south
- 5 - south-west
- 6 - west
- 7 - north-west
borderMasks[X][0] is the detector and borderMasks[X][1] the corresponding significance mask.
PII_IMAGE_EXPORT PiiMatrix< int > prewittX

Predefined filter masks for the x and y components of the Prewitt edge finder.
PII_IMAGE_EXPORT PiiMatrix< int > prewittY
PII_IMAGE_EXPORT PiiMatrix< int > robertsX

Predefined filter masks for the x and y components of the Roberts edge finder.
PII_IMAGE_EXPORT PiiMatrix< int > robertsY
PII_IMAGE_EXPORT PiiMatrix< int > sobelX

Predefined filter masks for the x and y components of the Sobel edge finder.
PII_IMAGE_EXPORT PiiMatrix< int > sobelY

Notes (0)

Add a note

Not a single note added yet. Be the first, add yours.

Into

Modules

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Template parameters

Template parameters

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Specializations

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Template parameters

Specializations

Template parameters

Template parameters

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Template parameters

Specializations

Template parameters

Template parameters

Template parameters

Specializations

Template parameters

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Template parameters

Template parameters

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations

Template parameters

Specializations