Abstract:
Apparatus, methods, and computer program products that provide fast and accurate means of mapping one data space into another by precisely mapping grid points between the data spaces and then by performing a bilateral-bilinear interpolation to map the points bounded by the precisely mapped grid points. The precisely mapped grid points define boundary lines that bound a data region in a source space. Each scan line mapped to the source space is dependent on the slopes of the bounding lines of the data region.

Description:
Background of the Invention  
         [0001]    1. Field of the Invention  
           [0002]    This invention relates to the field computer technology for mapping one data space to another data space.  
           [0003]    2 . Background  
           [0004]    Computers are often used to map data that exists in a source data space to a destination data space. This type of mapping is often used in “virtual reality” and “telepresence” applications. The data in the source data space can represent a warped image that is obtained by a distorting lens such as a fisheye lens or a catadioptric lens. The data in the destination data space can be presented by a presentation device such as a video screen, computer monitor or printer. The problem is how to rapidly generate the data for the destination data space from the source data space.  
           [0005]    One approach is to backward map the coordinates of a point in the destination data space to coordinates in the source data space and to obtain the value for the point in the destination data space from the mapped point in the source data space. Precisely mapping each point (for example, by using floating point calculations to perform the mapping) is expensive in either memory or computation, or both.  
           [0006]    Another approach is to precisely map a grid of points from the destination data space to the source data space. These grid points bound regions (patches) that contain pixels that have similar mapping as the grid points that bound the region. Thus, the precisely mapped grid points are used to determine coefficients for a mapping that can be applied to each point in the region. Each of the grid points in the destination data space has a corresponding grid point in the source data space. Thus, the destination grid point and the corresponding source grid point are referred to as a “point pair.” 
           [0007]    By using all four of the destination and source point pairs that bound a region, a perspective transformation can be computed and used to find the corresponding pixel in the source data space. Thus,  
         x   s     =         ax   d     +     by   d     +     t   x           ex   d     +     fy   d     +   1                 y   s     =         cx   d     +     dy   d     +     t   y           ex   d     +     fy   d     +   1                             
 
           [0008]    Can be used to perform the mapping where (x s , y s ,) is the is the resulting coordinate in the source data space, (x d , y d ) is the coordinates of the pixel in the destination data space, and a, b, c, d, e, f , t x  and t y  are the perspective transform coefficients. This calculation includes at least six multiply operations, two division operations, and six add operations. The multiply and division operations are computationally expensive. Although this equation does not generate mapping artifacts between the regions, the additional computational overhead is often prohibitive.  
           [0009]    Another approach is to generate a look-up table that provides the x s  and y s  coordinates when given the x d  and y d  coordinates. With high resolution images and high-resolution presentation devices, these look-up tables become unwieldy even with modern computers.  
           [0010]    Another approach is to approximately map the region using a less computationally expensive formula. For example, an affine transformation can be used to perform this mapping. In this circumstance, three of the four sets of destination and source point pairs are used to compute the affine coefficients for the transformation. Then coordinates that specify a pixel that in the destination data space can be used to find the corresponding pixel in the source data space. Thus,  
           
         x 
         s 
         =ax 
         d 
         +by 
         d 
         +c 
       
           
         y 
         s 
         =dx 
         d 
         +ey 
         d 
         +f  
       
           [0011]    Where (x s , y s ,) is the resulting coordinate in the source data space, (x d , y d ) is the coordinates of the pixel in the destination data space, and a, b, c, d, e and f are the affine coefficients for the grid region bounded by the precisely mapped grid points. This calculation includes four multiply operations and four add operations for each pixel in the patch and so is still computationally expensive. An additional problem with this approach is that an affine transformation often generates a very poor approximation to the perspective transformation. The affine transformation only uses three of the four point pairs that bound the region. Thus, the affine transformation can generate mapping artifacts (such as discontinuities) along edges of the quadralateral defining the region in the source space.  
           [0012]    [0012]FIG. 1 A illustrates a quadralateral patch in source space, indicated by general reference character  100 , used to show mapping artifacts generated by the affine transformation. The quadralateral patch in source space  100  is bounded by grid points (such as a point A  101 , a point B  103 , a point C  105 , and a point D  107  ). Applying an affine transformation to this region (using the points  101 ,  103 , and  105  and the corresponding points in the destination space) would generate the patch bounded by the point A  101 , the point B  103 , the point C  105  and a point D′  109  instead of approximating the original patch.  
           [0013]    [0013]FIG. 1B illustrates a presentation of a correctly mapped image, indicated by general reference character  150 , that represents a magnified image presented on a presentation device. This image does not have any mapping artifacts. It can be generated by precisely mapping each point in the destination data space to the source data space. It can also be generated by precisely mapping grid points, and using the perspective transformation previously discussed to map the points in each region defined by the grid. Compare FIG. 1B with FIG. 1C.  
           [0014]    [0014]FIG. 1C illustrates a presentation of an incorrectly mapped image, indicated by general reference character  160 , that shows mapping artifacts  161  that can result from the use of the affine transformation. As can be seen, these mapping artifacts include discontinuities in lines. Other mapping artifacts include (without limitation) texture discontinuities and color discontinuities.  
           [0015]    It would be advantageous to use a fast mapping algorithm that also provides a good approximation for a precise perspective-correct transformation that maintains continuity across patch boundaries without the computational or memory overheads associated with the prior art. Devices and computers that use these methods will operate more efficiently than those that use prior art methods will.  
         SUMMARY OF THE INVENTION  
         [0016]    The invention provides a fast and accurate means of mapping one data space into another by precisely mapping grid points between the data spaces and then by performing a bilateral-bilinear interpolation to map the points bounded by the precisely mapped grid points.  
           [0017]    One aspect of the invention is a computer-controlled method that includes the step of determining a region in a destination data space. The region is bounded by a plurality of grid points. It defines a first plurality of data points in the destination data space. The method precisely maps the plurality of grid points in the destination data space to a plurality of mapped grid points in a source data space. The source data space contains, or is associated with, a second plurality of data points. The plurality of mapped grid points define a plurality of boundary lines that represent the boundary of the region as mapped into the source data space. The method also applies a bilateral-bilinear interpolation algorithm to approximately map the first plurality of data points to the second plurality of data points.  
           [0018]    Another aspect of the invention is an apparatus that includes a central processing unit (CPU) and a memory coupled to the CPU. The apparatus also includes a region determination mechanism that is configured to determine a region in a destination data space. The region is bounded by a plurality of grid points. The region defines a first plurality of data points within the destination data space. The apparatus also includes a precise mapping mechanism that is configured to precisely map the plurality of grid points determined by the region determination mechanism to a plurality of mapped grid points in a source data space. The source data space contains (or associates) a second plurality of data points. The plurality of mapped grid points define a plurality of boundary lines that represent the boundary of the region as mapped into the source data space. The apparatus also includes a bilateral-bilinear interpolation mechanism that is configured to approximately map the first plurality of data points in the region to the second plurality of data points using the plurality of mapped grid points.  
           [0019]    Yet another aspect of the invention, is a computer program product that includes a computer usable storage medium having computer readable code embodied therein for causing a computer to map a destination data space to a source data space. When executed on a computer, the computer readable code causes the computer to effect a precise mapping mechanism, a region determination mechanism, and a bilateral-bilinear interpolation mechanism. Each of these mechanisms having the same functions as the corresponding mechanisms for the previously described apparatus.  
           [0020]    Still another aspect of the invention is a computer program product embodied in a carrier wave transmitting computer readable code therein for causing a computer to map a destination data space to a source data space. When executed on a computer, the computer readable code causes the computer to effect a precise mapping mechanism, a region determination mechanism, and a bilateral-bilinear interpolation mechanism. Each of these mechanisms having the same functions as the corresponding mechanisms for the previously described apparatus. 
       
    
    
     DESCRIPTION OF THE DRAWINGS  
       [0021]    [0021]FIG. 1A illustrates a mapping artifact resulting from an affine transformation;  
         [0022]    [0022]FIG. 1B illustrates a presentation of an image without mapping artifacts;  
         [0023]    [0023]FIG. 1C illustrates a presentation of an image with mapping artifacts;  
         [0024]    [0024]FIG. 2 illustrates a computer system capable of using the invention in accordance with a preferred embodiment;  
         [0025]    [0025]FIG. 3A illustrates a gridded destination data space in two-dimensions in accordance with a preferred embodiment;  
         [0026]    [0026]FIG. 3B illustrates a gridded source data space with a mapped destination data space in two-dimensions in accordance with a preferred embodiment;  
         [0027]    [0027]FIG. 3C illustrates a gridded destination data space with a mapped destination data space in three-dimensions in accordance with a preferred embodiment;  
         [0028]    [0028]FIG. 3D illustrates a gridded source data space with a mapped destination data space in three-dimensions in accordance with a preferred embodiment;  
         [0029]    [0029]FIG. 4A illustrates a gridded patch in two-dimensions in accordance with a preferred embodiment;  
         [0030]    [0030]FIG. 4B illustrates the gridded patch of FIG. 4A as mapped into the source data space in accordance with a preferred embodiment;  
         [0031]    [0031]FIG. 5 illustrates an overview of the process used to backward map pixels in a destination data space to a source data space in accordance with a preferred embodiment; and  
         [0032]    [0032]FIG. 6 illustrates a bilateral-bilinear interpolation algorithm that backward maps pixels in a destination region to a source data space in accordance with a preferred embodiment. 
     
    
     DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0033]    Notations and Nomenclature  
         [0034]    The following ‘notations and nomenclature’ are provided to assist in the understanding of the present invention and the preferred embodiments thereof.  
         [0035]    Procedure—A procedure is a self-consistent sequence of computerized steps that lead to a desired result. These steps are defined by one or more computer instructions. These steps are performed by a computer executing the instructions that define the steps. Thus, the term “procedure” can refer to a sequence of instructions, a sequence of instructions organized within a programmed-procedure or programmed-function, or a sequence of instructions organized within programmed-processes executing in one or more computers.  
         [0036]    Operating Environment  
         [0037]    [0037]FIG. 2 illustrates a computer, indicated by general reference character  200 , that incorporates the invention. The computer  200  includes a processor  201  having a central processor unit (CPU)  203 , a memory section  205 , and an input/output (I/O ) section  207 . The I/O section  207  is connected to a presentation device  211 , a disk storage unit  213  and a CD-ROM drive unit  215 . The CD-ROM drive unit  215  can read a CD-ROM medium  217  that typically contains a program and data  219 . The CD-ROM drive unit  215  (along with the CD-ROM medium  217  ) and the disk storage unit  213  comprise a filestorage mechanism (a filesystem). Some embodiments of the invention include a network interface  221  that connects the computer  200  to a network  223 . An application program  225  executes from the memory section  205 . The application program  225  can be loaded into the memory section  205  over the network  223  or from the filesystem. In one embodiment of the invention, the application program  225  includes computer code that causes the computer to perform the inventive steps. The CD-ROM drive unit  215  (along with the CD-ROM medium  217  ) are illustrative of mechanisms that can be used to read computer code from a removable media. One skilled in the art will understand that not all of the displayed features of the computer  200  need to be present for the invention.  
         [0038]    Data Space  
         [0039]    One aspect of the invention maps points between two data spaces. FIG. 3A through FIG. 3D illustrate some of the possible data spaces that can be mapped by this aspect of the invention.  
         [0040]    [0040]FIG. 3A illustrates a gridded destination data space  300  showing a first grid point  301 , a second grid point  303 , a third grid point  305 , and a fourth grid point  307 . These points are bounding points for the destination data space. Each of the intersections in the destination data space (for example a fifth grid point  309  ) is precisely mapped to a source data space. The grid points bound regions that contain data points that will be approximately mapped to the source data space. For example, the third grid point  305  and the fifth grid point  309  are two of the four grid points that bound a region  311  that contains points having mappings that will be interpolated. A bilateral-bilinear interpolation algorithm performs this approximate mapping. The bilateral-bilinear interpolation algorithm is subsequently described with respect to FIG. 5 and FIG. 6 as applied to patches in a two-dimensional data space.  
         [0041]    [0041]FIG. 3B illustrates a gridded source data space  350  indicating how the destination data space is mapped to the source data space. The resolution of the gridded destination data space  300  and the gridded source data space  350  need not be the same. The gridded source data space  350  can contain (or reference) warped image data that represents a true image that has been warped by a lens. One skilled in the art will understand that a physical lens need not be used to generate the warped image as ray-tracing techniques through a virtual lens can also be used to generate the warped image. A virtual lens can be used to generate images in a virtual-space. Once the image is generated, the invention can be used to present the image.  
         [0042]    One aspect of the invention backward maps the destination data space to the source data space using a mapping that generates a perspective corrected image in the destination data space. One step in this mapping process precisely maps the first grid point  301 , the second grid point  303 , the third grid point  305 , the fourth grid point  307 , the fifth grid point  309 , and other grid points to the gridded source data space  350 . These grid points map to a mapped first grid point  301 ′, a mapped second grid point  303 ′, a mapped third grid point  305 ′, a mapped fourth grid point  307 ′, a mapped fifth grid point  309 ′ and other grid points respectively in the source data space. Thus, the region  311  is mapped to a mapped region  311 ′.  
         [0043]    Notice that the gridded destination data space  300  when mapped into the gridded source data space  350  need not result in a parallelogram—the slopes of each of the lines defined by the mapped grid points can be different.  
         [0044]    [0044]FIG. 3C illustrates a 3-D gridded destination data space, indicated by general reference character  360 , that has a first plane  361  (bounded by the first grid point  301 , the second grid point  303 , the third grid point  305  and the fourth grid point  307  ) and a second plane  363  (sp) (bounded by a sp-first grid point  365 , a sp-second grid point  367 , a sp-third grid point  369  and another point that cannot be seen in FIG. 3C).  
         [0045]    [0045]FIG. 3D illustrates a 3-D gridded source data space, indicated by general reference character  370 , that indicates how the 3-D gridded destination data space  360  is mapped to the 3-D gridded source data space  370 . A mapped first plane  361 ′ is bounded by the mapped first grid point  301 ′, the mapped second grid point  303 ′, the mapped third grid point  305 ′, and the mapped fourth grid point  307 ′. A mapped second plane  363 ′ (msp) is bounded by a msp-second grid point  367 ′, and a msp-third grid point  369 ′, and two other points that cannot be seen in FIG. 3D.  
         [0046]    [0046]FIG. 3C and FIG. 3D show how grid points can be imposed on three-dimensional spaces. Once the grid points are precisely mapped, the points contained in the region (the volume) between and including the first plane  361  and the second plane  363  can be interpolated by extending the subsequently described techniques. Similar techniques can be applied to n-dimensional spaces.  
         [0047]    Although the bilateral-bilinear interpolation algorithm is applicable to n-dimensional spaces, subsequent discussion of the algorithm is directed to two-dimensional spaces containing image data. Each region is a two-dimensional patch containing points that represent pixels. One skilled in the art will understand how to modify the described algorithm to be applicable to higher dimensional spaces, for non-image data, and to a source data space that references the data. Such a one will also understand that the invention can be used (without limitation) to map a viewport onto spherical, cylindrical, and panoramic spaces.  
         [0048]    [0048]FIG. 4A illustrates a patch in destination data space, indicated by general reference character  400 , bounded by a first grid point  401 , a second grid point  403 , a third grid point  405  and a fourth grid point  407 . The destination patch  400  contains a number of pixels (in the illustration, 36 pixels) of which a pixel  409  is but one. The bilateral-bilinear interpolation algorithm efficiently generates data values for the pixels contained in the destination patch  400 . In this particular illustration, the 36 pixels are arranged in six scan lines. Each scan line is six pixels long. One skilled in the art will understand that the destination patch  400  need not be square and may include more or fewer pixels than the  36  used in the illustration. The grid points are mapped to the source data space as is shown with respect to FIG. 4B.  
         [0049]    [0049]FIG. 4B illustrates a mapped patch in source data space, indicated by general reference character  420 , indicating some of the parameters used by the bilateral-bilinear interpolation algorithm. The mapped patch  420  is bounded by the mapped first grid point  401 ′, the mapped second grid point  403 ′, the mapped third grid point  405 ′, and the mapped fourth grid point  407 ′ each of which have been precisely mapped to the source data space from the corresponding points in the destination data space. The data that is used to generate the value for the pixel  409  in the destination data space is located at a mapped pixel contribution area  409 ′. The mapped pixel contribution area  409 ′ contains pixels of a warped image at a resolution possibly different from the pixel resolution in the destination data space. Techniques known in the art are used to determine the value of the pixel  409  based on the information within the mapped pixel contribution area  409 ′.  
         [0050]    The mapped grid points define lines that bound the mapped patch  420 . Thus, the mapped first grid point  401 ′ and the mapped third grid point  405 ′ define a second boundary line  421 ; the mapped second grid point  403 ′ and the mapped fourth grid point  407 ′ define a third boundary line  423 ; the mapped first grid point  401 ′ and the mapped second grid point  403 ′ define a first boundary line  425  and a mapped third grid point  405 ′ and a mapped fourth grid point  407 ′ define a final boundary line  427 . One skilled in the art will understand that a different geometry can be used other than the one described.  
         [0051]    A first slope  428  represents the slope of the first boundary line  425 . A second slope  429  represents the slope of the second boundary line  421  and in the two-dimensional case includes delta-x and delta-y components. A third slope  431  represents the slope of the third boundary line  423 . A final slope  435  represents the slope of the final boundary line  427 .  
         [0052]    The bilateral-bilinear interpolation algorithm operates by determining the second slope  429  and the third slope  431  for the boundary lines. The second slope  429  and the third slope  431  need not be the same. Each of these slopes is used to determine a respective delta-x and delta-y value that is dependent on the number of scan lines in the destination patch  400  (N yd ). Next, each pixel in the first scan line in the destination patch  400  is iterated. To do this, a delta-x and delta-y representing the first slope  428  is determined responsive to the number of pixels in the scan line contained by the destination patch  400  (N xd ), and the coordinates of the starting pixel and the ending pixel. As each destination pixel is iterated the mapped pixel contribution area  409 ′ in the source data space is evaluated to determine a value for the destination pixel. As the destination pixel is advanced, the corresponding position in the source data space is advanced by the delta-x and delta-y corresponding to the first slope  428 . Once the first scan line has been processed subsequent scan lines in the destination patch  400  are processed. The starting coordinates for a subsequent scan line in the mapped patch  420  is advanced by the delta-x and delta-y corresponding to the second slope  429  and the ending position of the subsequent scan line in the mapped patch  420  is advanced by the delta-x and delta-y corresponding to the third slope  431 . Thus, the subsequent slope for each mapped scan line changes dependent on the slope of the second boundary line  421  and the third boundary line  423 . Thus for example, a subsequent slope  437  can be (and usually is) different from the first slope  428 , the final slope  435  and any other subsequent slope.  
         [0053]    Each subsequent scan line in the destination patch  400  is iterated (such that the last subsequent scan line is the final boundary line  427  ).  
         [0054]    One skilled in the art will understand that the bilateral-bilinear interpolation algorithm, previously summarized and subsequently described in detail, assures that adjacent patches correctly align. Thus, the bilateral-bilinear interpolation algorithm does not generate mapping artifacts as shown in FIG. 1A and FIG. 1C.  
         [0055]    Data Space Mapping  
         [0056]    [0056]FIG. 5 illustrates a mapping process, indicated by general reference character  500  used to backward map data points in a destination data space to data points in a source data space. The mapping process  500  initiates at a ‘start’ terminal  501  and continues to an ‘initialization’ procedure  503 . The ‘initialization’ procedure  503  performs initialization steps for the mapping process  500 . These steps can include steps for allocating memory for the source data space, allocating memory for the destination data space, determining the resolution of the presentation device (if any) used to present the destination data, and the spacing of grid points in the destination data space. Next, the mapping process  500  continues to a ‘load source data’ procedure  505  that inputs the source data into the source data space. The source data can be read (without limitation) from a file, a scanner device, a video device, from a network, a medical diagnostic tool or other similar device. In addition, the source data can represent a portion of a video data stream (the video data stream can be compressed; in addition the video stream can be live video, stored video or computer generated video). The ‘load source data’ procedure  505  need not complete before the mapping process  500  continues to a ‘determine grid points’ procedure  507 . The ‘determine grid points’ procedure  507  uses the resolution and the size of the destination data space and possibly other parameters to determine the size of the region. Depending on the configuration of the source data space and the destination data space, the region can be n-dimensional. The region defines the data points that will be interpolated instead of being precisely mapped. The bilateral-bilinear interpolation algorithm can be applied to n-dimensional spaces. When the region is two-dimensional, the region is referred to as a patch.  
         [0057]    A ‘precisely map grid points’ procedure  508  precisely maps the grid points that bound the selected region in the destination data space to points in the source data space. The ‘precisely map grid points’ procedure  508  uses well known transformations that can include floating point multiplication and division operations to precisely locate points in the source data space that correspond to the grid points in the destination data space.  
         [0058]    Once the grid points that bound the region have been precisely mapped, the mapping process  500  continues to an ‘iterate region’ procedure  509  that iterates each region in the destination data space that is to be interpolated. A ‘get grid point coordinates in source data space’ procedure  511  obtains the grid points that bound the iterated region. Then a ‘map points in region’ procedure  513  applies a bilateral-bilinear interpolation algorithm to approximately map the points in the region to a portion of the data in the source data space. The bilateral-bilinear interpolation algorithm is subsequently described with respect to FIG. 6.  
         [0059]    The mapping process  500  repeats to the ‘iterate region’ procedure  509  until all the regions in the destination data space are iterated. The resulting data in the destination data space can then be presented by a ‘present destination space data’ procedure  514 . This presentation can be accomplished (without limitation) by visually presenting the information by using a presentation device such as a printer or monitor, by providing a printout of the data, or by subsequent processing of the data using other mechanisms. The mapping process  500  completes through an ‘end’ terminal  515 .  
         [0060]    One skilled in the art will understand that the precisely mapped grid points define lines in the source data space that can serve as boundary lines for the mapped region in the source data space.  
         [0061]    [0061]FIG. 6 illustrates a bilateral-bilinear interpolation algorithm process, indicated by general reference character  600  that is invoked from the ‘map points in region’ procedure  513  of FIG. 5. A preferred embodiment is directed towards mapping data between two two-dimensional data spaces. This embodiment can be used to generate a perspective corrected image from a warped image that was generated from a true image projected through a lens (such as a fisheye lens or a catadioptric lens). One skilled in the art will understand that a physical lens need not be used to generate the warped image as ray-tracing techniques through a virtual lens can also be used to generate the warped image.  
         [0062]    The bilateral-bilinear interpolation algorithm process  600  initiates at a ‘start’ terminal  601  and continues to an ‘initialize’ procedure  603 . The ‘initialize’ procedure  603  determines the slopes for the boundary lines in the source data space that define the limits of the scan lines in the patch. The slope is defined by a delta-x and delta-y that depend on the number of scan lines in the patch. The ‘initialize’ procedure  603  also defines the starting and ending coordinates in the source data space for the first scan line that is to be interpolated. For a patch bounded by points P 0 (x 0 ,y 0 ), P 1 (x 1 ,y 1 ), P 2 (x 2 ,y 2 ), and P 3 (x 3 ,y 3 ) (these points corresponding to the mapped first grid point  401 ′, the mapped second grid point  403 ′, the mapped third grid point  405 ′, and the mapped fourth grid point  407 ′ of FIG. 4B) in the source data space and where the patch in the destination data space includes N yd  scan lines, each scan line containing N xd  pixels, the ‘initialize’ procedure  603  can include steps similar to:  
         [0063]    dxl=(x2−x0)/nyd; // determine slope of left line  
         [0064]    dyl=(y2−y0)/nyd;  
         [0065]    dxr=(x3−x1)/nyd; // determine slope of right line  
         [0066]    dyr=(y3−y1)/nyd;  
         [0067]    startx=x0; // set starting coordinates  
         [0068]    starty=y0;  
         [0069]    endx=x1; // set ending coordinates  
         [0070]    endy=y1;  
         [0071]    Next, the bilateral-bilinear interpolation algorithm process  600  continues to an ‘iterate scan line in patch’ procedure  605  that iterates each scan line in the patch in the destination data space. When all the scan lines in the patch have been iterated, the bilateral-bilinear interpolation algorithm process  600  completes through an ‘end’ terminal  607 . The number of iterations to iterate each scan line in the patch is the value of nyd.  
         [0072]    An ‘initialize working variables’ procedure  609  initializes the variables used for the iteration of the pixels in the iterated scan line. These initializations include determining the slope for the iterated scan line based on the coordinates of the start point and the end point of the scan line in the source data space. The start point of the scan line substantially lies on the boundary line defined by P 0  and P 2 . The end point of the scan line substantially lies on the line defined by P 1  and P 3 . Thus, these lines bound each scan line. The slope of the scan line is determined using the start point, the end point, and the number of pixels in the scan line in the patch. The ‘initialize working variables’ procedure  609  can include steps similar to:  
         [0073]    dx=(endx−startx)/nxd; // determine scan line slope  
         [0074]    dy=(endy−starty)/nxd;  
         [0075]    sx=startx;  
         [0076]    sy=starty;  
         [0077]    An ‘iterate each pixel in scan line’ procedure  611  iterates each pixel in the destination scan line. To iterate each pixel in the scan line requires N xd  iterations. When all the pixels in the line have been iterated, the bilateral-bilinear interpolation algorithm process  600  continues to an ‘advance to next scan line in patch’ procedure  613 . The ‘advance to next scan line in patch’ procedure  613  advances the startx, starty, endx and endy values by dxl, dyl, dxr, and dyr respectively. Thus, the ‘iterate each pixel in scan line’ procedure  611  determines a subsequent starting point and a subsequent ending point that bound a subsequent line that has a subsequent line slope. Thus, the subsequent line depends on the slope of the boundary lines. The ‘advance to next scan line in patch’ procedure  613  can include steps similar to:  
         [0078]    startx+=dxl; // determine new scan line start  
         [0079]    starty+=dyl; // coordinates  
         [0080]    endx+=dxr; // determine new scan line end  
         [0081]    endy+=dyr; // coordinates  
         [0082]    One skilled in the art will understand that the interpolation of each scan line thus depends on the slope of the patch&#39;s bounding lines. Thus, the end position of each scan line in one region substantially matches the start position of each scan line for an adjacent patch. The result is that there are no interpolation artifacts between adjacent patches (or regions).  
         [0083]    Once the ‘advance to next scan line in patch’ procedure  613  completes, the bilateral-bilinear interpolation algorithm process  600  continues to the ‘iterate scan line in patch’ procedure  605  to iterate the next scan line in the patch or to exit if all scan lines have been iterated.  
         [0084]    A ‘set pixel’ procedure  615  obtains the data value for the pixel in the destination data space from the data area specified by sx and sy in the source data space. One skilled in the art will understand how to obtain the value of a destination pixel from the source data space given coordinates in the source data space. Such a one will also understand how to combine data values in the source data space to generate the data value in the destination data space.  
         [0085]    Once the ‘set pixel’ procedure  615  completes, the bilateral-bilinear interpolation algorithm process  600  continues to an ‘advance to next pixel in scan line’ procedure  617 . The ‘advance to next pixel in scan line’ procedure  617  advances sx and sy by dx and dy respectively. Next, the bilateral-bilinear interpolation algorithm process  600  continues to the ‘iterate each pixel in scan line’ procedure  611  until each pixel in the scan line has been iterated.  
         [0086]    One skilled in the art will understand that the invention improves the mapping between two data spaces while still maintaining high performance.  
         [0087]    From the foregoing, it will be appreciated that the invention has (without limitation) the following advantages:  
         [0088]    1) The invention dramatically reduces mapping artifacts when mapping from one data space to another.  
         [0089]    2) The invention provides a high performance mapping capability between data spaces.  
         [0090]    3) The invention provides a superior real-time presentation of a visual image when the source data space contains warped image data.  
         [0091]    Although the present invention has been described in terms of the presently preferred embodiments, one skilled in the art will understand that various modifications and alterations may be made without departing from the scope of the invention. Accordingly, the scope of the invention is not to be limited to the particular invention embodiments discussed herein.