regiongrowing_n__ ( MultiChannelImage : Regions : Metric, MinTolerance, MaxTolerance, MinSize, NumberOfChannels : )

Regiongrowing for multi-channel images.

regiongrowing_n__ performs a multi-channel regiongrowing. The n channels of NumberOfChannels give rise to an n-dimensional feature vector. Neighboring points are aggregated into the same region if the difference of their feature vectors with respect to the given metric lies in the interval [MinTolerance, MaxTolerance]. Only 4-connected neighbors are examined. The following metrics can be used:

Let g_{A} denote the gray value in the feature vector A at point a of the image, and likewise be g_{B} the gray value in the feature vector B at point a neighboring point b. Let g(d) be the gray value with index d. Furthermore, let MinT denote MinTolerance and MaxT denote MaxTolerance.

  'Betrag1AbsZw'
                 Sum of absolute values
                               ----
                           1   \
                 MinT <=   - * /    |gA - gB|  <= MaxT
                           n   ----

  'Betrag2AbsZw'
                 Euclidian distance
                            ---------------------
                            |     ----
                            | 1   \             2
                 MinT <=  \ | - * /    (gA - gB)   <= MaxT
                           \| n   ----

  'Betrag3AbsZw'
                 p - Norm with p = 3
                            ---------------------
                            |     ----
                          3 | 1   \             3
                 MinT <=  \ | - * /    (gA - gB)   <= MaxT
                           \| n   ----

  'Betrag4AbsZw'
                 p - Norm with p = 4
                            ---------------------
                            |     ----
                          4 | 1   \             4
                 MinT <=  \ | - * /    (gA - gB)   <= MaxT
                           \| n   ----

  'BetragNAbsZw'
                 Minkowski distance
                            ---------------------
                            |     ----
                          n | 1   \             n
                 MinT <=  \ | - * /    (gA - gB)   <= MaxT
                           \| n   ----


  'MaxAbsZw'
                 Supremum distance
                 MinT <= max { |gA - gB| } <= MaxT

  'MinAbsZw'
                 Infimum distance
                 MinT <= min { |gA - gB| } <= MaxT

  'VarAbsZw'
                 Variance of gray value differences
                 X = gA - gB,
                 MinT <= Var(X) <= MaxT

  'Skalarprodukt'
                 Dot product
                                ------------------
                                |     ----
                          1     | 1   \
                 MinT <=  - * \ | - * /    gA * gB  <= MaxT
                          n    \| n   ----

  'Korrelierung'
                 Correlation
                            ----
                        1   \
                 SA   = - * /    gA ,
                        n   ----

                              -----------------
                              | ----
                        1     | \             2
                 VarA = - * \ | /    (gA - SA)  ,
                        n    \| ----

                            ----
                        1   \
                 SB =   - * /    gB ,
                        n   ----

                              -----------------
                              | ----
                        1     | \             2
                 VarB = - * \ | /    (gB - SB)  ,
                        n    \| ----

                          1    ----
                          -- * \    (gA - SA)*(gB - SB)
                 MinT <=   2   /    -------------------  <= MaxT
                          n    ----     VarA * VarB

  'Laenge1AbsIn'
                 Difference of arithmetic means
                         ----
                     1   \
                 a = - * /    gA ,
                     n   ----

                         ----
                     1   \
                 b = - * /    gB ,
                     n   ----

                 MinT <= |a - b| <= MaxT

  'Laenge1RelIn'
                 Quotient of arithmetic means
                         ----
                     1   \
                 a = - * /    gA ,
                     n   ----

                         ----
                     1   \
                 b = - * /    gB ,
                     n   ----

                 MinT <= min { a/b, b/a } <= MaxT

  'Laenge2AbsIn'
                 Difference of the vector lengths
                       ---------------
                       |     ----
                       | 1   \       2
                 a = \ | - * /     gA  ,
                      \| n   ----

                       ---------------
                       |     ----
                       | 1   \       2
                 b = \ | - * /     gB  ,
                      \| n   ----

                 MinT <= |a - b| <= MaxT

  'Laenge2RelIn'
                  Quotient of the vector lengths
                       ---------------
                       |     ----
                       | 1   \       2
                 a = \ | - * /     gA  ,
                      \| n   ----

                       ---------------
                       |     ----
                       | 1   \       2
                 b = \ | - * /     gB  ,
                      \| n   ----

                 MinT <= min { a/b, b/a } <= MaxT

  'LaengeNRelIn'
                 Quotient of the vector lengths w.r.t the p-norm with p = n
                       ---------------
                       |     ----
                     n | 1   \       n
                 a = \ | - * /     gA  ,
                      \| n   ----

                       ---------------
                       |     ----
                     n | 1   \       n
                 b = \ | - * /     gB  ,
                      \| n   ----

                 MinT <= min { a/b, b/a } <= MaxT

  'MaxAbsInAllg'
                 Difference of the maximum gray values
                 a = max { |gA| },
                 b = max { |gB| },
                 MinT <= |a - b| <= MaxT

  'MaxRelInAllg'
                 Quotient of the maximum gray values
                 a = max { |gA| },
                 b = max { |gB| },
                 MinT <= min { a/b, b/a } <= MaxT

  'MinAbsInAllg'
                 Difference of the minimum gray values
                 a = min { |gA| },
                 b = min { |gB| },
                 MinT <= |a - b| <= MaxT

  'MinRelInAllg'
                 Quotient of the minimum gray values
                 a = min { |gA| },
                 b = min { |gB| },
                 MinT <= min { a/b, b/a } <= MaxT

  'VarAbsIn'
                 Difference of the variances over all gray values (channels)
                 MinT <= | Var(gA) - Var(gB) | <= MaxT

  'VarRelIn'
                 Quotient of the variances over all gray values (channels)
                 MinT <= Var(gB) / Var(gA) <= MaxT

  'BetSumAbsIn'
                 Difference of the sum of absolute values over all
                 gray values (channels)
                     ----
                     \
                 a = /    |gA(d) - gA(k)|
                     ----
                    d,k,k<d

                     ----
                     \
                 b = /    |gB(d) - gB(k)|
                     ----
                    d,k,k<d

                 MinT <= 1/z * |a - b| <= MaxT,  z = Anzahl der Summen

  'BetSumRelIn'
                 Quotient of the sum of absolute values over all
                 gray values (channels)
                     ----
                     \
                 a = /    |gA(d) - gA(k)|
                     ----
                    d,k,k<d

                     ----
                     \
                 b = /    |gB(d) - gB(k)|
                     ----
                    d,k,k<d

                 MinT <= min { a/b, b/a } <= MaxT

  'MaxAbsIn'
                 Difference of the maximum distance of the components
                 a = max { gA(d), gA(k) },
                 b = max { gB(d), gB(k) },
                 MinT <= |a - b| <= MaxT

  'MaxRelIn'
                 Quotient of the maximum distance of the components
                 a = max { gA(d), gA(k) },
                 b = max { gB(d), gB(k) },
                 MinT <= min { a/b, b/a } <= MaxT

  'MinAbsIn'
                 Difference of the minimum distance of the components
                 a = min { gA(d), gA(k) }, k < d
                 b = min { gB(d), gB(k) }, k < d
                 MinT <= |a - b| <= MaxT

  'MinRelIn'
                 Quotient of the minimum distance of the components
                 a = min { gA(d), gA(k) }, k < d
                 b = min { gB(d), gB(k) }, k < d
                 MinT <= min { a/b, b/a } <= MaxT

  'Ebene'
                 The following has to hold for all d1,d2 in [1,n]:
                 gA(d1) > gA(d2) ==> gB(d1) > gB(d2),
                 gA(d1) < gA(d2) ==> gB(d1) < gB(d2)
Regions with less than MinSize are suppressed.


Parameters

MultiChannelImage (input_object)
image(-array) -> object : byte
Multi-channel image to be segmented.

Regions (output_object)
region-array -> object
Segmented regions.

Metric (input_control)
string -> string
Metric for the distance of the feature vectors.
Default value: 'Betrag2AbsZw'
List of values: 'Betrag1AbsZw', 'Betrag2AbsZw', 'Betrag3AbsZw', 'Betrag4AbsZw', 'BetragNAbsZw', 'MaxAbsZw', 'MinAbsZw', 'VarAbsZw', 'Skalarprodukt', 'Korrelierung', 'Laenge1AbsIn', 'Laenge1RelIn', 'Laenge2AbsIn', 'Laenge2RelIn', 'LaengeNRelIn', 'MaxAbsInAllg', 'MaxRelInAllg', 'MinAbsInAllg', 'MinRelInAllg', 'VarAbsIn', 'VarRelIn', 'BetSumIn', 'BetSumRelIn', 'MaxAbsIn', 'MaxRelIn', 'MinAbsIn', 'MinRelIn', 'Ebene'

MinTolerance (input_control)
number -> real / integer
Lower threshold for the features' distance.
Default value: 0.0
Suggested values: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 25.0, 30.0
Range of values: 0.0 <= MinTolerance <= 255.0 (lin)
Minimum increment: 0.01
Recommended increment: 1.0

MaxTolerance (input_control)
number -> real / integer
Upper threshold for the features' distance.
Default value: 20.0
Suggested values: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 25.0, 30.0
Range of values: 0.0 <= MaxTolerance <= 255.0 (lin)
Minimum increment: 0.01
Recommended increment: 1.0

MinSize (input_control)
integer -> integer
Minimum size of the output regions.
Default value: 30
Suggested values: 1, 10, 25, 50, 100, 200, 500, 1000
Range of values: 1 <= MinSize <= 10000 (lin)
Minimum increment: 1
Recommended increment: 5

NumberOfChannels (input_control)
integer -> integer
Number of gray channels.
Default value: 3
Suggested values: 2, 3, 4, 5, 6, 7, 8, 9
Range of values: 2 <= NumberOfChannels
Restriction: NumberOfChannels > 1


Result

regiongrowing_n__ returns TRUE if all parameters are correct. The behaviour with respect to the input images and output regions can be determined by setting the values of the flags 'no_object_result', 'empty_region_result', and 'store_empty_region' with set_system. If necessary, an exception is raised.


Possible Predecessors

compose2, compose3


Alternatives

class_2dim__, class_ndim1__, class_ndim2__


See also

regiongrowing__



Copyright © 1996-1997 MVTec Software GmbH