Handbook of Computer Vision Algorithms in Image Algebra by Gerhard X Ritter; Joseph N Wilson CRC Press, CRC Press LLC ISBN: 0849326362 Pub Date: 05/01/96 Search Tips Advanced Search Search this book: invariant Preface Acknowledgments Title Chapter 1—Image Algebra 1.1 Introduction - 1.2 Point Sets 1.3 Value Sets 1.4 Images 1.5 Templates 1.6 Recursive Templates 1.7 Neighborhoods 1.8 The p-Product 1.9 References Chapter 2—Image Enhancement Techniques 2.1 Introduction 2.2 Averaging of Multiple Images 2.3 Local Averaging 2.4 Variable Local Averaging 2.5 Iterative Conditional Local Averaging 2.6 Max-Min Sharpening Transform 2.7 Smoothing Binary Images by Association 2.8 Median Filter 2.9 Unsharp Masking 2.10 Local Area Contrast Enhancement 2.11 Histogram Equalization 2.12 Histogram Modification 2.13 Lowpass Filtering 2.14 Highpass Filtering 2.15 References Chapter 3—Edge Detection and Boundary Finding Techniques 3.1 Introduction 3.2 Binary Image Boundaries 3.3 Edge Enhancement by Discrete Differencing 3.4 Roberts Edge Detector 3.5 Prewitt Edge Detector 3.6 Sobel Edge Detector 3.7 Wallis Logarithmic Edge Detection 3.8 Frei-Chen Edge and Line Detection 3.9 Kirsch Edge Detector 3.10 Directional Edge Detection 3.11 Product of the Difference of Averages 3.12 Crack Edge Detection 3.13 Local Edge Detection in Three-Dimensional Images 3.14 Hierarchical Edge Detection 3.15 Edge Detection Using K-Forms 3.16 Hueckel Edge Operator 3.17 Divide-and-Conquer Boundary Detection 3.18 Edge Following as Dynamic Programming 3.19 References Chapter 4—Thresholding Techniques 4.1 Introduction 4.2 Global Thresholding 4.3 Semithresholding 4.4 Multilevel Thresholding 4.5 Variable Thresholding 4.6 Threshold Selection Using Mean and Standard Deviation 4.7 Threshold Selection by Maximizing Between-Class Variance 4.8 Threshold Selection Using a Simple Image Statistic 4.9 References Chapter 5—Thining and Skeletonizing 5.1 Introduction 5.2 Pavlidis Thinning Algorithm 5.3 Medial Axis Transform (MAT) 5.4 Distance Transforms 5.5 Zhang-Suen Skeletonizing 5.6 Zhang-Suen Transform — Modified to Preserve Homotopy 5.7 Thinning Edge Magnitude Images 5.8 References Chapter 6—Connected Component Algorithms 6.1 Introduction 6.2 Component Labeling for Binary Images 6.3 Labeling Components with Sequential Labels 6.4 Counting Connected Components by Shrinking 6.5 Pruning of Connected Components 6.6 Hole Filling 6.7 References Chapter 7—Morphological Transforms and Techniques 7.1 Introduction 7.2 Basic Morphological Operations: Boolean Dilations and Erosions 7.3 Opening and Closing 7.4 Salt and Pepper Noise Removal 7.5 The Hit-and-Miss Transform 7.6 Gray Value Dilations, Erosions, Openings, and Closings 7.7 The Rolling Ball Algorithm 7.8 References Chapter 8—Linear Image Transforms 8.1 Introduction 8.2 Fourier Transform 8.3 Centering the Fourier Transform 8.4 Fast Fourier Transform 8.5 Discrete Cosine Transform 8.6 Walsh Transform 8.7 The Haar Wavelet Transform 8.8 Daubechies Wavelet Transforms 8.9 References Chapter 9—Pattern Matching and Shape Detection 9.1 Introduction 9.2 Pattern Matching Using Correlation 9.3 Pattern Matching in the Frequency Domain 9.4 Rotation Invariant Pattern Matching 9.5 Rotation and Scale Invariant Pattern Matching 9.6 Line Detection Using the Hough Transform 9.7 Detecting Ellipses Using the Hough Transform 9.8 Generalized Hough Algorithm for Shape Detection 9.9 References Chapter 10—Image Features and Descriptors 10.1 Introduction 10.2 Area and Perimeter 10.3 Euler Number 10.4 Chain Code Extraction and Correlation 10.5 Region Adjacency 10.6 Inclusion Relation 10.7 Quadtree Extraction 10.8 Position, Orientation, and Symmetry 10.9 Region Description Using Moments 10.10 Histogram 10.11 Cumulative Histogram 10.12 Texture Descriptors: Gray Level Spatial Dependence Statistics 10.13 References Chapter 11—Neural Networks and Cellular Automata 11.1 Introduction 11.2 Hopfield Neural Network 11.3 Bidirectional Associative Memory (BAM) 11.4 Hamming Net 11.5 Single-Layer Perceptron (SLP) 11.6 Multilayer Perceptron (MLP) 11.7 Cellular Automata and Life 11.8 Solving Mazes Using Cellular Automata 11.9 References Appendix A Index Products | Contact Us | About Us | Privacy | Ad Info | Home Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc All rights reserved Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited Read EarthWeb's privacy statement Handbook of Computer Vision Algorithms in Image Algebra by Gerhard X Ritter; Joseph N Wilson CRC Press, CRC Press LLC ISBN: 0849326362 Pub Date: 05/01/96 Search Tips Search this book: Advanced Search Table of Contents Title - Preface The aim of this book is to acquaint engineers, scientists, and students with the basic concepts of image algebra and its use in the concise representation of computer vision algorithms In order to achieve this goal we provide a brief survey of commonly used computer vision algorithms that we believe represents a core of knowledge that all computer vision practitioners should have This survey is not meant to be an encyclopedic summary of computer vision techniques as it is impossible to justice to the scope and depth of the rapidly expanding field of computer vision The arrangement of the book is such that it can serve as a reference for computer vision algorithm developers in general as well as for algorithm developers using the image algebra C++ object library, iac++.1 The techniques and algorithms presented in a given chapter follow a progression of increasing abstractness Each technique is introduced by way of a brief discussion of its purpose and methodology Since the intent of this text is to train the practitioner in formulating his algorithms and ideas in the succinct mathematical language provided by image algebra, an effort has been made to provide the precise mathematical formulation of each methodology Thus, we suspect that practicing engineers and scientists will find this presentation somewhat more practical and perhaps a bit less esoteric than those found in research publications or various textbooks paraphrasing these publications 1The iac++ library supports the use of image algebra in the C++ programming language and is available for anonymous ftp from ftp://ftp.cis.ufl.edu/pub/src/ia/ Chapter provides a short introduction to field of image algebra Chapters 2-11 are devoted to particular techniques commonly used in computer vision algorithm development, ranging from early processing techniques to such higher level topics as image descriptors and artificial neural networks Although the chapters on techniques are most naturally studied in succession, they are not tightly interdependent and can be studied according to the reader’s particular interest In the Appendix we present iac++ computer programs of some of the techniques surveyed in this book These programs reflect the image algebra pseudocode presented in the chapters and serve as examples of how image algebra pseudocode can be converted into efficient computer programs Table of Contents Products | Contact Us | About Us | Privacy | Ad Info | Home Use of this site is subject to certain Terms & Conditions, Copyright © 1996-2000 EarthWeb Inc All rights reserved Reproduction whole or in part in any form or medium without express written permission of EarthWeb is prohibited Read EarthWeb's privacy statement Handbook of Computer Vision Algorithms in Image Algebra by Gerhard X Ritter; Joseph N Wilson CRC Press, CRC Press LLC ISBN: 0849326362 Pub Date: 05/01/96 Search Tips Search this book: Advanced Search Table of Contents Title - Acknowledgments We wish to take this opportunity to express our thanks to our current and former students who have, in various ways, assisted in the preparation of this text In particular, we wish to extend our appreciation to Dr Paul Gader, Dr Jennifer Davidson, Dr Hongchi Shi, Ms Brigitte Pracht, Mr Mark Schmalz, Mr Venugopal Subramaniam, Mr Mike Rowlee, Dr Dong Li, Dr Huixia Zhu, Ms Chuanxue Wang, Mr Jaime Zapata, and Mr Liang-Ming Chen We are most deeply indebted to Dr David Patching who assisted in the preparation of the text and contributed to the material by developing examples that enhanced the algorithmic exposition Special thanks are due to Mr Ralph Jackson, who skillfully implemented many of the algorithms herein, and to Mr Robert Forsman, the primary implementor of the iac++ library We also want to express our gratitude to the Air Force Wright Laboratory for their encouragement and continuous support of image algebra research and development This book would not have been written without the vision and support provided by numerous scientists of the Wright Laboratory at Eglin Air Force Base in Florida These supporters include Dr Lawrence Ankeney who started it all, Dr Sam Lambert who championed the image algebra project since its inception, Mr Nell Urquhart our first program manager, Ms Karen Norris, and most especially Dr Patrick Coffield who persuaded us to turn a technical report on computer vision algorithms in image algebra into this book Last but not least we would like to thank Dr Robert Lyjack of ERIM for his friendship and enthusiastic support during the formative stages of image algebra Notation The tables presented here provide a brief explantation of the notation used throughout this document The reader is referred to Ritter [1] for a comprehensive treatise covering the mathematics of image algebra Logic Symbol pỊq pƠq Explanation “p implies q.” If p is true, then q is true “p if and only if q,” which means that p and q are logically equivalent iff ¬ “if and only if” “not” “there exists” “there does not exist” “for each” “such that” s.t Sets Theoretic Notation and Operations Symbol X, Y, Z x, y, z X, Y, Z x, y, z Explanation Uppercase characters represent arbitrary sets Lowercase characters represent elements of an arbitrary set Bold, uppercase characters are used to represent point sets Bold, lowercase characters are used to represent points, i.e., elements of point sets The set = {0, 1, 2, 3, } The set of integers, positive integers, and negative integers The set = {0, 1, , n - 1} The set = {1, 2, , n} The set = {-n+1, , -1, 0, 1, , n - 1} The set of real numbers, positive real numbers, negative real numbers, and positive real numbers including The set of complex numbers An arbitrary set of values The set unioned with {} The set unioned with {} The set unioned with {-,} The empty set (the set that has no elements) The power set of X (the set of all subsets of X) “is an element of” “is not an element of” “is a subset of” 2X Union X * Y = {z : z X or z Y} Let be a family of sets indexed by an indexing set › for at least one » ›} = {x : x X» = X1 * X2 * * Xn = {x : x Xi for some i X Y } Intersection X ) Y = {z : z X and z Y} Let for all » ›} be a family of sets indexed by an indexing set › = X1 ) X2 ) ) Xn = {x : x X» = {x : x Xi for all i X×Y } Cartesian product X × Y {(x, y) : x X, y Y} = {(x1,x2, ,xn) : xi Xi} = {(x1,x2,x3, ) : xi Xi} X\Y X2 card(X) choice(X) The Cartesian product of n copies of , i.e., Set difference Let X and Y be subsets of some universal set U, X \ Y = {x X : x Y} Complement X2 = U \ X, where U is the universal set that contains X The cardinality of the set X A function that randomly selects an element from the set X Point and Point Set Operations Symbol Explanation x+y If x, y , then x + y = (x1 + y1, , xn + yn) x-y If x, y , then x - y = (x1 - y1, , xn - yn) x·y If x, y , then x · y = (x1y1, , xnyn) x/y If x, y , then x/y = (x1/y1, , xn/yn) x¦y If x, y , then x ¦ y = (x1 Ư y1, , xn Ư yn) xƠy If x, y , then x ¥ y = (x1 ¥ y1, , xn ¥ yn) x³y In general, if x, y k³x If k x"y If x, y , then x"y = x1y1 + x2y2 + ··· + xnyn x×y If x, y , then x × y = (x2y3 - x3y2, x3y1 - x1y3, x1y2 - x2y1) and x , and = (x1³y1, , xn³yn) and , then k³x = (k³x1, , k³xn) If x and y then = (x1, , xn, y1, , ym) -x If x , then -x = (-x1, , -xn) x If x , then If x x If x , then x = ( x1, , xn) [x] If x , then [x] = ([x1], , [xn]) pi(x) If x = (x1, x2, , xn) £x If x , then £x = x1 + x2 + ··· + xn x If x , then x = x1x2 ··· xn ¦x If x , then ¦x = x1 ¦ x2 ¦ ··· ¦ xn ¥x If x , then ¥x = x1 ¥ x2 ¥ ··· ¥ xn , then x = ( x1, , xn) , then pi (x) = xi ||x||2 If x , then ||x||2 = ||x||1 If x , then ||x||1 = |x1| + |x2| + ··· + |xn| ||x|| If x , then ||x|| = |x1| ¦ |x2| ¦ ··· ¦ |xn| dim(x) If x , then dim(x) = n X+Y If X, Y , then X + Y = {x + y : x X and y Y} X-Y If X, Y , then X - Y = {x - y : x X and y Y} X+p If X , then X + p = {x + p : x X} X-p If X , then X - p = {x - p : x X} X*Y If X, Y , then X * Y = {z : z X or z Y} X\Y If X, Y , then X\Y = {z : z X and z Y} X”Y If X, Y , then X ” Y = {z : z X * Y and z X ) Y} X×Y If X, Y , then X × Y = {(x, y) : x X and y Y} -X If X , then -X = {-x : x X} If X , then sup(X) X = {z : z and z X} , then sup(X) = the supremum of X If X = {x1, x2, , xn }, then sup(X) = x1 If X ¦ x2 ¦ ¦ xn For a point set X with total order inf(X) X , x0 = card(X) x0, x X \ {x0} If X , then inf(X) = the infimum of X If X = {x1, x2, , xn}, , then sup(X) = x1 ¥ x2 ¥ ¥ xn For a point set X with total order choice(X) XÔx , x0 = X Ô x0 x, x X \ {x0} If X then, choice(X) X (randomly chosen element) If X , then card(X) = the cardinality of X Morphology In following table A, B, D, and E denote subsets of Symbol Explanation A* The reflection of A across the origin = (0, 0, 0) A2 The complement of A; i.e., A2 = {x Ab = {a + b : a A} Ab A×B A/B A B A"B A C : x A} Minkowski addition is defined as A × B = {a + b : a A, b B} (Section 7.2) Minkowski subtraction is defined as A/B = (A2 × B*)2 (Section 7.2) The opening of A by B is denoted A B and is defined by A B = (A/B) × B (Section 7.3) The closing of A by B is denoted A " B and is defined by A " B = (A × B)/B (Section 7.3) Let C = (D, E) be an ordered pair of structuring elements The hit-and-miss transform of the set A is given by A C = {p : Dp A and Ep A2} (Section 7.5) Functions and Scalar Operations Symbol Explanation // with a 3x3 neighborhood // #include "math.h" #include "ia/UcharDI.h" #include "ia/IntDI.h" #include "ia/Nbh.h" #include "ia/UcharNOps.h" u_char average (u_char *uchar_vector, unsigned num) { if (0 == num) { return 0; } else { int sum = 0; for (int i = 0; i < num; i++) { sum += uchar-vector[i]; } return u_char (irint (float (sum) / num)); } } int main(int argc, char **argv) { IA_Image source_image = read_uchar_PGM (cin); IA_Neighborhood box (2, IA_boxy_pset (IA_Point (-1, -1), IA_Point (1, 1))); // // Reduction with sum and division by nine yields a boundary // effect at the limits of the image point set due to the // lack of nine neighbors // display (to_uchar (sum (source_image, box) / 9)); // // Reduction with the n-ary average function correctly // generates average values even at the boundary // display (neighborhood_reduction (source_image, box, source_image.domain(), average)); } Example Hough Transform main.c // // // // // // // // // example1.c Averaging Multiple Images usage: example1 file-1.pgm [file2.pgm file-n.pgm] Read a sequence of images from files and average them Display the result Assumes input files are pgm images all having the same pointset and containing unsigned char values // #include "ia/IntDI.h" #include "ia/UcharDI.h" #include "ia/IntNOps.h" // integer valued images // unsigned character images // neighborhood operations #include "hough.h" // Hough transform functions int main(int argc, char **argv) { IA_Image source = read_int_PGM (argv[1]); IA_Image result; IA_Set accumulator_domain = source.domain(); // // Initialize parameters for the Hough Neighborhood // hough_initialize (source.domain(), accumulator_domain); IA_Neighborhood hough_nbh (accumulator_domain, hough_function); IA_Image accumulator; display (to_uchar (source * 255 / max(source))); // // Map feature points to corresponding locations // in the accumulator array // accumulator = sum (source, hough_nbh, accumulator_domain); display (to_uchar(accumulator * 255 / max(accumulator))); // // Threshold the accumulator // accumulator = to_int(chi_eq (accumulator, max(accumulator))); display (to_uchar(accumulator*255)); restrict (accumulator, IA_Set(1)); // // Map back to see the corresponding lines in the //source domain // result = sum (hough_nbh, accumulator, source.domain()); display (to_uchar(result * 255 / max(result))); } hough.h // hough.h // // Copyright 1995, Center for Computer Vision and Visualization, // University of Florida All rights reserved #ifndef _hough_h_ #define _hough-h_ #include "ia/Nbh.h" #include "ia/IntPS.h" void hough_initialize (IA_Set image_domain, IA_Set accumulator_domain); IA_Set hough_function (const IA_Point &r_t); // // // // // // // // // // // // // // // // // // Accomplish the Hough Transform as follows: Given a binary image 'Source' containing linear features Call hough-initialize with first argument Source.domain() and with second argument being the accumulator domain (an r by t set of points with r equal to the number of accumulator cells for rho and t equal to the number of accumulator sells for theta) Create an IA_Neighborhood as follows: IA_Neighborhood HoughNbh (AccumulatorDomain, hough_function); Then calculate the Hough Transform of a (binary) image as follows: Accumulator = sum (Source, HoughNbh); #endif hough.c // hough.c // // Copyright 1995, Center for Computer Vision and Visualization, // University of Florida All rights reserved #include "hough.h" #include "math.h" #include static const double HoughPi = atan(1.0)*4.0; static double *HoughCos; static double *HoughSin; static static static static static static // int RhoCells; int ThetaCells; IA_Point IterationMin; IA_Point IterationMax; IA_Point ImageSize; IA_Point Delta; // hough_initialize: // // Initializes parameters for HoughFunction to allow a neighborhood // to be created for given image and accumulator image point sets // void hough_initialize (IA_Set image_domain, IA_Set accumulator_domain) { // // Check to make sure the image domain and accumulator domain // are both dimensional rectangular point sets // if (!image_domain.boxy() || !accumulator_domain.boxy() || image_domain.dim != || accumulator_domain.dim != 2) { cerr