Expressing imaging algorithms using a C++ based image algebra programming environment

Rochester Institute of Technology

RIT Scholar Works

Theses

Thesis/Dissertation Collections

4-18-1990

Expressing imaging algorithms using a C++ based

image algebra programming environment

Davender Nath Gupta

Follow this and additional works at:

http://scholarworks.rit.edu/theses

This Thesis is brought to you for free and open access by the Thesis/Dissertation Collections at RIT Scholar Works. It has been accepted for inclusion

in Theses by an authorized administrator of RIT Scholar Works. For more information, please contact

[email protected]

.

Recommended Citation

EXPRESSING IMAGING ALGORITHMS

USING A C++ BASED

IMAGE ALGEBRA PROGRAMMING ENVIRONMENT

by

D~vender

Nath Gupta

Captain, Canadian Forces

B.Eng. Royal Military College of Canada

(1984)

A

th~sis

submitted in partial fulfillment

of the requirements for the degree of

Master of Science in the Center for

Imaging Science in the College of

Graphic Arts and Photography of the

Rochester Institute of Technology

18 April 1990

Signature of the Author

_D_a_v_a_nd_e_r_N_at_h_G_u-'-p_ta

_

Accepted by

M_en~d_i_Va_e_z_-P_ra_v_a_ni~

_

COLLEGE OF GRAPHIC ARTS AND PHOTOGRAPHY

ROCHESTER INSTITUTE OF TECHNOLOGY

ROCHESTER, NEW YORK

CERTIFICATE OF APPROVAL

M.S. DEGREE THESIS

The M.S. Degree Thesis of Davender Nath Gupta

has been examined and approved

by the thesis committee as satisfactory

for the thesis requirement for the

Master of Science degree

Dr. Edward

R.

Dougherty, Thesis Advisor

Dr. Peter O. Anderson

Dr. Harvey Rhody

Title of Thesis:

THESIS RELEASE PERMISSION FORM

ROCHESTER INSTITUTE OF TECHNOLOGY

COLLEGE OF GRAPHIC ARTS AND PHOTOGRAPHY

EXPRESSING IMAGING ALGORITHMS USING A C++ BASED

IMAGE ALGEBRA PROGRAMMING ENVIRONMENT

I. Davender Nath Gupta, hereby grant permission to the Wallace Memorial Ubrary of

R.I.T.

to

reproduce my thesis in whole or in part. Any reproduction will not be for commercial use or profit.

EXPRESSING IMAGING ALGORITHMS USING

A

C++

BASED

IMAGE ALGEBRA PROGRAMMING

ENVIRONMENT

by

Davender Nath Gupta

Submittedto the Center for

Imaging

Science in partialfulfillmentoftherequirements

forthedegreeofMasterofScience

atthe Rochester Instituteof

Technology

ABSTRACT

Homogeneous Image Algebra isused asthebasis foran_{image processing}environment

thatusesthe

image,

insteadofthepixel, asthefundamentalunit

being

manipulated. The

object-orientedlanguageC++isusedtoimplementtheenvironment. Examplesofapplications arethat

include

filtering,

regiongrowing, skeletonization,Fourier TransformsandHadamard transforms

are presented. ThisthesisconcludesthatC++does haveseveralfeatureswhichareof great

ACKNOWLEDGEMENTS

Thisworkhas beenmade possiblethrough thesupport oftheCanadian Forces.

Iwishto thankDr. Edward

Dougherty,

whofirstsuggested _mythesistopic. Workonthis

problem allowed metobecomecomfortablein

Pascal, C,

and

C++,

as well aswith

UNIX,

thus

keeping

mycomputer skills_uptodate

(and

_givingmetwoexcusestogotoLA!).

I also wishtoacknowledgethevaluable assistance ofthedepartmentofComputer

Scienceand Information

Technology

at

RIT,

and_{specifically Dr. Peter}

Anderson,

whoprovided

DEDICATION

TABLE

OF CONTENTS

TABLE OF CONTENTS vii

CHAPTER 1

-INTRODUCTION 1-1

AIM OF THESIS 1

Aimofthesis 1

PROBLEM STATEMENT 1

Background 1

Problem 1

CHAPTER 2

-PREVIOUS WORK 2-1

GENERAL 1

Chapter Objective 1

IMAGE ALGEBRA 1

Context 1

Originofimagealgebra 1

COMPUTER IMPLEMENTATIONS OF IMAGEALGEBRA 2

General 2

AFATL Image Algebra 2

C-3PL 3

SLIP 4

Otherimplementations 4

CONCLUSION 5

CHAPTER 3- _{GENERAL DESIGN 3-1}

GENERAL

Chapter Objective USERS

Intended audience and uses

Level of user sophistication

Hardware and Software

DESIGN QUALITIES 2

CHOICE OF MATHEMATICAL BASIS 2

Conclusion 3

USER INTERFACE 4

General 4

Blockdiagrams 4

Alphanumeric expressions 5

Conclusion 6

IMPLEMENTATION STYLES 6

Programming

Styles 6

Procedural approach 6

Object-oriented approach 6

Conclusion 8

LIBRARYVS. LANGUAGE 8

Desired characteristicsoffinal system 8

Implementation approach 8

Conclusion 9

SELECTION OF A HOSTLANGUAGE 9

General 9

Pascal 9

FORTRAN 1 1

ANSIC 1 2

C++ 1 4

Conclusion 1 6

GENERAL DESIGN 16

CHAPTER 4- _{IMPLEMENTATION} 4-1

GENERAL 1

Chapter Objective 1

Notation Conventions 1

FEATURES 2

General 2

oopsSlip Class

Library

2

Preprocessor 2

DERIVED TYPE CLASSES 2

General 2

Byte 2

Coord 3

IMAGE CLASSES 3

Abstract data type 3

Frames of reference 4

Elementvalues 4

Image types 5

Nullimages 5

IMAGE CLASS OPERATORS 5

OverloadedC++operators 5

Unary

operators 5

180 degreerotation

(-)

6

Complement

(!)

6

Binary

operators 6

Multiplicative Operators 6

Multiplication

(*)

6

Division

(/)

7

Zero-division

(%)

7

Additive Operators 7

Addition

(+)

7

Subtraction

(-)

7

Relational Operators 8

Equality

Operators 8

Additional Image Class Operators (Extended

Operators)

8

IMAGECLASS FUNCTIONS 1 0

Organization 1 0

Constructors and destructors 1 0

Self managementfunctions 1 1

Basis functions 1 2

Inquiry

functions 1 2

Arithmetic functions 1 2

Structural functions 1 3

Extended functions 1 3

Morphological functions 13

Statistical functions 1 3

Thresholding

functions 14

Higher-level functions 1 4

FUNCTION CALLING SYNTAX 1 4

Member function invocation 1 4

Friend function invocation 1 5

IMAGE STRUCTURE CLASSES 16

Domain class 1 6

Range classes 17

FOR_DOMAIN_OF CONSTRUCT 1 8

Purpose 1 8

Syntax 1 8

ERROR HANDLING 19

Preconditions and Postconditions 1 9

Error

flag

errno 1 9

SOURCE FILE ORGANIZATION 1 9

General 2 0

Header Files 2 0

Source files 20

Program Compilation 2 1

Restrictions and Caveats 21

CHAPTER 5- APPLICATION EXAMPLES 5-1

GENERAL 1

Chapter Objective 1

Applications 1

Algorithm Illustration 1

GREY SCALE DILATION 1

Algorithm Description 1

Implementation 2

REGION GROWING 6

Purpose 6

Algorithm 6

Implementation 7

SKELETONIZATION 9

Aim 9

Algorithm description 9

oopsSlip Implementation 1 0

C Implementation 1 1

FOURIER TFtANSFORM 1 3

Generalized Picture Transform 13

Discrete Fourier Transform 1 3

Inverse Fourier Transform 1 5

oopsSlip Implementation 1 5

HADAMARD TRANSFORM 17

Mathematical description 1 7

Implementation 1 8

FILTERING 20

Aimof algorithm 2 0

Algorithm description 20

oopsSlip Implementation 21

C Implementation 2 2

Image Results 2 3

CHAPTER6- DISCUSSION 6-1

GENERAL 1

Chapter Objective 1

MEETING THE SYSTEM REQUIREMENTS 1

Design Qualities 1

Portability

1

Simplicity

1

Efficiency

and Performance 2

BUT IS ITOBJECT-ORIENTED? 3

Requirementsofan Object-Oriented System 3

Conclusion 5

USE OF IMAGE ALGEBRA 5

General 5

CHAPTER7- FUTURE DIRECTIONS 7-1

GENERAL 1

Chapter Objective 1

USE OFC++VERSION2.0 1

OTHER OBJECT-ORIENTED LANGUAGES 1

Ada 1

Otherlanguages 2

VISUAL INTERFACE 2

CHAPTER 8- _CONCLUSION 8-1

APPENDIXA- INTRODUCTIONTO IMAGEALGEBRA A-1

GENERAL 1

HOMOGENEOUS IMAGE ALGEBRA '. 1

Operationsand Inducement 1

Basis 2

FINITE HOMOGENEOUS IMAGE ALGEBRA 2

General 2

Bound Matrix 2

Star 3

Basis operations 3

Extended operators 5

Structural operators 7

Minkowski operators 7

Behaviorof star 8

CONCLUSION 8

APPENDIX B

-CLASS DECLARATION LISTINGS B-1

APPENDIX C

-IMAGE FUNCTION DICTIONARY C-1

EXPRESSING IMAGING ALGORITHMS

USING A C++ BASED

IMAGE

ALGEBRA PROGRAMMING

ENVIRONMENT

CHAPTER 1 - INTRODUCTION

AIM OF THESIS

Aim ofthesis. Theaim ofthisthesisistoimplementan_{image processing}systemthat

usestheImageasthe_primaryunit ofmanipulation.

PROBLEM STATEMENT

Background. _{Image processing}algorithmsforgeneral-purposecomputersare_usually

designedtomanipulatepictureelements,orpixels. Theneedtoimplementalgorithms_{this way}

tends,

in manycases, toobscurethe_clarityof_{the underlying}algorithm.

Severalmathematical

techniques,

calledimagealgebras,have beenproposedto

completely describe image interactions. The noteworthyapproaches usetheconcept ofthe Imageasthefundamental unitofmanipulation. The definitionof_{Image may vary between}

algebras,butis generallymeanttoencompassthe totalnumber of pictureelements,orpixels, as

Problem. Fewpractical

implementations

have beenmadeofimagealgebras. Ameans

of

implementing

animagealgebraexpression_usingadedicated languageorenvironmentis

CHAPTER 2 - PREVIOUS WORK

GENERAL

Chapter Objective. Theaim ofthischapteristodescribetheworkinthisfieldtodate.

IMAGE ALGEBRA

Context. _{Much development in image processing} algorithmstodate has been done

empirically,basedon statistical science or_{simply intuitive judgement. Several}current problemsin

imaging

pointto the needforastandardized,coherent and completetooltodemonstratethe

correctnessof algorithms. Analgebraic mathematical approachto_{image processing}offers_many

ofthesequalities.

Thegoal of animagealgebraistoexpress allimageoperations

hierarchically

froma small

collectionofproven,wellbehavedprimitivebasisoperations. _{Not only does}such an algebra

providea sound mathematical

framework,

butitalsolaysthefoundation for languagesand

systems whose _abilitytoexpressimage processingalgorithms canbe

thoroughly demonstrated,

andthatproduce correct and robust results.

Origin of image algebra. There exists a number ofdifferentimagealgebras, most

basedon an approachtoset mathematics pioneered

by

H. Minkowski

[Min03],

and refined

by

GeorgesMatheron

[Mat75]

andJ.P. Serra

[Ser81

]

fortextureanalysisof geologicalformations.

TheworkofMatheronandSerra has been

directly

appliedin an area ofimageanalysis

involves analyzing imageswith respectto their shapes, not_{only in}their

domain,

orextent,butalso

intheirgrey level

(considered

athird dimensionofthedomain). Becauseofitsorigins,it benefits

froma strictermathematicalformulationthanother_{image processing}methodologies,andis

being

usedtoovercomethe

limitations

oftraditionallinearconvolution-type operations.

ThemathematicsofMatheronandSerrawere appliedina systematic_waytoimages

by

two_primarygroups:

Dougherty

and Giardina

([DoG85], [DoG87b], [DoG88a]),

and Ritterandhis

team

{[RSG85], [RDW87]

and

[RSW87]

).

The heterogeneous

(many-typed)

imagealgebras

developed

by

these twoindependentgroups require several sortsofdatatypes to

fully

describe

imagealgorithms.

Further developmentoftheDougherty/Giardina imagealgebra resulted ina

homogeneousor single-sortedimagealgebra

([Dou89a]

and

[Dou89b]).

Theadvantage ofthis

singledatatypealgebraisthatitcan express_anyothertypeofimagealgebra,or_{any kind}ofimage

processingoperation. Appendix Aprovides a general overview ofHomogeneous Image Algebra.

COMPUTER IMPLEMENTATIONS OF IMAGE ALGEBRA

General. Aconcise algorithmformulationmethodsuch asimagealgebra provides a

convenient methodfor

defining

a_computingenvironment whereitcanbeused. Threeprincipal

groups_{have been working}toimplementvariationsofMatheronandSerra'swork: Ritterandhis

teamatthe

University

ofFlorida

[RDW87],

Lougheedand

Sternberg

attheEnvironmental

Research InstituteofMichigan

[Ste83]

and

Dougherty

attheMorphological

Imaging

Labofthe

AFATL Image Algebra. Underthe_sponsorshipoftheU.S. Air Force Armament

Technical

Laboratory (AFATL)

andthe Defense Advanced Research Projects

Agency

(DARPA),

a

researchanddevelopmentteamatthe

University

of

Florida, Gainesville,

headed

by

Gerhard

Ritter,

has developeda

heterogeneous

(many-sorted)

imagealgebrabasedonimagesand

templates

[RSG85].

Templatesare a means of_relatingthedomainoftheinputto thedomainof

theoutput. AFORTRAN based languagepreprocessor enables a usertoprototype image

processingalgorithms_{developed using AFATL Image Algebra}andimplementthemon a

computer.

Althoughtheir_{language is relatively}complete, the templateoperations add a measure of

complexityto thesystem. Inthe

beginning,

itwasdesignedtobeused on a specialized array

processor, althoughlaterversions run on a general-purpose computer.

C-3PL. Researchgroups atthe

University

ofMichiganandtheEnvironmental Research

InstituteofMichigan

(ERIM),

headed

by Stanley Sternberg

andRobert

Lougheed,

have

developedaparallel pipeline imageprocessor,called acytocomputer,and ahigh-level language

specificallycreatedfor imageprocessing,calledC-3PL

[Ste83].

Thecytocomputer applies sequences of neighborhoodtransformations todigitized

images. Eachneighborhoodtransformationismadeinanindividual processingelementknown

asa_processingstage. Thecomputerisa serial pipeline ofstages,where each stage performs a

transformationontheentire image.

The image processing languageused

by

thecytocomputeris

directly

basedonthe

Thissystemwas one ofthefirst to dealwithimagesas a whole

(as

opposedto thepixel

level). The image

being

processed iscalledtheactive

image,

whichismodified

by

probingor

combination withotherimagescalled_structuringelements. Thearchitecture providesfor

manipulationofboth

binary

images,

_usingsilhouette

transformations,

and grey-scale

images,

usingumbratransformations.

Thecurrentversion ofthecytocomputer istheCyto-HSS

(Cytocomputer-High

Speed

System) [Lou89].

Theadvantages ofthecytocomputer arethatmorphological operations are executed_very

fast.

However,

sincethearchitectureisunique, theimage processing languagecannotbeused

on other systems. It isalso_{intended primarily for}morphological imageprocessing.

SLIP. Homogeneous Image Algebrawas extendedinto Finite HomogeneousImage

Algebra

(FHIA) by Dougherty

andGiardina

[DoG87b],

which providedabasisforcomputer

implementation.

FHIAis basedontheconceptoftheboundmatrix ofreal values onatwo-dimensional

CartesiangridZx

Z,

Z

being

theset ofintegers. Thematrixhas dimensionsmrows

by

n

columns,anditspositioninthegrid isgiven

by

thecoordinates rowtand columnrofthe

top

left-handelementinthematrix. Allthevalues ofelementsoutsidetheboundmatrix arecalled *

(star),

or undefined. Undefinedvalues are also allowedinsidethebound matrix. Asignificantfeatureof

FHIA isthat_{any interaction between finite images}

(bound

matrices)canbe defined froma_set,or

Theoriginalworkto implement FHIAwasperformed

by

Paramjit

SehdevattheStevens

Instituteof

Technology [D0S88],

andwascalled

Structured Language

for Image

Processing

(SLIP).

Itconsisted of a

library

ofPascaland_{assembly language}subroutinesthatexecuted on a

DEC VAXcomputer. Theobjective oftheproject wastoprovideaportablemeansforresearchers

toexperimentwithFHIA.

I haveworked on andimprovedthisimplementation

([DGS89]

and

[GDA90]),

_provingthe

concept of a portable structured

imaging

environment.

Other implementations. Theuse ofobject-oriented_{languages for image processing}

andimagealgebraimplementation is

beginning

tobeexamined. Peter MarineauandMichael M.

SkolnickattheRensselaer Polytechnic Institute

[MSk89]

are

defining

an object-oriented

imaging

language formathematical morphology. Acommercial parallel_processingcomputer, the

AIS-5000

by

AppliedIntelligence

Systems,

isalso programmedin Objective-C

[ScW88].

These

approachesdonotappearto be basedon a specific algebraic means of_expressingalgorithms.

Michael A. JenkinsandJanice I. GlasgowofQueen's

University

at

Kingston,

Ontario have

takenadifferentapproachusingarraytheory,the

'study

ofnested,rectangularly-arranged

collections ofdataobjects"

([JeG89])

asthebasisfortheirNested Interactive

Array

Language

(Nial).

Nialcanbeusedinseveral _{different programming}styles

(procedural,

object-oriented, etc.)

CONCLUSION

Image processingsystemsbasedon acompletemathematicalformulationhave been

designed and built

(Ritter,

Lougheedand Dougherty). Objectorientedtechniquesare

being

exploredfortheirusein imageprocessing.

To

date,

thereappearstohave beenno attempts at

building

animage-as-objectoriented

CHAPTER 3 - GENERAL DESIGN

GENERAL

Chapter Objective. Theobjective ofthischapteristodescribethe requirements,

constraintsand designchoicesin

implementing

an_{image-as-object image processing}system.

USERS

Intended audience and uses. The intendedusers ofthissystem arethe students

andresearch staff oftheRochesterInstituteofTechnology. Thesystem willbeusedfor

demonstration,

prototyping of_{image processing}applications

(especially

morphological

processing),andteaching.

Level of user sophistication. Thecomputer experience of users variesfromnovice

toexpert.

Many

fall intothenovicecategory,and are notfamiliarwith computerinternalsordata

structures. Theuser will be familiarwithatleastone ofthe"fundamental"computerlanguages

(FORTRAN,

Pascal,

C,

etc.). Theuser will alsobe familiarwiththebasicprinciples ofimage

processing.

Hardware and Software. Theequipmentavailable includes

Sun, VAX7VMS,

UNIX/Ultrix,

IBM-PCand Macintoshsystems. Languagesavailable include

FORTRAN,

BASIC,

Pascal,

CandC++. The finalsoftwareshouldbeabletointerfaceas much as possiblewiththese

DESIGN QUALITIES

Thesystemmust provide an_{image processing}environmentthatisportable,simple and

efficient.

Portability

canbeachieved

by

_ensuringthat thesystem canfunctionwithout special

hardwareor software. Thisrequirementallowsthesystemtobeused on_anygeneral-purpose

computer.

Thesystem shouldbesimpletouse and maintain. There isno provisionforuser

training,

otherthan thedocumentation provided.

Simplicity

encouragesuse,and reduces potential

sources of errors.

Althoughefficiencyiscompromisedtosomedegree

by

the_portabilityrequirement, the

system should provideforas

timely

a response as possible.

CHOICE OF MATHEMATICAL BASIS

Severalauthors

([CDM88],

[JeG89])

havenotedtherequirementforan_{image processing}

languageorsystemtobe builtona soundmathematicalbasis.

Using

mathematical

theory

as a

starting pointforsystemdesignensures a consistent and complete set ofoperators, providesa

mechanismforcorrectnessproofs and eliminates redundant andcontradictory constructions,

The primaryrequirementofa mathematicalbasis foran_{image processing}systemis

simplicity. Asimplemeansof_expressing

interactions

between imagestranslatesintosimpler

algorithms and

implementations.

To

keep

thesystemsimple, thenumber of objects manipulated mustbekepttoa

minimum. Since Finite Homogeneous Image Algebra

(FHIA)

has onlyonedata

type,

the

image,

andtheinteractions between imagesaredefined ina simplemanner,it isa good choiceasthe

basis foran_{image processing}system.

Apossibledisadvantageof_{using FHIA is}thatitcontains somefundamental differences

comparedtomoretraditionalmethods. In

FHIA,

thedomainsoftheimageare

important,

aswell as

theconcept of undefinedelement,or*

(star).

_{Thesetwofeaturescauseresults generated}

by

_an

FHIA-basedsystem and atraditionalsystemto

differ,

althoughtheFHIAresultisrigorous

mathematically. Traditionalalgorithms oftentake"shortcuts*or simplifications eventhough the

results_maysuffer

(for

example,division

by

zero: FHIAreturnsa*,butmost return ao).

Theadvantages ofusing FHIA isthatalogicalmeansof

defining

image interactions is

developed

(for

example,whatdoestheaddition oftwo imagesmean?). Thispowerfultoolinturn

leadstoalogical definitionofhigher-levelimagemanipulations

(extended

operators,filters). This

advantage oftheuse of adefinedmathematicalmodelfor image interactionssuch asFHIA

outweighstheapparentdisadvantage.

Other imagesalgebrassuchasAFATL Image

Algebra,

withits imagesand

templates,

do

nothaveasstraightforwardanapproachto

defining

image

interactions,

asdoesFHIA Thismakes

Conclusion.

Finite

Homogeneous

Image Algebrawillbeused asthemathematical

foundation forthis

implementation.

USER

INTERFACE

General. Image processingalgorithmscan bespecified_{in many}ways. _{Two primary}

means of expressionhave been developed for

describing

Image Algebra imagemanipulations:

block diagramsand mathematicalexpressions.

Block diagrams. Block

diagrams,

suggested

by Dougherty

andGiardina

[DoG87a],

are

a graphical means of_{programming in}whicheachfunction isrepresented

by

a"blackbox" with a

specified number of

inputs,

outputs and adefinedaction. Figure 3-1 gives an example of ablock

diagram.

structuring

tran h! add r-H

i

domain element

se _{tran add}

range extmax ? dilate

im1

tran add

[image:23.543.50.497.413.585.2]

The block diagramconventions are similartothatof a generaldata-flowdiagram. Themain

difference is inthemeansof

displaying

howanactionis

implemented

overthedomainand range

of an image.

The domain

box

isconnectedtoallthetranboxes _aningthat theelements ofthe

domainstructurearefed oneatatimeto theinputofthe tran procedure. The highest tran

box receivesthefirstelement, thesecond getsthesecondelement,andso on

(represented

by

the threevertical

dots)

untilthelastelement. Theaction oftherangeboxcan _{be similarly}

interpreted. Theresultsfromthetranandadd.functionsarecombinedtogetherusingthe

extmaxfunction.

Eachofthefunctionsare

"defined"

by

lower levelsofblock

diagrams,

until,atthelowest

level,

onlytheFHIA basisoperations

(image

add,imagemultiply,etc)are used.

Using

theblock

diagram,

theindependentand parallel nature ofthe

loop

contents stands

out,whichisthemajor advantage ofthisvisualtool. Otheradvantages ofblock diagramsareits

visual representation ofdata flow andtheabstraction oftheimplementation fromthedesign

Agraphicaluserinterface isrequiredfortheuse ofblock diagramsas a_programming

method. Sophisticated hardwareand software would berequired_{for direct entry}of adiagram. In

addition, theuser_maynotdesignthemost efficient methodof

implementing

analgorithm. A

visuallanguageeditor and compiler/optimizeristhereforerequiredforthisapproach.

Although block diagrams have beenusedtosomedegreeof successin

illustrating

computer

implementation

difficult. Forexample,

looping

and control mechanismshavenotbeen

consistently defined.

Alphanumeric expressions. Since FHIAconsistsofmathematicalexpressions

concerning

images,

suchasc=a+b,wherea,band care

images,

itcantranslatewellintoan

alphanumericmeansofprogramming. Suchan approach couldbesimplertoimplementthan

using block

diagrams,

becausespecial userinterface hardwarewould notbe required.

Sincethesyntax of

describing

image interactions foran alphanumerically-based system

wouldfollowmore

directly

fromtheimagealgebra, thisapproach would require creation of an

imagealgebra

library

_usinga common_programming

language,

or of a special-purpose

programming language.

Conclusion. Analphanumericuserinterfacewillbe usedtoimplementimagealgebra.

Block diagramscanhowever beused asa_{supplementary documentation}tool.

IMPLEMENTATION STYLES

Programming Styles. Therearetwomain stylesinwhichthissystem canbe

implemented: theobject-orientedapproachandtheprocedural

(structured)

approach. The

choice of style willinfluence thearchitectureofthesoftwaresystem.

Procedural approach. Theprocedural approachisthe traditional

"structured"

proceduresthatoperate ondatawiththatdata

(modularity)

ispossibletoa certain_{degree using}

procedurallanguages.

Theadvantageofthisapproachisthatit istheonemost_widelyusedatthemoment,and

theone mostfamiliartothepotentialusers ofthesystem. Traditionalgeneral-purpose computer

architecturesand_operatingsystems are also"tuned"tothisstyle of_programming

[Str88].

Object-oriented approach. "Object-oriented" referstoenvironments and

programmingtechniques thatsupportdataabstraction,data

hiding,

procedural_modularityand

concurrence

[Str88a].

Pureobject-oriented systems consist of groupings of"virtual

devices",

calledobjects.

thatcan

"communicate"

with each other. Objectsencapsulateconventionaldatastructures and

theroutinesneededtomanipulatethedata. Objectsare organizedintoclasses,ordatatypesof a

similarfunction. Classescanfurtherbe defined intosubclasses. The"actualization"

of an object

iscalled aninstance.

Eachobjectisself-contained,and cannot

directly

accessthedataof otherobjects. This

restricted accessisone ofthemajor advantages oftheobject-oriented_paradigm,inthat the

implementation detailsoftheobjectare

hidden,

andthepermitted actionswiththedataare

well-definedand _strictlycontrolled. Inthissystem,

defining

imagesas objectswould enforcetheFHIA

concept astheimageasthe fundamental unit ofmanipulation,and preventtheuserfrom

dealing

directly

with pixels.

The conceptof"messagepassing",used insuch object-orientedlanguagesas

Smalltalk

mathematicalinnature,and severalinvolvetwoimages

(such

as

filtering,

dilation)

toproducea

thirdimageasresult.

Themost severedisadvantageofthisapproachistheintendeduser's_{non-familiarity}with

object-orientedparadigms

(at

this time). Sincethe targetusers_{have different computing}

backgroundsand skills

(with

some

having

noformal introductionto programming,structuredor

otherwise),use ofthisapproach could compromise one ofthebasic designconsiderations,

simplicity.

Anotherdrawback isthe

difficulty

of

implementing

an object-oriented approach with a

portablelanguage. Theclosesttoa

"portable"

language isC++

[Str88b].

Itcan allowroutines

writtenin ANSI

C,

sincethelatterisa subset ofC++. Specialistobject-orientedprogramming

languagessuch asSmalltalkwould compromise_portabilityevenfurther.

Many

object-oriented tools and techniques available at the moment are better suited

toapplications such as model

building,

computer-based simulations and expert system

knowledgerepresentation

[Kos88].

The image processingapplicationstargeted

by

thissystem

are more of amathematicalnature,andlendthemselvesmoreefficientlyto traditional

data-only

structures.

However,

thepossibilitiesof

treating

imagesas objectsdoesmakeforsimplerprogram

design.

Conclusion. The ideal implementation methodologywouldbeacombinationofboth

theobject-orientedapproach,forits data

hiding

anddata-based modularity,andtheprocedural

approach,becauseofits

familiarity

to theuser. Itis importantthat theuserbeabletochoose

LIBRARY VS. LANGUAGE

Desired characteristics of final system. To implement Finite Homogeneous

Image

Algebra,

thefinalsystem needsthe

following

characteristics:

a. Structures: Sincetheimage isastructureofdata

(the

matrix,and

its location inspace,at aminimum),amechanism_{for referring}to thewhole groupingofdatawith one referenceisrequired. Thissimplifiesthe code, increases readabilityandforcestheusertoreferto the dataat ahigher

level;

b. Procedural Modularity: Ameans ofgrouping proceduresintomodules, either onthebasisoftheirfunctions

("structured

programming")ortheir relationship tothedata

("object-oriented

programming")isneededtoorganize thelargenumber offunctionsinthe

library

intoa manageablesystem;

c. Equational expression: Since imagealgebraismathematical,functions

shouldbe implementedas equations

(such

asc = _A + _b; where_A,Bandcare images).

Implementation approach. Therearetwopossibilitiesto implement FHIA: complete

designof anew, FHIA-based

language;

and

building

of a

library

andtools_usinganexisting

language.

The firstalternative would require afullsyntacticalanalysis,as well as construction of a

parser and compiler. Thiscanbequitecomplicated, expensive,and_maynot meetthedesired

systemqualities,especiallysimplicitytothe user,since

they

would havetolearnanother

language.

Portability

canbeanother obstacleto thesuccessful useofa newlanguage. The

advantage ofthisapproach isthatthe languagecouldincorporatethe"image processor's_wayof

thinking",

as some

imaging

constructs

("repeat

over entireimage

domain")

translate_awkwardly

Thesecondalternative of_providinga

library

of constructsbasedon anexisting language

couldbesimplerfortheusertolearnand cheapertoimplement. Some languagesprovidetools

toimplementmostor all oftherequiredcharacteristicsforthesystem. Thedisadvantageisthat

not alltools_{may be}available or can notbeconstructed.

Conclusion. Thesecondapproach, thatof

building

an

imaging

library,

istheone

selectedforthis study,mainly because it isthesimpler approach.

SELECTION OF A HOST LANGUAGE

General. Fourcomputerlanguageswere examinedfortheir_suitabilitytohostaFHIA

library:

Pascal, FORTRAN,

CandC++. Thissectiondescribestheadvantagesanddisadvantages

of each.

Pascal. The firstimplementationof

FHIA

called SLIP (Structured Language for Image

Processing)

wasdonein Pascal

[D0S88].

Thisimplementationdidnotusestructures,and

therefore the matrix, its dimensionsandits locationwere passed with_everyprocedurecall,

resulting instatementssuchas:

Add( AR, AT, MA, NA, A,

BR, BT, MB, NB, B,

BR, BT, MB, NB, B) ;

Theproblem withthisapproachisthatthealgorithmflowcanbeobscured

by having

so

manyarguments

"cluttering

up"

eachprocedurecall. ThesecondincarnationofSLIP

[DGu89]

Useoftherecordtypedefinitionallowstheboundmatrix and

{t,

r, m, n} valuestobe

passed around as oneunit. Pascal alsoallows variable matrixsizes,

by

usingpointersandthenew

anddispose procedurestoallocate anddeallocatememory.

The

disadvantage

ofPascal isthe_callingconvention. Astatementsuch as

Add

(A,

_B, B) ;

whereaandbare

images,

raises_{the question,} whichimage is

input,

and whichisoutput? Inthis

case,a consistent proceduredesigncoulddesignatethelastargumenttoalwaysbethe output,

butwithout such a_policy

(or

correct

documentation),

errors canbemade.

Ifone wantstouse variable-sized matricesformaximum use ofmemory, theonusisonthe

usertodesignatethatvariable names refertopointerstoimagestructures. Theabove call would

then look like:

var

A,B: "

Image; begin

(...)

Add_{(A, B,} B) ;

(...)

end.

Failuretoincludethepointer symbol "

inthedeclarationwould resultin an error. The

syntax couldbe improved

by defining

Addas a_{function returning}a pointer. Thecallthen

becomes:

B = _Add(A,B) ;

which ismuch closerto thedesired format.

ThemaindisadvantagesofPascalare_memorymanagementandportability. The latter

problem referstothefactthatnostandard means ofgrouping proceduresintomoduleshas

been

(version 1.00A)

toVAX Pascal. Ateachtransfer

(required

touseimage

display

routines onthe

VAX),

the module headers hadtoberewritten,fromtheTurboto theVAXstyle:

Turbo Pascalmoduleheader: unit modulename

(moduleid)

VAX Pascalmoduleheader: module modulename

Inaddition,VAX Pascalproceduresthatcanbecalledfromoutsidethemodule musthave

thedesignation

[global]

.

The memorymanagementissue isanother mainproblemwhen_{using Pascal. The}onusis

ontheusertoensureimagesare allocated withnewbeforeuse, anddeallocatedwithdispose

whenfinished. Failure to doso makestheavailable_{memory fill up}quickly,and causesthe

proceduretocrash.

By

notusingpointers,and

declaring

arraystobeof afixed maximalsize,

memoryallocation anddeallocation ismore automated

(although

it isa waste of_memorytouse a

64x64element_arraytocontain a3x3matrix).

FORTRAN. Standard FORTRAN-77 hastwomajordrawbacks: lackof a structure

declarationmechanism, and alackof pointers.

Becausethereisno structuredeclarationmechanism,referencetoa procedure mustbe

intheform:

CALL ADD( AR, AT, MA, NA, A, BR, BT, MB, NB, B,

BR, BT, MB, NB, B) ;

VAX

FORTRAN

doescontainastructure mechanism

(structure)

which_greatly

simplifies

implementation.

_{For example,}theabove code

fragment

would look like:

STRUCTURE

/IMAGE/

UNION

MAP

INTEGER*2 R ! Upper left-hand corner coord _(column)

INTEGER*2 T ! Upper left-hand corner coord (row)

INTEGER*2 M ! Number of rows in image

INTEGER*2 N ! Number of columns in image

INTEGER*2 PIXEL(1:128,1:128) ! Image elements END MAP

END UNION

END STRUCTURE

(.. .)

IMAGE A,B

(...)

CALL ADD(A, B, B)

(...)

Thestructure statementisnot yet part ofthestandardFORTRAN.

Theotherdisadvantageof standard FORTRAN isthelackof apointer mechanism. This

meansthatimagesmustbe declaredtobethemaximum allowable_size,before compile

time,

resulting ineither a waste ofspace,or a program abortduetoalackof space.

ANSI C. ANSI C isa standarddefinitionofCthatallowsstructure

declarations,

_pointers,

andastandardmeans of_groupingproceduresintomodules. Amajor advantage ofthisversion of

C is itsportability.

Structuresaredeclared

by

_using thestructspecifier. _{The resulting}structurescanbe

Pointerscanbeusedtoprovide arrayswhosesize isnotknownat compiletime. The

mallocand freefunctionsare calledtoallocate anddeallocatememory,howeverthiscreates

thesame problem as mentionedin Pascalabove: theonusisagain ontheusertodecidewhen

animage isneeded. Failureto_{properly initialize}anddeallocateanimagecouldhave disastrous

consequences. Another problemwith allocationanddeallocation isthat theseextraneous

statements"clutterup"

theimplementation.

Anotherproblem withpointers,also presentin

Pascal,

is howtoaddress elements

pointedto

by

an address whichis itselfan element of a structure. Forexample,aC

implementation of animagestructureis:

typedef int pix; /* PIXEL TYPE */

typedef struct image /* IMAGE STRUCTURE */

{

/* _{col no of top left-hand corner*/}

/* _row number of _top lh corner */

/* number of rows */

/* _{number of} columns _/

/* _pixel values _*/

To findoutthesizeof an

image,

the

following

expressionisrequired:

{

image* _A;

int nbr_of_rows, nbr_of_cols;

nbr_of_rows = _A->M;

nbr_of_cols = _A->N;

(...)

Accessing

pixels

directly

ismorecomplicated:

pixell 1 = *(A->pixel + (rownum) + _{(colnum) ) ;}

int R

int T

int M

int N

pix *pixel;

Thesubscriptoperator

[]

cannotbeusedbecausetheelement_arraywas notdeclaredwitha row

length dimension: thecompilerdoesnotknow how

long

a rowis. Macrosorfunctionscanbe

designedtomake accesstoimageelementsmore_{natural,especially}tonovice programmers.

The use ofheader filesandfunction prototypes provideaconvenientmeansof_grouping

proceduresintomodules. Functionscan alsobe implementedtoreturn pointersto

images,

so

"equational"

procedureformatscanbeused. Theapplication examplesshow several cases of

this typeof expression.

Oneproblem withfunctionsremains:

they

are still an unnatural_wayof

formulating

an

arithmeticalexpression. Ifaandbare

integers,

is itnot preferabletowrite "b = _a+b

"

insteadof

"B=add(A,B)

;"?

Asimilar argument canbemadefor images.

Defining

operatorsforimagealgebra canbe

doneonaUNIXsystem,

by defining

asyntax,and_writinga preprocessor_usingutilities such as

lex and yacc, buttheimplementation canbequite complicated.

Anotherproblem withfunctioncalls

(also

presentin Pascaland

FORTRAN),

isthat

"natural"

function namessuch as open,close, abs,andmaxcannotbe redefined when applied

toimages. This increasestheprobabilityof user errors.

C++. C++isasupersetoftheC languagethatsupports controlled accesstostructures

("classes").

Another featureofC++thatappliestothisimplementationistheuse ofconstructors

anddestructors.

Aclassisadatastructurethatcontains withinittherelevantfunctions. Inthecaseof a

prototype

declarations

forall

functions

thatcan accesstheclass. Thismeetsthemodularity

requirementforahost

language,

in thatproceduresareorganizedas afunctionofthedata

(class)

on which

they

operate.

A featureofclassesisthe_abilitytocontrol whichparts oftheclass canbeaccessiblefrom

the"outside*. Inaclass

library,

thedataelementsarekept

"private",

and are not

directly

accessiblefrom instancesotherthanitselforthosedeclared "friend". Functionscanbemadeto

insulate theuserfromthedata internals

(setimageLoc

, showimageLoc). This abilitytoforce

theusertoconsiderthedatastructureas awholeisanother ofthedesiredattributes of ahost

language.

Withclasses,operators

(+,

*,=) canbe

"overloaded",

or_{redefined, tohave meaning}

when appliedto new classes. _{This capability}allowsthestatement:

B = _A + _B;

tomean"add image Btoimage Aand returntheresult_{in B". This ability}touse equational

expressionsisanotherdesiredattribute of ahost language. Functionssuch asopenandmaxcan

alsobeoverloadedtohavetheirimagealgebra_meaningwhen appliedto

images,

and still

keep

theiroriginaldefinitionwhen appliedtofilestreams

(open)

or numbers

(max).

Amajor advantage of

C++,

when comparedto

C,

Pascaland

FORTRAN,

isthe_capability

to defineconstructorsanddestructorstoallocate_{memory automatically}whenavariableis

declared,

andtomarktheallocated _{memory for disposal}whenthevariableisnolongerneeded.

This freestheuserfrommostofthe_{responsibility for}memorymanagement

(although

theuser

mustbecareful nottoreferto thevariable outsidethescopeinwhichitwas

declared,

sinceitno

Atthepresent

time,

themajor

disadvantage

of C++is itsportability. Therearetwoslightly

incompatibleversionsthatexist ofC++: version 1.2

([Str86])

and version2.0

([Gut89],

[Lip89]).

Upwardmigrationoftheclass

library

fromaversion1.2compilertoa version2.0compilershould

nothaveanadverseeffect onthe

library,

althoughthishasnotbeentested becausea version2.0

compilerwasnotavailable.

Inaddition,onlya certain number ofoperatorscanbeoverloadedin C++. This isa

problem

because,

forexample, the often used operatorextaddused as:

B = _{extadd(A, B)} ;

couldbemore_clearlyexpressed as:

B = _{A <+> B}

Conclusion. C++ appearstobethebestchoicetomeettherequirements of

hosting

a

FHIA

library,

having

a well-controlled structuremechanism,a meanstoorganize modules and a

meanstoexpressimagealgebra equationsintheirnatural mathematicalform. ItresemblancetoC

will makeitsuse somewhat easier.

GENERAL DESIGN

Thissystem will use analphanumericuser

interface,

basedonFinite Homogeneous

Image

Algebra,

to implementaclass

library

writtenin C++.

The generaldesignofthesystem will consist of.

a class

library

writtenin

C++,

defining

theimageandthefunctions neededtooperate on

it;

and

TheC++class

library

willbe

implemented

inamanner

that,

whenappropriate,can allow

bothan object-orientedfunctioncallstyle:

a. extend(b) ;

anda moretraditionalfunctioncall style:

extend

(a,

b) ;

CHAPTER

4 -

IMPLEMENTATION

GENERAL

Chapter

Objective.

Theelementsneededtoimplement Finite Homogeneous Image

Algebra have been defined ina class

library

calledtheObject Oriented Programming System

Standard

Library

for Image Processing

(oopsSlip).

Theobjective ofthischapteristo describe the

featuresandimplementationoftheclasslibrary.

oopsSlip User Manual. Thischapter andAppendix C

(Class

Function

Dictionary)

are

intendedto beusedtogetherand constitutetheuser manualforthesystem.

Examplesoftheuseoftheclass

library

are givenin Chapter 5.

Notation Conventions. Toaid _{in explaining}the

implementation,

the

following

notation conventions are used:

Courier font

IMAGEor IMAGE

PIXorPix

denotespredefined

keywords, identifiers,

or other

computer-relatedobjects,used

directly ("literally")

inthe system;

isa genericimage

type,

anyofthepredefined image

classes;

FEATURES

General. Thesystem consistsofthe_oopsSlipclass

library

andapreprocessor.

oopsSlip Class Library. _{The oopsSlip}class

library

isa set ofthreegroups of classes:

a. type classes

(coord,

_Byte), whicharederived from the C++_fundamental

types;

b. image classes

(Bytelmage,

_{Intlmage, Reallmage,}

Compleximage),which are imagesthathaveallthesamefunctionsand

methods, butare composed of one ofthefundamentalorderived

types;

and

C. imageStructure Classes

(Domain,

_{ByteRange, IntRange,}

RealRangeandComplexRange),which are classesderived fromtheimage classes.

Preprocessor. Sixadditional operators are addedtothenormal overloadableC++

operatorset. This istoaccommodatetheextended operators

(extadd,

extmult, extmax,and

extmin) andbasicmorphological operators

(dilate

anderode). Apreprocessordecodes

thesespecial symbolsinto functioncalls, thencompiles andlinkstheuser program.

DERIVED TYPE CLASSES

General. C++containsfundamentaldatatypessuch as int, float,anddouble. To

accomodatetheimage_processingalgorithmsinthe_oopsSlipclass

library,

twoothertypeclasses

aredefined: ByteandCoord.

Byte. TheByte isaninteger type that takesuponebyteofspace. Itcan

Coord. This isusedtodenote thecoordinatesof anobject,and isa pair ofintvalues.

Theconvention_{for referring to}acoordinateis

(row,

column). _{The only}operatorsdefined for

Coordare <_<,== _{and !=. Themethodtoreferto}

coordinatecomponentsis

(here

isoftype

Coord):

rowComponent = _here.row

();

columnComponent = _here,col();

or rowComponent = _row(here) ; columnComponent = _col

(here);

The brackets intheexpressionsareimportant because

they

refertomemberfunctionsof

theclassCoord. Thiswillbe furtherexplainedinthesection on Function

Calling

Syntax.

IMAGE CLASSES

Abstract datatype. The"generic"

imageclassisanimplementationoftheconcept of

bound matrix,anmrow

by

Ncolumnmatrix,withthe

top

left-handcornerelement at rowtand

columnrina universalCartesiangrid,asillustratedin figure4-1. The locationof an elementis

referredtoas apixel,and itsvalue, thegrevvalue.

image location

in grid:

row T = ₃

column R = -1

grid column numbers

I

i i

7 i i i i i

i '

i i i i i

ei

:

:

:

:

1 _{N 7} ' _?

4 i i

i i i i i

i i

.::::& *

'3-'i''''V-'.'.'.i-V.'.'i'.'-'.'-V-V.', -. -1----i- -!- -+'--t-

-. _ i

6

!

7 p i_

|

grid row

!--.-= ₆ _ _ _ --2 2-i- -i-i.-.-i l.iV-v-v-".'-'.i-v-ViV.v.y""".

numbers ? -5 i-4 i _-i: o;-v-_{1 y:2V3:-v-4X''5-:}

i i i

i i i

.**-i . _ i_ _

r_ __i i

i i

-3' i i i i

-4i i i i i

__JL_J__L_1__I__

1 1 1 1 1

-5i i i i i

i i i i i i L. JL _l

Fig

4-1 Coordinatesofimageoverlaid onCartesiangrid

Framesof reference. The Cartesiangridisusedtoposition

images,

regions within

an

image,

andimageelementsina universalframeofreference,calledthegrid coordinates. Grid

coordinatesare usedbecauserelative positionofimageregionscanbe important in FHIA A

frameof referencelocalto the

image,

image coordinates,locateselements

by

their

(row,

column)

coordinates relativetothe

top

left handelementintheimagematrix

(being

element

(o.o)).

This

referenceisusedformanipulationswithin animage.

Element values. Elementsofthebound matrixare eitherdefinedorundefined.

Definedelementscanhaveanyvalueaccording to thedatatype

being

used

(double,

_int, [image:41.543.89.476.53.380.2]

image fromaperiscope,whichcanberound)fit therectangularbound imagematrixdatatype.The

undefinedelementvalue isgiven

by

the constantstar.

Image types. The elementsofthebound matrixcanbecomposed of one ofthe

fundamentalorderived types. The designationsand_{corresponding}typesare:

Intlmage correspondsto int;

Reallmage correspondstodouble;

Bytelmage correspondsto Byte;

Complexlmage correspondstocomplex.

All imagetypeshavethesamefunctionsand operatordefinitions.

Null images. Thenullimage isan imagewith0

(zero)

rows and0

(zero)

columns. Itcan

be locatedanywhereinthegrid. It_{is denoted generically}

by

nulliMAGE,which correspondsto

the

following

valuesforthe

following

types:

nulllntlmageisusedwith an Intlmage;

nullReallmageisusedwith aReallmage;

nullBytelmageisusedwith aBytelmage;

nullComplexImageisused with a Complexlmage.

IMAGE CLASS OPERATORS

Overloaded C++ operators. Several C++ operatorsare givenspecific meanings

with respecttoimages. Therearetwo typesofoperators:

binary

(operating

ontwo

images)

and

Unary

operators.

Expressions

with

unaryoperators_groupright-to-left:

unary-expression:

unary-operator expression

unary-operator: one of

i

180 degree rotation

(-).

Theresult oftheunary

-operator on animage isthat the

image isrotated 180 degreesabouttheorigin

(0,0)

oftheglobalCartesiangrid.

Complement

(

!

).

Theresult ofthe_{unary !}operator on animage isthat_every

definedpixel becomesundefined (= star), and_everyundefined pixelisgiventhevalue 1. All

elements outsidetheresulting imageare consideredtohavevalue 1.

Binary

operators. The

binary

operators, in

decreasing

precedence,are:

*

multiplytwoimagesor animageand a scalar

/

dividetwoimagesor animage

by

a scalar

(division

by

zero givesstar) %

zerodivide2 imagesor animage

by

a scalar

(division

by

zero giveszero)

+ addtwo imagesor animageandascalar

subtracttwoimagesor a scalarfromanimage

< isone imagesmallerthan theother > isoneimagelargerthan theother

== _isone image_equalto theother != is_one imagenot equalto theother

<= is_oneimage_smallerorequalthan theother

>= is_one imagelargeror equalthantheother

Multiplicative Operators . The multiplicative operators

*,

/and% group

left-to-right:

multiplicative-expression:

expression * _expression

Multiplication

(*).

The *

(image

multiply)operatorperforms a multiplication

between corresponding definedelementsofthe

intersecting

parts oftheoperandimages.The

domainoftheresultistheintersectionofthe two images. Iftheimages donot

intersect,

theresult

isa nullimage. Ifone ortheotheror bothofthe

corresponding

elementsisundefined, the

correspondingelementinthe resultisundefined.

Multiplication

of animage

by

a scalaris defined

asthemultiplicationof eachdefinedelementoftheoperandimage

by

thatscalar. Multiplication is

commutative.

Division

(/).

The

/ (image divide)

operator performs adivisionofthefirstoperand

image

by

thesecond onthe

intersecting

domainoftheimages. Ifone ortheotherorbothofthe

correspondingelements onthe intersectionareundefined, theresult isundefined. Ifthe

corresponding elementinthedivisoris 0

(zero)

thentheresultisundefined. Iftheimages donot

intersect,

theresultisa nullimage. Divisionof animage

by

a scalaris definedasthedivisionof

eachdefinedelementoftheimage

by

thatscalar. Division

by

o

(zero)

setsthepixeltostar.

Zero-division

(%).

The%

(image

zero-divide)operatorperforms a

"zero-division",

inthatifthe_{corresponding}elementinthedivisorisao

(zero),

theresultingpixel issettoo

(zero).

If the images donot

intersect,

theresultisanullimage. Zero-divisionof animage

by

a scalaris

defined inananalogousmannertodivision.

Additive Operators. Theadditive operators+and

-group left-to-right:

additive-expression:

expression + expression

expression expression

Addition

(+).

The domainoftheresult ofthe+

(image

add)operatoronimages is

the intersectionofthedomainsof each oftheoperand images. The resulting greyvalues arethe

orbothare undefined. Ifoneorbothoftheoperandsisanull

image,

theresultisa nullimage.

Additionof animagetoascalaris definedastheadditionofthescalartoevery definedelementof

theimage. Addition iscommutative.

Subtraction(-

).

_{Image Subtraction is defined in}

an manner analogoustoaddition.

Relational

Operators.

Therelationaloperators_{group in}thesame manner astheir

C++_{counterparts:}

relational-expression:

image-expression

< image-expression

image-expression

> image-expression

image-expression

<= _{image-expression}

image-expression >= _{image-expression}

Theoperators <

(smaller),

>

(larger),

<=

(smaller

_{orthe same),} >=

(larger

_{orthesame)relatethe}

extent ofthedomain

(or

size)oftheimages. Theextent ofthedomainof an

image,

orits

cardinality,isthe number ofdefinedelementsintheimage. Therelational operators yieldthe

constantfalse

(=0)

ifthespecifiedrelationis

false,

andtrue

(=1

)

if it istrue. Anullimage hasa

cardinalityof0.

Eguality

Operators. The equalityoperatorstestwhether animage isthesame as

another:

equality-expression:

image-expression == image-expression image-expression >.= _{image-expression}

The==

(equal to)

operator returnstrue

(=1)

iftheimageheader and imagematrices are

Additional

Image Class Operators

(Extended

Operators). Sixadditional

(non

C++)

operators are providedinordertoimplementtheextendedoperators andthemorphological

functionsdilateanderode. Inorder of

decreasing

precedence,

they

are:

[+] dilate [-] erode

<@> extmax

(extended

maximum)

< "

> extmin

(extended

minimum)

<*_{> extmult}

(extended

multiplication)

<+> extadd

(extended

addition)

Theseoperatorshave the highestprecedence,sothat

they

areevaluatedfirst.

Evaluationorderis from lefttoright. Thesyntaxis:

extended-arithmetic-expression:

expression <+> expression

expression <*> expression

expression <@> expression

expression <~> expression

Theaction oftheextended arithmetic operatorsisanalogousto thenormal arithmetic

operatorsontheintersectionoftheoperand images. This intermediateresultisextended

by

unioning the remaining domainofthesecondoperandto the result, thenunioningthe _remaining

domainofthefirstoperandto theresult. Ifthedomains do not

intersect,

theresultistheunionof

thedomains. Ifone ortheotherimage isnullthen theresultisthedomainofthenon-nullimage.

If bothoperands arenull, the resultisa nullimage. Extendedoperationsbetween imagesand

scalars are notdefined. Extendedoperators are not commutative.

Sincetheseare not validC++operators,anyprogram_{containing these}symbols mustfirst

bepassedthroughapreprocessor. This stepconsistsof_recognizingthesymbols and

replacing

The

advantage of

using

thesesymbols

instead

of afunctioncallisthat theseare common

image operators,and are used atleastasoftenastheimagearithmetic operators such as+,or*. It

can also make anequational expressionmorereadable:

h = _{a [-] (f <}+> g) ;

h = _erode

(a,

_extadd

(f,

g) ) ;

are equivalentstatements. The imagearithmeticis highlightedwhen operators are used.

IMAGE CLASS FUNCTIONS

Organization. Thepower ofthe_oopsSlip

library

residesintheset of morethan 100

image processing functionsavailableintheImageclasses. Theseroutines canbesubdividedinto

groups_accordingto theirfunctions.

The

following

discussion isanoverview oftheprincipalimage functions. A detailed listof

thefunctionprototypesisgivenintheheader file listingsofAppendix

B,

and eachis described in

the Function

Dictionary

oftheuser manual atAppendixC.

Constructors and destructors. The imageclasseshaveconstructorsand

destructorsthatallocate and deallocatespacefortheimage. Theconstructoriscalled

automatically inC++whenadeclarationismade:

Intlmage iml;

Reallmage im2(0,1,2,3,4.1) ;

The_{constructor statement consistsofthe typename.variable name, anda}

groupof

Ptional

initialization

arguments,in parenthesis. Theorder oftheinitializationarguments and

defaultvaluesifnotspecified are:

T row numberof

top

left handcorner ofimage

(default

o

);

R column number of

top

left handcorner ofimage

(default

o); M numberofrowsintheimage

(default

o

)

-rownumbersgofrom oto m-l; n number of columnsintheimage

(default

o)

-columnsgofromo to N-1;

Theconstructor

function

isalso calledwhen_assigningoneimagetoanother

during

declaration:

Intlmage im4 = _iml;

Other typesofinitializationarguments,usinga secondimage

(here

calledother), are:

Reallmage name

(other,

0) ;

setsname'sheaderthesame asother, butwith all definedelements=₀

Reallmage name(otherLoc, M, N, 0) ;

setsnametosamelocationasother

(the

coordinate valueotherLoccontains thelocationofother), butwithdimensionsm

by

n,and all elements=_0.

Variablescanbe declaredat_anypointin aprogram,but

they

mustbe declared before

they

areused,and areautomatically deallocatedwhenthevariable passes outof scope.

Destructorsareautomaticallycalled

by

the compiler,so

they

are nottobecalled

by

the

user.

Self managementfunctions. Accesstoelements oftheimage

(t,

r, m, n, element

area showsthetotal numberof

defined

and undefined elements card showsthe number of

defined

elements

elem showstheelement valueat acertainlocation

setElem setstheelement valueat acertainlocationtoa certain value setAll sets alltheelementsintheimage toa certain value

loc showstheimage

location

(t

,r)

setlmageLoc setstheimage location

(t,r)

numCols showsthe numberofcolumns

(n)

numRows showsthenumber of rows

(m)

nextElemLoc showsthelocationofthenextdefined elementintheimage

nextElemVal showsthevalue ofthenextdefined elementintheimage

Othermanagementfunctionsare:

print printtheimageas a matrixto thestandard output writelmage writestheimagetoafilestream

readimage readstheimage fromafilestream

Basis functions. Sixoperators aredefinedastheFHIA basis: imageaddition

(+),

imagemultiplication

(*),

image division

(/),

extended maximum

(extmax),

_{ninety degree}rotation

(ninety)

andbasistranslation

(tran).

Appendix A describestheformal definitionof each of

thesefunctions.

Inouirv functions. Theseoperatorsreturn a booleanvaluetrue orfalseabout

certain aspects oftheimage:

isComp

image checksiftheimageisacomplementedimage isNulllmage checksiftheimage isnull or_empty

isDomainEqualcomparesthedomainsoftwoimages

isHeaderEqualcomparestheheaders

(t,

r, m. n)oftwoimages

Arithmetic functions. Thearithmetic operators+, ,*,/,and% aredefinedto

operatebetweentwo

images,

or animageand a scalar. Ifa scalarisone ofthe arguments,it is

transformed toanimageofequaldomainastheother_{argument, but}with allimageelements equal

to thescalar. Inthis way,theresultof animageoperatedon

by

a scalar resultsinanimageof same

domainastheinput image.

Otherarithmeticfunctionsthatoperatebetweentwoimages:

max findthemaximum value_{between corresponding} elements

min findtheminimum value_{between corresponding} elements

Thereare alsoarithmeticfunctionsthatoperate_onlyon oneimage:

sub additiveinverse

(negate

alldefinedelements)

abs absolute value alldefined elements

comp complementtheimage

sgr square alldefined elements

sgrt findthesquare root of alldefinedelements

recip reciprocalof alldefinedelements

sin,cos, tan trigonometricfunctionsof alldefinedelements

Structural functions. These functionsperform manipulations onthedomainofthe

image:

flip

flip

theimageovertheorigin

window restricttheimagetoa certainwindow transpose transpose therows and columns

minbound findtheminimalbound matrix

intersect findthe

intersecting

domain betweentwoimages

ninety2 rotateimage 180 degreesabouttheorigin

ninety3 rotateimage270 degreesabouttheorigin

Extended functions. Aset ofextendedfunctionsare provided:

extend imageextension

extmult extendedmultiplication

extmin extendedminimum

extmult extended maximum

Morphological

functions.

The morphologicalfunctions dilate,erode,open,

close, and minksub

(Minkowski

subtraction)areimplemented.

Binary

operations can alsobe

performedon_greyscaleimages

by

_{using b_dilate, b_erode, bopen,}and b_close.

Statistical functions. Statisticsontheimagecanbeobtainedwiththe

following

functions:

avg findtheaverage pixel value med findthemedian pixel value

max findthemaximal pixelvalue

min findtheminimum pixel value

sum findthesum ofthepixel values

ssg calculatethesum ofsquares

Theseroutines return a valuetyped_accordingto the typeoftheinput image

(for

example,

maxon an intlmage returns anint).

Thresholding functions. Asetof

thresholding

functionsprovides

flexibility

in

algorithmdesign: thresh, threshAbove,threshBelow,threshBelowEqual,

threshBetween,threshDefined.

Higher-level functions. Thereare_manyother routinesthatperformhigher level

image manipulations,such as theFourier transform,filter,andhist. The implementationof

FUNCTION

CALLING SYNTAX

Member

function invocation.

Theobject-oriented paradigm assumesthatobjects

actonmessages. ThismechanismissimulatedinC++

by

invoking

memberfunctions

(functions

grouped with agivenobject)usingthesyntax

instanceName.functionName(arguments) ;

where:

instanceName isthename of aninstanceoftheobject

functionName isthe name of a memberfunctionofthatinstance

arguments arethearguments passedto thefunction

Forexample, theclassReallmage containsthememberfunctionsninety(),

thresh( ) andextend( ). Iftheinstanceiml of Reallmageiscreated,then thesemember

functionsare called_usingthesyntax:

Reallmage iml; Reallmage im2;

double tVal ;

(...)

iml.ninety() ;

/* _"iml, rotate _by ninety degrees" */

iml.thresh(tVal) ; /*

"iml, threshold yourself at tVal" */

iml.extend(im2) ; /* "iml, extend yourself by

im2" */

This formoffunction invocationcan alsobeusedinsideexpressions,such as:

for (int i = _{0; i < iml.}area(); i++) {;}

Functions

canbe

"chained",

forexamplethe

function

ninety2 0 isequivalentto

chainingthe_{ninety() function:}

iml.ninety2 ₍₎ ; /*

"iml,

rotate

by

180 degrees"

*/

iml. ninety() .ninety() ; /* "iml, rotate

by

9 0 _{degrees, then..."/}

/*

...rotate by 90 degrees again" */

Thearguments_{in the function}

invocation

_{canbe any data type}

or another object

(such

asanother

image).

Friend function

invocation.

Themorefamiliar Cstyle offunction invocation is

simulated

by defining

friend

functions,

wheretheargument objectshaveaccesstoeach other's

member

functions.

Using

this syntax, theabove examples wouldread:

Reallmage iml;

Reallmage im2;

double tVal;

(...)

ninety(iml); /* _{"rotate iml}

by ninety degrees" */

thresh(iml,tVal) ; /* "threshold iml at tVal" /

iml = _extend

(iml,

im2) ; /* "extend iml

by

im2" */

for (int i = _{0; i < area(iml); i++)} {;}

IMAGE STRUCTURE

CLASSES

Domain class. TheDomainclass contains an orderedlistofcoordinates ofthedefined

elementsinanimage. The imagetraversalorderis from lefttoright

(increasing

gridcolumn

number),

top

tobottom

(decreasing

grid row number).

separately. Acomparisonoftheuse ofthisclassis

illustrated

intheimplementationof grey-scale

dilation,

givenin Chapter 5

(Application Examples).

Thisexample showsthat_extractingthe

Domain_{in its entirety before}use wastes_memory,

processing time,

_{cluttersthealgorithm and}

addsanotherdata typetothesystemthatdoesnot

necessarily

addto thefunctionality. The

equivalentfunctionsadhere better totheobject-oriented paradigmthattheimagecontains all"it

needstoknowabout

itself.

It isalsothereason_{for selecting FHIA}as atheoretical_{basis: only}one

datatype_{is necessary}toperformallimagecomputations.

TheDomainclassis included in this

implementation

as_{for compatibility}with image

processingalgorithmsdescribed in

[DoG87a]

andother sources.

The onlyroutines availablefortheDomainclassis:

showDomElem show a particularDomainelement

The domain isextracted_usingtheextract Domain_{() function}ofthe

image,

anditssize

isgiven

by finding

the number ofdefinedelements

(card)

oftheimage.

Range classes. TheRangeclasses are an ordered listofthedefinedelementsofthe

image. Orderofimagetraversal isthesame asforDomain,sothe ithelement ofaRangeclass

correspondstothe ithelement oftheDomainclass extractedfromthesameimage.

There isaRangeclass_{corresponding to}eachtypeofimage:

intRange correspondstoIntlmage;

RealRange correspondstoReallmage ;

ByteRange correspondsto Bytelmage;

The utilityoftheRange classeshasalsobeensuperseded

by

theimplementationofthe

image_class,forthesamereasons astheDomain class above. The implementationofdilation in

chapter5 illustrates this. Note thatneithertheDomain or Range classeswere used_{in any}

implementation inthe_oopsSlipclasslibrary.

The only operatordefined fortheRange classesis:

showRngElem showa particular Range element

The domain isextracted_{using the}extractRange() functionofthe

image,

anditssize is

given

by finding

thenumberofdefinedelements

(card)

oftheimage.

FOR_DOMAIN_OF CONSTRUCT

Purpose. Thepurpose ofthe for_domain_of 0 constructisto implementtheimage

processingparadigm of

"processing

overthedomainof animage". For_example,inconvolution,

oneimage istranslatedover another

by doing

atranoftheorigin ofthefirst imageover_every

defined pixelofthesecond. Ateach_tran,an operation isperformed.

Syntax. Theconstruct syntax resemblesthe for0do/endforof

FORTRAN:

for_domain_of _(img)

{

statement

Theconstructis implementedasthemacro:

{Coord here = _{img.nextElemLoc ()} ;

for (int i=0; <img.card() ; i++, here=i.mg.nextElemLoc(here) )

Insidethe for_domain_of()

loop,

therearetwovariablesthatare_{automatically defined:}

here isthegrid coordinates ofthedefinedelement_presently

being

operatedon; i isa counterfrom 0to thenumber ofdefinedelements.

Thescope ofthesevariablesislocalto the

loop,

sotheconstructs canbenested

(this

is

thereasonforthe"{"

beforethedeclarationofhere.

Theconstruct mustbeterminatedwith eithertheend_f or0 statement

(img

isoptional),

or a second"}".

Forexample, tosetallthedefinedelements of an imageto theirnegative value

(the

implementationofinv):

for_domain_of ( (*this) ) {

setElem(here, -elem(here) ) ;

}

end_for_{() ;}