|Publication number||US7379063 B2|
|Application number||US 10/901,603|
|Publication date||May 27, 2008|
|Filing date||Jul 29, 2004|
|Priority date||Jul 29, 2004|
|Also published as||US20060022978, WO2006026013A1|
|Publication number||10901603, 901603, US 7379063 B2, US 7379063B2, US-B2-7379063, US7379063 B2, US7379063B2|
|Inventors||Christopher G. Hoff|
|Original Assignee||Raytheon Company|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (28), Non-Patent Citations (2), Referenced by (9), Classifications (10), Legal Events (2)|
|External Links: USPTO, USPTO Assignment, Espacenet|
1. Field of the Invention
This invention relates to mapping applications, and more specifically to a mapping application for rendering pixel imagery on platforms with limited processing power and memory and small display sizes.
2. Description of the Related Art
Hand held devices are rapidly evolving beyond their use as an address book, calendar, note pad, etc. They are merging with other technologies to provide cellular telephone service, email, wireless internet and other applications. Continuing improvements in processor speed, memory, displays and battery power are making the hand held devices a powerful and ubiquitous tool for consumers, business, and the military.
Mapping applications allow users to display and navigate maps on a hand held display using GPS technology. Mapping application software should support the ability to pan around a map, zoom in and out, manipulate navigation objects, and view a tracked position relative to displayed maps in near real-time, e.g. at least 10 frames per second. Military handsets usually have additional direction-finding hardware such as digital compass and accelerometers, which make the application feature of “track-up” (the ability to rotate the map relative to user orientation) desirable for that market. These requirements have to be implemented on a battery-powered handheld device with limited processing power, memory and display size. Therefore, the application software must be very efficient.
Most consumer GPS mapping applications utilize line segment data to represent roads, land-masses, and other boundaries. Consumer applications such as those seen on Garmin, Magellan, or standalone Pocket PC suites are capable of displaying line segment data. However, their frame-rate is limited by the need to redraw all of the line segments on-screen every time the view of the map is changed. These applications alleviate the problem somewhat by preprocessing the line segment data into spatial data structures to skip the clipping step. They also employ several drawing tricks such as only drawing certain line segment data at particular zoom levels, e.g., only draw freeways at distant zoom levels, and only drawing all of the line segment data when the user “stays still”, i.e. doesn't pan or zoom the screen rapidly. Such optimizations allow these applications to achieve a moderate performance level of a few frames per second at best. However, some of the drawing tricks employed can have the effect of temporarily disorienting the user when they are rapidly panning or zooming. Most of these applications do not support rotation.
Military applications and certain consumer applications use detailed imagery, like topographic maps or pictures taken from satellites or surveillance aircraft. These maps typically take the form of large picture imagery, composed of pixel data rather than line segment data. The application software that supports these types of maps must process a lot more data to perform the same display and navigation tasks. Applications such as ESRI's ArcPad and MapServer CE support displaying these types of maps. However, on a platform such as a PDA having limited memory and processing power, the supported frame rate is very slow, a slide show at best. These applications use rendering algorithms that are more efficient at panning than zooming, so they typically limit zoom capability to a “step” zoom between a few constant defined zoom levels so that the slow update rate is less noticeable. This can have the effect of temporarily disorienting the user when “jumping” from one zoom level to the other. In addition, rotating picture maps is a feature that is completely unsupported by any existing PDA mapping tools.
A new approach to the PDA mapping application problem for pixel imagery is needed, especially in the military mapping space. The performance of panning and zooming, particularly important because of the small PDA display size, needs to be increased by at least an order of magnitude to provide near real-time response. Ideally, this would be done without the limitations that the known approaches impose upon the user. A real-time “smooth-zoom” feature is desirable in situations where the user cannot afford to temporarily lose track of their location, such as when driving or operating within a military environment. The desire for a “track-up” feature creates an unmet need to rotate maps, preferably with the same performance as zooming and panning. Finally, there is a need to create an application that supports both line segment data and picture data, and still maintains good performance with both—particularly for the military whose theatres include both natural and urban environments.
The present invention provides a mapping application for rendering pixel imagery on platform with limited processing power, memory and display size. The mapping tool provides the capability to navigate multiple images simultaneous, the ability to pan, scan, zoom and rotate in near real-time, and enables “track-up” mode.
The mapping application first defines a world space, a coordinate system representing a “world”, typically 2D, in which the user can navigate. Bounding objects, typically rectangles, are defined in world space with each representing the extent and position of a particular map in world space. Although these objects contain no image data of their own (they consist simply of bounding world space coordinates, specifically the four vertices in the case of a bounding rectangle), each object is associated with a particular map and its corresponding pixel data stored elsewhere in memory. In response to user input, these objects can be added, removed, associated with different maps, and resized. Also, map image data can be loaded, added or removed by the user, which in turn can be used for association with world space objects.
A view port is defined within world space by bounding world space coordinates that represents what part of the “world” the user sees on the display. A typical rectangular view port is represented by its four rectangular vertices. The view port is translated, scaled, and rotated within world space in response to user input. The mapping application then performs an affine transformation to assign world space coordinates to each pixel of the display represented by the view port. For every assigned world space coordinate that intersects with a world space map object, the mapping application converts the world space coordinate into a map space coordinate using a second affine transformation and copies the map's pixel value to the display pixel. The mapping application assigns a background value to all other non-intersecting pixels. Once all display pixels are assigned, an entire “frame” is suitably constructed, and the frame is copied to the actual hardware display buffer so that it is visible on screen.
In another embodiment, the execution time to perform the affine transformation is, on average over all rotations of the view port in world space, greatly improved by storing the map pixel data in vertical strips of memory. On average, this will greatly reduce the likelihood of a cache miss when rendering the maps. In this case pixel data is sampled by determining the vertical strip in memory in which the pixel data resides, converting the map space coordinate into a vertical strip column coordinate, and sampling the pixel data from the vertical strip at the column coordinate.
In another embodiment, a hand held device includes non-volatile storage for storing a plurality of pixel maps and a mapping application. Once initiated, the mapping application is loaded into main memory. User I/O is used to load maps from non-volatile storage into main memory in a world space coordinate system and to navigate world space to position a view port therein. The pixel data is stored in vertical strips in memory. A processor executes the mapping application to assign coordinates in world space to each pixel in the view port using an affine transformation, convert the world space coordinates that intersect a map into map space coordinates using a second affine transformation, sample each pixel at its coordinates from the map's vertical strips stored in memory, assign the sampled pixel value to that pixel in the view port, assign a background value to the non-intersecting pixels and paint the display with the map and background pixels assigned to the view port.
If navigation hardware such as a GPS receiver is present and geo-referencing data is provided with the map image data, the user can navigate based on his/her location relative to the loaded maps. If direction-finding hardware is present, such as a digital compass or accelerometer, then the user's orientation can be displayed relative to the map's orientation. With direction-finding hardware, the mapping application will automatically rotate the map according to the user's orientation, so that the direction the user is facing is always upward on the view port.
To further improve processing efficiency, the processor preferably executes the mapping application using integer fixed-point math whenever possible, writes and reads pixel data in double words, and constructs an entire graphics frame in an off-screen double-buffer and then paints the entire frame to the view port at once.
These and other features and advantages of the invention will be apparent to those skilled in the art from the following detailed description of preferred embodiments, taken together with the accompanying drawings, in which:
The present invention relies on a modified affine transformation algorithm to provide near real-time navigation of imagery, track-up capability and integration of segment and picture data. The mapping application is most useful for rendering pixel imagery on a platform with limited processing power, limited memory and small display sizes, e.g., “hand held devices” such as a GPS handset, a personal digital assistant (PDA) or cell phone. However, the techniques could be applied to other platforms such as car navigation systems, laptop computers or PCs.
Affine transformations are algorithms most often used in 3D graphics for texturing polygons (triangles are most commonly used) with bitmaps. They are also used in applications that allow the rotation of 2D images, such as Power Point®. Although the affine transformation algorithm is known, its use in and modification for a map rendering application is new. The standard affine algorithm, although adequate for displaying a single image of limited size as is done in 3D graphics or Power Point®, does not meet all of the requirements for mapping applications. Mapping applications are expected to have the ability to display multiple maps at the same time, handle very large maps and rotate the maps. Affine algorithms only paint a “map space” (referred to as “texture space” in 3d graphics) portion of a single bitmap onto a polygon, which prevents it from supporting multiple maps. Furthermore, the standard memory bitmaps are not optimized for rotation in very large maps.
An overview of the mapping application in accordance with the present invention is illustrated in
The application maps world space coordinates (u′,v′) 18 to each pixel (x′,y′) 20 of the view port 16 using an affine transformation. For each pixel in the view port 16 that intersects a rectangle 12, the application converts the world space coordinate (u′,v′) 18 using a second affine transformation into a map space coordinate (m,n) 21 in map space 22 for the map 23 (Map A) associated with that particular rectangle 12. Image data 24 for Map A 12 is stored in vertical strips 26 in memory. Using the map space coordinate (m, n) 22, the application determines the vertical strip 26 of map image data in which the pixel lies and converts the map space coordinate (m,n) 22 into a vertical strip column coordinate (r, s) 28. Any overlapping maps are arbitrated based, for example, on priority or blending. The application samples the map's pixel data 24 and assigns a value to that pixel (x′,y′) 20 in the view port 16. This process is repeated for each pixel in the view port. Any non-intersecting pixels within the view port are assigned a background color value. The background value is typically one color such as black or white but is not so constrained. Once completed, all of the view port pixels (x′,y′) 20 are assigned a color value with which to “paint” the display. Any segment data is stored as a monochrome bitmap and rendered like any of the other maps.
The mapping application incorporating the modified affine transformation is extremely fast and delivers very good visual results for surfaces that are parallel to the display's viewing plane, perfect for 2D maps. The concept of painting a “world space” onto the display allows the mapping application to display multiple maps at the same time. The modified affine transformation provides the ability to pan, zoom and rotate an image in near real-time with any granularity and at any rotation angle the user chooses. Improvements in frame rates of 15× to 30× have been demonstrated with software that supports track-up and does not impose limitations on, for example, zoom level.
Mapping applications must deal with very large, variable image sizes (2000 or more pixels per dimension is common). Standard affine algorithms typically define a constant image size (512×512 pixels is standard) to optimize for CPU cache size. If a standard affine algorithm were used to rotate a large image on a typical PDA cache-limited CPU to a vertical orientation (90 or 270 degrees), it would encounter memory inefficiencies so severe that it would incur an approximate 10× performance hit. Because the mapping application does not have the luxury of choosing a small, constant pixel resolution for its images, its affine algorithm has been adapted to better cope with these memory inefficiencies. By presenting the image data to the affine algorithm in vertical strips of memory rather than in a standard bitmap memory orientation, the map software reduces the above situation's 10× performance penalty to 3×.
Because the map software is intended to operate on a PDA, other important, but more mundane optimizations to its affine algorithm include using integer fixed point over floating point math whenever possible, double word read/writes whenever possible, and double buffering.
The details of an embodiment of the mapping application for use in a hand held device including the I/O interface with the user and a step-by-step presentation of the modified affine transformation are illustrated in
As shown in
As shown in
The application maps world space coordinates to each pixel (x′, y′) 74 in the view port 70 (step 76) as shown in
The application solves for u′ and v′ using the formula:
Using these sets of equations, the application can represent view port 70 in the (u,v) coordinate system in world space 62 for any translation, scale (zoom level) or rotation or combination thereof.
The mapping application is optimized for an affine transformation of a single rectangular polygon that represents the entire view port. The affine algorithm simplifies to performing two linear interpolations, one along the vertical axis of the view port and the second along the horizontal axis of the view port for each pixel of the display. The rectangle is horizontal in display space, so the algorithm only needs to linearly interpolate between the left and right edge of the rectangle. In addition, the left and right edge of the rectangle will always have the same slope in world space, which means that both the vertical and horizontal affine slopes of interpolation do not change. This allows the algorithm to pre-calculate constant slope values that apply to both edges. The algorithm then proceeds as normal for an affine transformation; filling the bottom horizontal scan line of the rectangle and up until it fills the entire view port.
The application then determines if mapped world space coordinates (u′,v′) 74 within view port 70 intersect with any of the rectangular map regions 64, 66 in world space 62 (step 78) as shown in
The application converts the world space coordinates (u′,v′) 74 in intersecting areas 79 to map space coordinates (m′, n′) 80 using a second affine transformation (step 82) as shown in
First, the application computes these four slope values:
Then the application solves for m′ and n′ using the formula:
Essentially, the equation becomes a linear interpolation along the horizontal axis of the map in map space that is only dependant on the horizontal coordinate to solve for m′ and then a linear interpolation along the vertical axis of the map that is only dependant on the vertical coordinate to solve for n′.
Image data 84 is arranged in a series of vertical strips 86, each of pixel width: StripWidth. Map coordinates (m′,n′) 80 can not be used to directly access the map image data. Instead the application uses (m′,n′) to first determine in which vertical strip the coordinate lies and then converts (m′,n′) into vertical strip column coordinate (r′, s′) 88 (step 90). The RGB pixel value is sampled from the vertical memory strip and assigned to the corresponding view port display pixel (m′,n′) (step 92).
To find which vertical strip contains (m′, n′), the application applies the formula:
The application than applies the following formula to convert (m′, n′) to (r′, s′):
Using the Vertical Strip index 94 and the (r′, s′) coordinate 88, the application samples the RGB pixel value from the map image data 84 and assigns it to the (x′, y′) display coordinate.
By comparison an affine algorithm using a conventional row-by-row bitmap would perform poorly when rotating a large image because large images have a large horizontal width in pixels. If two pixels are in two different rows of an image, they will be (difference in image rows * image width in bytes) apart in memory. “Image width in bytes” will be large, in this case, because of the large horizontal width in pixels of the image. The second pixel is not likely to be in the sane memory address region as the first pixel, which is currently loaded into cache memory on the CPU. If these two pixels are accessed in sequence, a CPU cache miss is likely to occur because of their distance apart in memory. A CPU cache miss forces the CPU to retrieve the second pixel from DRAM rather than cache, an operation an order of magnitude slower than if it was able to “cache-hit.” If a large image is rotated to 90 or 270 degrees while zoomed out (the worst case), the affine algorithm will be accessing pixels in sequence that are multiple image rows apart. This means that the affine algorithm may cache-miss on every single pixel it samples from the image.
As just illustrated, the current mapping application splits the image into constant width vertical strips 86 whose pixel row width is a small fraction of the full pixel row width of the image. Using the example above, this effectively makes “image width in bytes” smaller, increasing the chances that pixel 2 will be within the same memory region as pixel 1, making a cache-hit more likely. The tradeoff of the approach is that rotations of 0 degrees, which tend to access horizontal pixels in sequence, have the chance of accessing a pixel 1 in one vertical strip and a pixel 2 in a separate vertical strip, incurring a cache miss. However, the increased rate of cache missing for horizontal orientations will be orders of magnitude lower than the chance of cache missing for a vertical orientation with an unoptimized affine algorithm. The current approach provides balanced performance over all rotations as compared to the standard affine transform, which is optimum for 0 degrees but degrades rapidly with rotation. To implement this optimization, the mapping application as described above stores image data in a vertical strip format and its affine algorithm samples from a vertical strip format rather than a standard bitmap orientation. This optimization has been shown to reduce a 10× performance penalty in the worst case (rotated 90 or 270 degrees) to a 3× performance penalty.
The number of vertical strips allocated depends on the StripWidth in bytes, pixel width, and pixel color depth (bits per pixel). For example:
PixelColorDepth=2 bytes (16 bits per pixel: 65,536 colors)
It is not uncommon that maps will overlap in world space either because of their geo-reference or because the user places one map on top of another. In this case, the application must arbitrate how to display the overlapping portions 96 of the maps A and B associated with rectangular regions 64 and 66 (step 98) as shown in
where Alpha is some fraction of 1 representing the transparency of Map A, 1 being opaque and 0 being completely invisible. Alpha is a settable property for each map in world space, representing how “transparent” the map is. Transparency allows the user to see two maps of the same region blended together without having to constantly flip between them. The application assigns all non-intersecting world space pixels 100 a background color value (step 102) as shown in
Once all view port pixels are assigned a color value, the display 104 is “painted” with the RGB values that have been assigned to the view port (step 106). As shown in
The application continues to update world space 62 and the size and position of the view port 70 in world space in response to the user's navigation commands and to perform the modified affine transformation and render the image data in near real-time. As shown in
The relative performance of an affine transformation that uses standard row-by-row bitmaps versus the modified affine transformation that uses vertical strips of memory is shown in
Finally, map software is typically required to render line segment data. As mentioned before, the performance limiter for consumer navigation software is how many line segments (roads, borders, etc . . . ) are displayed on screen at once, since every line has to be drawn per frame. It would seem that an affine algorithm would be useless in this respect since it is intended to render image data, not line segment data. However, the mapping application uses the affine algorithm in an innovative way that eliminates the need to draw line segments every frame. The mapping application draws all of the line segment data 118 to a large off-screen monochrome bitmap 120 as illustrated in
As mentioned previously, the mapping application is particularly well suited for rendering pixel imagery on hand held devices with limited processing power and memory and small display sizes. The capability to navigate multiple maps in near real-time and operate in track-up mode will be critical to many military and commercial applications. As shown in
To start the mapping application, the user employs an I/O device 132 e.g., a stylus and touch screen or buttons, to inform the operating system (OS) running on the processor 134 to load the mapping application software 136 from non-volatile storage 138 into main memory 140. For a Windows OS, the user double clicks on the executable icon 139 representing the mapping application. Non-volatile storage 138 in a PDA is typically flash memory. Main memory 140 is almost always some form of dynamic RAM, usually SDRAM or DDR SDRAM. The PDA is typically used in a wireless, mobile environment and thus requires a mobile power source 141 such as a lithium-ion or alkaline battery.
The PDA processor 134 typically has a small amount of cache memory 142, 16 or 32 kb compared to 512 kb for typical desktop processors by today's standards. Cache memory 142 is useful for speeding up the processor's interaction with main memory 140 by adding a super-fast portion of memory that can “cache” areas of main memory so that the processor spends most of its time interacting with fast cache instead of slow main memory. Cache 142 “mirrors” portions of main memory 140 that the processor 134 has recognized as memory address ranges of frequent use. When the processor 134 interacts with a memory address that happens to be within the range “mirrored” by cache, the processor interacts with the cache instead of main memory, speeding things up (cache hit). If the processor accesses a memory address range that is not mirrored by cache, a cache miss occurs, the processor gets the value from main memory instead, and a portion of cache is flushed and loaded to mirror the address range that contains the newly accessed address.
Once in main memory 140, the OS allows the processor 134 to execute the mapping application. The mapping application establishes its own internal data structures in main memory and then displays a view port 144 on a display 146 such as a small touch screen LCD. View port 144 is an area of the display 146 where map imagery 148 can be seen by the user. Using the on-screen interface, the user loads image data 150 from non-volatile storage 138 into main memory 140 where it is preferably stored in vertical strips. Once in main memory 140, the mapping application uses the map image data 150 to render maps 148 onto the view port 144. Map Image data is usually large, so only a subset of maps is typically loaded into memory, usually selected according to the immediate location of the user. The mapping application uses this information to define the current instantiation of world space.
Given a loaded set of maps 148 displayed on display 146, the user uses I/O 132 to create and edit navigation objects such as waypoint, routes, and areas of interest on the maps. The user can also pan, zoom, and rotate the maps according to his or her desire. The mapping application responds to changes in the view port translation, scale and orientation in world space and performs the modified affine transformation to paint the view port on the display with the appropriate portion of world space. Because image data is preferably stored in vertical strips of main memory, incidence of cache misses averaged over all rotations will be dramatically reduced, hence execution time will be much faster.
If navigation hardware 152 such as a GPS receiver is present on the PDA and geo-referencing data is provided with the map image data 148, the user can navigate based on his/her location relative to the loaded maps. If direction-finding hardware 154 is present, such as a digital compass or accelerometer, then the user's orientation can be displayed relative to the map's orientation. Direction can also be computed with GPS when the user moves to a new location at a minimum velocity with a constant direction. With direction-finding hardware 154 and the mapping application's ability to rotate maps in near real-time, an additional feature of “track-up” is enabled. In “track-up” mode, the mapping application will automatically rotate the map according to the user's orientation, so that the direction the user is facing is always upward on the view port 144.
Other important optimizations have been added to the affine algorithm to make it operate efficiently on a hand held device including using integer fixed point over floating point math whenever possible, double-word read/writes to write out the map data and double-buffering to paint the entire view port at once.
Embedded processors developed for PDA's such as Intel's XSCALE and Bulverde typically lack floating point units. Embedded processors normally do not run applications that favor intensive floating point calculations, so the floating point unit is removed to save power and space for integrated components like memory controllers, display controllers, etc. . . . Whenever an embedded processor needs to execute a floating point operation, it must emulate it with a series of integer instructions. The performance hit when doing a large number of real number calculations is high.
Because the mapping application in performing the affine transformation deals with slopes of lines during its linear interpolation, the processor must do several real number calculations per pixel. This can significantly degrade performance in an affine transformation.
The technique of fixed point math is used to solve this performance issue. Fixed point math is a way of using integers to emulate real numbers. To produce a fraction, an integer is multiplied by a fixed constant. This size of the fixed constant represents the range of the “fractional” part of the fixed point number. So, if you multiplied a number by 1000, you would have a fractional range of 0-999, or in decimal 0.000 to 0.999. This fractional part can be used in normal integer calculations while still maintaining a fractional value of the number, much like doing calculations with a real number. After carrying out real number-like calculations with fixed numbers, the result can be returned to the actual integer value by dividing by the fixed constant.
In the mapping application, the current fixed constant used is 8096, giving it an accuracy of almost 4 digits after the decimal point. This leaves a range of +/−265,252 for the integer portion of the number using signed 32 bit integers. The mapping application uses a fixed constant that is a power of 2 because the processor can use fast shift operations instead of the slower integer multiply and divide operations. A fixed point implementation of the mapping application is approximately 2.5 times faster than a floating point implementation.
Memory performance is much more efficient when writing/reading double words (32 bit values) as opposed to writing/reading individual bytes (8 bit values) when dealing with memory in sequential orientation (it is faster to read a single double word than read 4 bytes in sequence). An affine transformation must access map data at an unknown location, so there is no easy way to optimize for word writes within this portion of the algorithm. However, the view port's memory is in sequential order, so when writing out the map data, it is advantageous to do so in double word writes. For this reason, the mapping application works on as many pixels at a time that can fill a double word, i.e. for a 4 bit per pixel display, it will work on 8 pixels at a time, because 1 double word=32 bits/4 bits per pixel=8 pixels. It then composes the resulting values for each of those pixels into a full double word that is then written to the view port. This optimization produces performance gains of about 5-10%.
Embedded processors are typically inefficient when it comes to updating the display. The processor has to access un-cached display memory in DRAM or go out on the bus to update an external LCD controller's embedded memory. For this reason, the mapping application's drawing algorithm constructs an entire graphics frame in an off-screen double-buffer, and then copies the entire frame to the view port using a single Windows API BitBlt call. This has the advantage of utilizing memory caching during frame construction, limiting the number of (slow) Windows API calls to one, and removing “flicker” from the display, because the entire display will be updated all at once.
While several illustrative embodiments of the invention have been shown and described, numerous variations and alternate embodiments will occur to those skilled in the art. Such variations and alternate embodiments are contemplated, and can be made without departing from the spirit and scope of the invention as defined in the appended claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4661811 *||Sep 10, 1984||Apr 28, 1987||British Telecommunications Plc||Video map display|
|US4847788 *||Feb 12, 1986||Jul 11, 1989||Hitachi, Ltd.||Graphic data processing method and system|
|US5161886 *||Nov 18, 1991||Nov 10, 1992||U.S. Philips Corp.||Method for the perspective display of a part of a topographic map, and device suitable for performing such a method|
|US5687307 *||Sep 16, 1994||Nov 11, 1997||Canon Kabushiki Kaisha||Computer graphic animation in which texture animation is independently performed on a plurality of objects in three-dimensional space|
|US5884217 *||Jul 11, 1996||Mar 16, 1999||Xanavi Informatics Corporation||Map display apparatus for motor vehicle|
|US6011566 *||Apr 22, 1997||Jan 4, 2000||Unisys Corporation||System and method to display raster images with negligible delay time and reduced memory requirements|
|US6141014 *||Apr 17, 1996||Oct 31, 2000||Hitachi, Ltd.||Bird's-eye view forming method, map display apparatus and navigation system|
|US6205181 *||Mar 10, 1998||Mar 20, 2001||Chips & Technologies, Llc||Interleaved strip data storage system for video processing|
|US6341254 *||Aug 17, 2000||Jan 22, 2002||Xanavi Informatics Corporations||Map displaying method and apparatus, and navigation system having the map displaying apparatus|
|US6421134 *||Jan 11, 1996||Jul 16, 2002||Canon Kabushiki Kaisha||Progressive display during image compression|
|US6556185 *||Aug 9, 2001||Apr 29, 2003||Sony Corporation||Information processing device and method|
|US6611753 *||Apr 17, 1998||Aug 26, 2003||Magellan Dis, Inc.||3-dimensional intersection display for vehicle navigation system|
|US6721952 *||Mar 7, 1997||Apr 13, 2004||Roxio, Inc.||Method and system for encoding movies, panoramas and large images for on-line interactive viewing and gazing|
|US6836270 *||May 2, 2002||Dec 28, 2004||Geojet Information Solutions, Inc.||3-D map data visualization|
|US20010034588 *||Nov 30, 2000||Oct 25, 2001||Maneesh Agrawals||System and method for abstracting and visualizing a rout map|
|US20010038718||Mar 9, 2001||Nov 8, 2001||Rakesh Kumar||Method and apparatus for performing geo-spatial registration of imagery|
|US20020145610 *||Oct 16, 2001||Oct 10, 2002||Steve Barilovits||Video processing engine overlay filter scaler|
|US20040056861 *||Sep 16, 2003||Mar 25, 2004||Mark Huber||Method of handling context during scaling with a display|
|US20040100471 *||Jun 12, 2003||May 27, 2004||Leather Mark M.||Dividing work among multiple graphics pipelines using a super-tiling technique|
|US20040165775 *||Jul 27, 2001||Aug 26, 2004||Christian Simon||Model-based recognition of objects using a calibrated image system|
|US20050031197 *||Jun 28, 2004||Feb 10, 2005||Knopp David E.||Method and apparatus for producing digital orthophotos using sparse stereo configurations and external models|
|US20050033511 *||Sep 3, 2004||Feb 10, 2005||Telmap Ltd.||Dynamic navigation system|
|US20050184993 *||Sep 29, 2004||Aug 25, 2005||Ludwin Albert S.||Display processor for a wireless device|
|US20050270311 *||Feb 5, 2005||Dec 8, 2005||Rasmussen Jens E||Digital mapping system|
|US20070014488 *||Jun 28, 2005||Jan 18, 2007||Ching-Chien Chen||Automatically and accurately conflating road vector data, street maps, and orthoimagery|
|EP0510939A2||Apr 22, 1992||Oct 28, 1992||Pioneer Electronic Corporation||On-board navigation apparatus|
|EP0738874A2||Apr 18, 1996||Oct 23, 1996||Hitachi, Ltd.||Navigation display with bird's-eye perspective|
|EP0841537A2||Nov 5, 1997||May 13, 1998||Xanavi Informatics Corporation||Method and apparatus for displaying a navigation map|
|1||*||Shirley et al., "Fundamentals of Computer Graphics: second edition", A K Peters, LTD, 2005, pp. 201-211.|
|2||*||Wikipedia, "Ray tracing", http://en.wikipedia.org/wiki/Ray<SUB>-</SUB>tracing, Mar. 6, 2004.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7852315 *||Apr 7, 2006||Dec 14, 2010||Microsoft Corporation||Camera and acceleration based interface for presentations|
|US8217964 *||Feb 14, 2008||Jul 10, 2012||Nokia Corporation||Information presentation based on display screen orientation|
|US8531486||Jul 9, 2012||Sep 10, 2013||Nokia Corporation||Information presentation based on display screen orientation|
|US8587617||Feb 4, 2010||Nov 19, 2013||Raytheon Company||Apparatus and method for map zooming|
|US8615432||Apr 26, 2010||Dec 24, 2013||Apple Inc.||Background process for providing targeted content within a third-party application|
|US9110749||Jun 1, 2010||Aug 18, 2015||Apple Inc.||Digital content bundle|
|US9111309||Jun 13, 2012||Aug 18, 2015||Apple Inc.||Caching multiple views corresponding to multiple aspect ratios|
|US20070236451 *||Apr 7, 2006||Oct 11, 2007||Microsoft Corporation||Camera and Acceleration Based Interface for Presentations|
|US20110246618 *||Oct 6, 2011||Apple Inc.||Caching multiple views corresponding to multiple aspect ratios|
|U.S. Classification||345/427, 345/649, 345/672, 345/648|
|International Classification||G09G5/00, G06T15/10|
|Cooperative Classification||G06T17/05, G06T3/0006|
|European Classification||G06T17/05, G06T3/00A|
|Jul 29, 2004||AS||Assignment|
Owner name: RAYTHEON COMPANY, MASSACHUSETTS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:HOFF, CHRISTOPHER G.;REEL/FRAME:015645/0826
Effective date: 20040729
|Sep 19, 2011||FPAY||Fee payment|
Year of fee payment: 4