SGI Techpubs Library
Techpubs Library
Home/Search
Books by Product
What's New
Help


IRIX 6.5 Linux Hardware Freeware (IRIX) Windows
   
To further optimize your search, select from the following options:
 Search only in:
Search only titles    Show only 1 hit/book      Results/page:


IRIX 6.5  »  Books  »  Developer  »  
ImageVision Library™ Programming Guide
(document number: 007-1387-050  /  published: 1996-11-29)   additional info | download

This manual describes how to use the ImageVision Library (IL) to perform image processing tasks. It is intended for programmers writing image processing applications using C++, C, or Fortran. The manual describes the IL architecture, how IL application programs can access external data, the operations that can be performed on an image, how to display images on a monitor. For advanced applications, the manual also describes how programmers can optimize an application, and how they can extend the library by adding image operators, file formats, and memory management methods unique to that application.

table of contents (expand all | collapse all)  |  list of figures  |  list of tables  |  list of examples  |  list of procedures  |  

   Front Matter
 - About This Guide
       What This Guide Contains
       Suggestions for Further Reading
       Adding a User Interface to Your ImageVision Library Program
       Style Conventions
 + Chapter 1. Writing an ImageVision Library Program
 - Chapter 2. The ImageVision Library Foundation
       The IL Class Hierarchy
     - Foundation Classes
           The ilLink Class
           The ilImage Class
     - Image Attributes
           Error Codes
           Size
           Data Type
           Data Ordering
         - Color Model
               Determining the Color Model
           Determining Operator Data Types, Ordering, Working Types, and Definable Fields
           Color Palette
           Orientation
         - Fill Value
               Creating Fill Values
         - Minimum and Maximum Pixel Values
               Setting Maximum and Minimum Pixel Values
               Setting Maximum and Minimum Pixel Values for a Channel
               Setting Maximum and Minimum Scaling Values For Color Conversion
           Data Compression
     - The Cache
           Managing Cache
           Priority
           Page Size
           Multi-threaded Paging Support
     - Accessing Image Data
         - Two-dimensional Functions
               getTile() and setTile()
               copyTile()
               The Left-Shift or Output Operator, <<
               getSubTile() and setSubTile()
               getPixel() and setPixel()
               fillTile()
           Three-dimensional Functions
         - Data Access Support Functions
               Using getStrides()
               clipTile()
           Orientation Support
           Geometric Mapping Support
     - The IL Execution Model
           On-demand Processing
         - Multi-threading
               How Multi-threading Works
         - Using Graphics Hardware for Acceleration
               Disabling Hardware Acceleration
               Page Borders
     - Working with Image Chains
         - Dynamically Reconfiguring a Chain
               Replacing a Chained Operator
               Querying Chained Images
               Adding and Removing Inputs
         - Propagating Image Attributes
               Changing Image Attributes
               Automatic Color Conversion of Inputs
       Object Properties
 - Chapter 3. Accessing External Image Data
     - Supported IFL Image File Formats
           FIT
           GIF
           JFIF (JPEG)
           ilTCL
         + Kodak Photo CD Image Pac
           Kodak Photo CD Overview Pac
           PNG
           PPM/PGM/PBM
           Raw
           SGI
           TIFF
           YUV
           Alias
           SOFTIMAGE
     - Using IL to Access an Image
           Opening an Existing File
           Creating an Image File
           Setting a File's Compression
           Querying a File Image
         - Setting and Getting Special Image Properties
               Using getItem()
               Using setItem()
               Using haveAttributesChanged()
     - Importing and Exporting Image Data
           Images in Memory
 - Chapter 4. Operating on an Image
     - Image Processing Operators Provided with IL
         - Color Conversion and Transformation
               Color Conversion
               ilFalseColorImg
               ilSaturateImg
         - Arithmetic and Logical Transformations
               Single-input Operators
               Dual-input Operators
         - Geometric Transformations
               Warping an Image
               Resampling Methods
               Rotating, Zooming, and Flipping an Image
         - Spatial Domain Transformations
               Convolving an Image
               Blurring or Sharpening an Image
               Rank Filtering an Image
               Morphological Operators
           Edge Detection
         + Frequency Domain Transformations
         - Generation of Statistical Data
               An Image's Histogram
               Minimum, Maximum, Mean, and Standard deviation
               Other Functions
         - Radiometric Transformations
               Scaling an Image
               Histogram Operators
               The Threshold Operator
               ilLutImg
               ilPiecewiseImg
         - Combining Images
               ilBlendImg
               ilMergeImg
               ilCombineImg
           Constant-valued Images
           Using a Null Operator
     - Defining a Region of Interest
         - Creating an ilRoiImg
               A Rectangular ROI
           Creating an ilSubImg
 - Chapter 5. Displaying an Image
     - Overview of the Display Facility
           Scrolling Windows
     - A Simple Interactive Display Program
           Sample Program Code
         - Sample Program Comments
               Step 1: Open an Input Image File and Create a Threshold Image
               Step 2: Open an X Window and Create an ilDisplay Object
               Step 3: Process Events
     - Creating an ilDisplay
           Opening an X Window and Creating an ilDisplay Object
           Adding a View to the ilDisplay Object
           Deallocating the Display
       Choosing OpenGL or X Rendering
     - View and Display Basics
           Background Color
         - Borders
               Border Styles
           Preventing View Operations
           Deferring Drawing
           The Drawing Area
           Managing the Cache
         - Mode Flags
               Display Flags
               Coordinate Flags
               Wipe Mode Flags
               Align Mode Flags
     - Managing Views
           Adding Images
           Stereo Viewing
           Retrieving Views
           Retrieving Images
           Removing Views
           Replacing Images
           Reordering the View Stack
           Finding a View
           Finding an Edge
           Operating on a Pixel
           Locating a Point
     - Applying a Display Operator
         - Drawing Views
               display()
               paint()
               qpaint()
               redraw()
               save()
               setStaticUpdate()
         - Relocating Views and Images
               alignImg()
               alignView()
               moveImg()
               moveView()
               split()
         - Resizing Views
               resize()
               wipe()
               wipeSplit()
               wipeSize()
           Updating Views
           Using setMouse()
       A More Complicated Interactive Display Program
 - Chapter 6. Extending ImageVision Library
     - Deriving From ilImage
         - Data Access Functions
               Implementing qGetSubTile3D()
               Implementing qSetSubTile3D()
               Implementing qCopyTileCfg()
               Implementing qFillTile3D() and qFillTileRGB()
               Implementing qLockPageSet()
               Implementing qGetTile3D()
               Implementing qSetTile3D()
               Support Functions
           Color Conversion
         - Managing Image Attributes
               The reset() Function
               Allowing Attributes to Change
               Preventing Attributes From Changing
               Setting Altered and Stuck Flags
               Setting Attributes Directly
               Adding New Attributes
       Deriving From ilCacheImg
       Deriving From ilMemCacheImg
     - Implementing an Image Processing Operator
         - Deriving From ilOpImg
               The Constructor
               The resetOp() Function
               The keepPrecision() Function
         - Handling Image Processing
               prepareRequest Phase
               executeRequest Phase
               finishRequest Phase
               Clamping Processed Data
               Setting Minimum and Maximum Pixel Values
         - Deriving From ilMonadicImg or ilPolyadicImg
               Deriving From ilArithLutImg
               Deriving From ilHistLutImg
         - Deriving From ilSpatialImg
               Deriving From ilConvImg or ilSepConvImg
         - Deriving New Classes From ilWarpImg and ilWarp
               Deriving New Classes From ilWarp
           Deriving From ilFMonadicImg or ilFDyadicImg
           Deriving From ilFFiltImg
     - Deriving From ilRoi
           Using an ROI: The ilRoiIter class
           Deriving New Classes From ilRoi
           Deriving New Classes From ilRoiIter
 - Chapter 7. Optimizing Your Application
     - Managing Memory Usage
         - Optimizing Use of Cache
               Cache Size
               Effect of Multi-threading on Cache
               Cache Priority
               Monitoring the Cache
         + Page Size
           Buffer Space
     - Using Hardware Acceleration
         - Using Accelerated Operators
               Accelerating ilAddImg, ilBlendImg, ilMaxImg, ilMinImg, ilMultiplyImg, and ilSubtractImg Operators
               Accelerating ilAndImg, ilInverImg, and ilXorImg Operators
               Accelerating ilConvImg and ilSepConvImg Operators
               Using the ilFalseColorImg Operator
               Using ilLutImg, ilHistLutImg, and ilThreshImg Operators
               Using ilScaleImg, ilHistScaleImg, and ilNegImg Operators
               Accelerating ilWarpImg Operators
               Accelerating the ilImgStat Operator
           Understanding the OpenGL Imaging Pipeline
           Composing Operators
           Pixel Buffers and Multi-Pass Acceleration
         - Texture
               Seeing Evidence of Pixel Buffer Use
           Texture Allocation
     - Hardware-Specific Acceleration Restrictions
           General Restrictions
           InfiniteReality
           Reality Engine
           Impact/High Impact
           Indy/Indigo2
     - Hardware Hints
         - Using IL-Recognized Hints
               Using the Hint ID
               Using the Hint Name
               IL-Recognized Hints
         - Creating Your Own Hints
               Hint Lists
 - Chapter 8. The Programming Environment
     - Compiling and Linking an IL Program
         - Programs Written in C++
               A Sample Makefile
         - Programs Written in C
               A Sample Makefile
       Reading the Reference Pages
       Image Tools
       Online Source Code
     - Environment Variables
           Caching Configuration Issues
           Hardware-Acceleration Configuration Issues
           Hardware Display Configuration Issues
           Monitoring Control Issues
           Multi-Threading Configuration Issues
 - Appendix A. What is New in Version 3.1
       keepPrecision() Added to ilOpImg
       Multiprocessing on Single CPU Machines Enabled
       Additional Image Formats Supported
       ELT Performance Enhanced
       Choosing OpenGL or X Rendering
       API Change for ilImgStat
 - Appendix B. What is New in Version 3.0
       Overview of Changes in 3.0
     - Understanding the New Features
           Support for OpenGL and Hardware Acceleration
           64-bit Address Space Support
         - Understanding New Classes
               ilAffineWarp
               ilCallback
               iflColormap
               ilCompoundImg
               ilELTImg
               ilFPolarImg
               ilFPolyadicImg
               ilFrameBufferImg
               ilMath
               ilPolyWarp
               ilPolyadicImg
               ilTiePointList
               ilTimeoutTimer
               ilTimer
               ilWarp
     - Understanding the Changes to the Existing Features
           Multi-threading Architecture Changes
         - Asynchronous Operations
               Deriving Image Operators
               Image Format library
               File formats
               Renamed Types Now Defined in IFL
           Changes to the Display Facility
           Error handling
           Polynomial Coordinate Structures
           Run-time Object-Type Query Macros
         - Changes to Existing Classes
               ilCacheImg
               ilClassId
               ilDilateImg
               ilDisplay
               ilErodeImg
               ilFDyadicImg
               ilFFTOp
               ilFFiltImg
               ilFMonadicImg
               ilFalseColorImg
               ilFileImg
               ilFsDitherer
               ilGBlurImg
               lHistLutImg
               ilHistScaleImg
               ilImage
               ilImgStat
               ilIndexableList
               ilLink
               iflLut
               ilLutImg
               ilMemCacheImg
               ilMemoryImg
               iflName
               ilOpImg
               ilPage
               ilPropSet
               ilSepConvImg
               ilSpatialImg
               ilSpinLock
               ilSubImg
               ilRoiImg
               ilMergeImg
               ilTieWarpImg
               ilViewer
               ilWarpImg
     - Backwards Compatibility with IL 2.5
           Automatic Class Name Conversion
       New Derivations for Classes
 - Appendix C. Introduction to C++
     - Objects and Classes
           Overloaded Functions
       Inheritance
       Public versus Protected versus Private
       Passing by Reference
       Default Values
       Class Declaration Format
       Linking with Libraries in Other Languages
       Referring to Function Names
   Appendix D. Summary of All Classes
 - Appendix E. Implementing Your Own Image File Format
     - Deriving and Implementing Your Image File Format Class
           Opening an Existing File
           Creating a New Image File
         - Closing a File
               Flushing the Buffer
           Parsing the File Name
         - Reading and Writing Formatted Data
               Using getTile()
               Using setTile()
               Using getPage()
               Using setPage()
         - Functions that Manipulate the Image Index
               Using getNumImgs()
               Using getCurrentImg()
               Using setCurrentImg()
           Adding Images to Image Files
     - Deriving an Image File Format from iflFormat
           Deriving Subclasses
           Virtual Function Descriptions
           Sample Code for Virtual Function Definitions
     - Registering an Image File Format
           Using the File Format Database
 - Appendix F. Auxiliary Classes, Functions, and Definitions
     - Auxiliary Classes
           iflConfig
           Using iflLut
     - Useful Functions
           Computing the Size of Data Types
           Minimum and Maximum Comparisons
           Converting to Color-index Mode
     - Convenient Structures
           Coordinate Data Structures
     - Error Codes
           ilStatus Error Codes
           iflStatus Error Codes
     - Enumerated Types and Constants
           Describing Image Attributes
 - Appendix G. Using the Electronic Light Table
     - Understanding How ELT Works
           DeWarping the Image
           RotZooming the Image
           Convolving the Image
           Collecting Histogram Data
           Dynamically Adjusting the Image
           DeWarping the Image Data
           Enabling and Disabling Operators
       Setting Operator Values
     - Understanding Accelerated Performance
           Look-ahead Algorithms
           Hardware Acceleration
           Image Size
       Choosing a Display in ELT Applications
       Creating an ELT Application
       Understanding the ilELTImg API
 - Appendix H. Results of Operators
       Color Conversion
       Arithmetic and Logical Transformations
       Geometric Transformations
       Spatial Domain Transformations
       Edge Detection
       Frequency Domain Transformations
       Radiometric Transformations
       Combining Images
   Index


home/search | what's new | help