SGI Techpubs Library

The new home for SGI documentation is the SGI Customer Portal, This site will be redirected to the new location later this month.

Techpubs Library
Books by Product
What's New

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
     - A Sample Program in C++
           C++ Version of the Sample Program
         - More about the Sample Program
               Header Files
               Step 1: Open the File of Image Data
               Step 2: Create IL Objects for Sharpening and Rotating
               Step 3: Open a Window for Display
               Step 4: Display the Processed Data
               Step 5: Display Until the User Quits
               Step 6: Write the Processed Data to a File
     - The C Interface
           Creating and Deleting C++-style Objects
           Calling Functions
           Including Header Files
       A Sample Program in C
 - Chapter 2. The ImageVision Library Foundation
       The IL Class Hierarchy
     - Foundation Classes
           The ilLink Class
           The ilImage Class
     - Image Attributes
           Error Codes
           Data Type
           Data Ordering
         - Color Model
               Determining the Color Model
           Determining Operator Data Types, Ordering, Working Types, and Definable Fields
           Color Palette
         - 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
           Page Size
           Multi-threaded Paging Support
     - Accessing Image Data
         - Two-dimensional Functions
               getTile() and setTile()
               The Left-Shift or Output Operator, <<
               getSubTile() and setSubTile()
               getPixel() and setPixel()
           Three-dimensional Functions
         - Data Access Support Functions
               Using getStrides()
           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
           JFIF (JPEG)
         - Kodak Photo CD Image Pac
               Photo CD Images
               Photo CD Color Model
           Kodak Photo CD Overview Pac
     - 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
         - 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
         - Combining Images
           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
         - Relocating Views and Images
         - Resizing Views
           Updating Views
           Using setMouse()
       A More Complicated Interactive Display Program
 - Chapter 6. Extending ImageVision Library
     + Deriving From ilImage
       Deriving From ilCacheImg
       Deriving From ilMemCacheImg
     + Implementing an Image Processing Operator
     - 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
               Optimum Page Size
               Maximizing Efficiency When Copying Pages
           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
           Reality Engine
           Impact/High Impact
     - 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
 - Appendix C. Introduction to C++
     - Objects and Classes
           Overloaded Functions
       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
           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

Home    •     What's New    •     Help    •     Terms of Use    •     Privacy Policy    •

© 2009 - 2015 Silicon Graphics International Corp. All Rights Reserved.