Abstract:
A system and method for creating a connectivity framework between map image objects and map data objects in an object oriented computer environment. The connectivity framework may provide a flexible and efficient architecture for generating multiple map images from one or more map data sources. The map image objects may be coupled to map data objects and map projection objects.

Description:
[0001]    This application claims the benefit of U.S. Provisional Application No. 60/574,924, filed May 28, 2004, which is incorporated herein by reference. 
         [0002]    The present invention relates generally to object oriented computer graphics and, more particularly, to object oriented software for digital maps. 
         [0003]    Digital map images may be generated from a source of map data. It may be desirable to generate multiple map images from a single data source and for each image to have different characteristics depending on the contemplated use of the image. It may also be desirable to provide connectivity between map image objects and map data and map projection objects. 
         [0004]    Conventional map image generation software may have associations between a map image and a map database, which may be limited in number and type. Further, these associations may be coded into the software and may not be readily adapted or changed. 
         [0005]    A system and method of map image object connectivity in accordance with the present invention may overcome the limitations of the conventional methods of generating map images. 
         [0006]    Briefly, in an exemplary embodiment of the present invention, three objects are created, a map data object, a map image object, and a map projection object. The map data object provides members and methods to access a map data source. The map image object provides members and methods to generate map images based on map data and a map projection. The map projection object provides methods for projecting map data into a map image having a specified projection. The map image object may be connected with any map data source or any other map image object. The map data source may be a map database or another map data object. 
         [0007]    In an exemplary embodiment of a method for creating connectivity between map data and a map image in an object oriented computer system, in accordance with the present invention, first, a map data object is created. Then, a map image object and a map projection object are created. 
         [0008]    The map data object is connected to a map data source by invoking a map data connection method of the map data object and providing a map data source identifier. The map image object is connected to the map data object by invoking a map data selection method of the map image object and providing an identifier for the map data object. Finally, invoking a map image rendering method of the map image object creates a map image. 
         [0009]    The exemplary embodiment of the present invention described above provides for any combination of map images to be associated with map data objects or other map image objects. Further, the system and method of the present invention may provide a savings of processing time and memory during the generation of map images. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS  
         [0010]    The present invention will be described with reference to the accompanying drawings, wherein: 
           [0011]      FIG. 1  is a block diagram of map object connectivity in accordance with the present invention; 
           [0012]      FIG. 2  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention; 
           [0013]      FIG. 3  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention; 
           [0014]      FIG. 4  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention; 
           [0015]      FIG. 5  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention; and 
           [0016]      FIG. 6  is a flowchart of an exemplary embodiment of a map object connectivity method in accordance with the present invention. 
       
    
    
     DETAILED DESCRIPTION  
       [0017]    In accordance with the present invention, a system and method of map image object connectivity is provided. The system and method of map image connectivity in accordance with the present invention may provide a flexible and efficient framework from which to develop digital map applications. These digital map applications may be used in a variety of platforms, such as, for example, mapping terminals, land vehicles, ships, fixed wing or rotary wing aircraft, unmanned aerial vehicles, command and control centers, spacecraft, and/or the like. 
         [0018]    Further, the system and method of map image object connectivity may be practiced in a client-server computer environment. The map image object, map data object, and map projection object may each be distributed onto different processors, or they may be co-located. The connections between the objects may be software connections within a processor, may be wired connections, may be wireless connections, or a combination of the above in a distributed environment. 
         [0019]    The systems and methods of the present invention are illustrated below in terms of specific exemplary embodiments. However, it should be appreciated that the systems and methods of the present invention are not limited to the specific exemplary embodiment shown and this invention may be practiced in various configurations in accordance with a contemplated use of the invention. 
         [0020]    In an exemplary embodiment, the MapData class (the map data object base class) provides an API (Application Program Interface) for derived map database classes. The MapData class is abstract, meaning that it cannot be used by itself. It is a building block to be used when creating an implementation for a particular kind of map data. 
         [0021]    Most of the MapData API is defined as pure virtual methods. These virtual methods must be implemented when creating a derived class for a particular kind of map data. The presence of the [virtual] label in the table below denotes a virtual method that has a default implementation in this class, [pure virtual] denotes a virtual method with no default implementation, and [protected] indicates that the method can only be accessed by derived classes. Table 1, below, contains an exemplary embodiment of the methods that may be found in the MapData API: 
         [0000]    
       
         
               
             
               
               
               
             
               
             
               
               
               
             
               
             
               
               
               
             
               
             
               
               
               
             
               
             
               
               
               
             
               
             
               
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
             
             
               
                 Connect (specify) the location of a map database 
               
             
          
           
               
                   
                 CanConnectToMapObject( ) 
                 [pure virtual] 
               
               
                   
                 ConnectToMapObject( ) 
                 [pure virtual] 
               
               
                   
                 CanConnectToMultipleDbPaths( ) 
                 [pure virtual] 
               
               
                   
                 ConnectToDbPath( ) 
                 [pure virtual] 
               
               
                   
                 Disconnect( ) 
                 [pure virtual] 
               
             
          
           
               
                 Query the type of map data supported and the availability of data. 
               
             
          
           
               
                   
                 GetMapTypeLongString( ) 
                 [pure virtual] 
               
               
                   
                 GetMapTypeString( ) 
                 [pure virtual] 
               
             
          
           
               
                 Query the available map scales and initialize to a particular map 
               
               
                 scale. 
               
             
          
           
               
                   
                 GetNumberScales( ) 
                 [pure virtual] 
               
               
                   
                 GetScaleIndex( ) 
                 [pure virtual] 
               
               
                   
                 GetScaleString( ) 
                 [pure virtual] 
               
               
                   
                 GetScaleStringLong( ) 
                 [pure virtual] 
               
               
                   
                 GetScaleStringNumeric( ) 
                 [pure virtual] 
               
               
                   
                 IsValidScale( ) 
                 [pure virtual] 
               
               
                   
                 SetScale( ) 
                 [pure virtual] 
               
             
          
           
               
                 Query the available feature data, and initialize features. 
               
             
          
           
               
                   
                 FeaturesHaveColor( ) 
                 [pure virtual] 
               
               
                   
                 GetFeatureActivation( ) 
                 [pure virtual] 
               
               
                   
                 GetFeatureClass( ) 
                 [pure virtual] 
               
               
                   
                 GetFeatureCode( ) 
                 [pure virtual] 
               
               
                   
                 GetFeatureColor( ) 
                 [pure virtual] 
               
               
                   
                 GetFeatureName( ) 
                 [pure virtual] 
               
               
                   
                 GetTotalNumberFeatures( ) 
                 [pure virtual] 
               
               
                   
                 IsValidFeatureCode( ) 
                 [pure virtual] 
               
               
                   
                 IsValidFeatureName( ) 
                 [pure virtual] 
               
               
                   
                 SetFeatureActivation( ) 
                 [pure virtual] 
               
               
                   
                 SetFeatureColor( ) 
                 [pure virtual] 
               
             
          
           
               
                 Query and initialize projections. 
               
             
          
           
               
                   
                 CanSetProjection( ) 
                 [pure virtual] 
               
               
                   
                 CloneProjection( ) 
                 [pure virtual] 
               
               
                   
                 GetProjection( ) 
                 [pure virtual] 
               
               
                   
                 HaveProjection( ) 
                 [pure virtual] 
               
               
                   
                 MakeProjection( ) 
                 [pure virtual] 
               
             
          
           
               
                 Initialize and request a data load, and query data availability. 
               
             
          
           
               
                   
                 AbortLoad( ) 
                 [pure virtual] 
               
               
                   
                 CanSetSizeCells( ) 
                 [pure virtual] 
               
               
                   
                 CanQueryDataAvail( ) 
                 [pure virtual] 
               
               
                   
                 ClearReadLock( ) 
                 [virtual] 
               
               
                   
                 GetUpdateCount( ) 
                 [inline] 
               
               
                   
                 HaveData( ) 
                 [pure virtual] 
               
               
                   
                 Load( ) 
               
               
                   
                 LoadData( ) 
                 [protected, pure virtual] 
               
               
                   
                 SetReadLock( ) 
                 [virtual] 
               
               
                   
                 SetSizeCells( ) 
                 [pure virtual] 
               
               
                   
                 SetSizeDegrees( ) 
                 [pure virtual] 
               
               
                   
                   
               
             
          
         
       
     
         [0022]    An exemplary implementation of the MapData class may be responsible for reading a particular type of map data from disk files and storing that data into memory. The format of the data storage may be left to the implementer of the derived class. 
         [0023]    Derived classes must implement all pure virtual API methods. Other virtual methods must be implemented if the default behavior does not meet the needs of the derived class. Derived classes should initialize to some default state, such that a minimum number of method calls are required to accomplish loading data into memory. 
         [0024]    In an exemplary embodiment, the minimal set of methods required to accomplish this may be: 
         [0025]    ConnectToDbPath( . . . ) or ConnectToMapObject( . . . ) 
         [0026]    SetSizeDegrees( . . . ) or SetSizeCells( . . . ) 
         [0027]    SetScale( . . . ) 
         [0028]    Load( . . . ) 
         [0029]    In an exemplary embodiment, the responsibility of the MapImage class may be to provide an API for map image classes. The MapImage class may not be not abstract, which means that it may be used as a complete object. By itself, the MapImage class cannot create a map image because it is not associated with any particular kind of map data. However, a map image object may contain a map image by using associations that can be set up between map images. The MapImage class may be a building block to be used when creating an implementation for a particular kind of map data. 
         [0030]    The MapImage API has some methods that are implemented within the class, and some API methods that are defined as virtual methods. The API methods implemented within this class have to do with the providing initialization and access to the image and establishing relationships between different MapImage objects. 
         [0031]    The API methods that are defined as virtual are methods that need to be implemented when creating a derived class for a particular kind of map data. 
         [0032]    Table 2, below, contains an exemplary embodiment of the MapImage class methods. 
         [0000]    
       
         
               
             
               
               
             
               
             
               
               
               
             
               
             
               
               
               
             
           
               
                 TABLE 2 
               
               
                   
               
             
             
               
                 Initialize the image. 
               
             
          
           
               
                   
                 Clear( ) 
               
               
                   
                 GetBackgroundColor( ) 
               
               
                   
                 GetBytesPerPixel( ) 
               
               
                   
                 GetBytesPerPixel( ) 
               
               
                   
                 GetClut( ) 
               
               
                   
                 GetImagePointer( ) 
               
               
                   
                 GetImageSize( ) 
               
               
                   
                 GetImageType( ) 
               
               
                   
                 GetSubImage( ) 
               
               
                   
                 SetBackgroundColor( ) 
               
               
                   
                 SetClut( ) 
               
               
                   
                 SetImageMemory( ) 
               
               
                   
                 SetImageSize( ) 
               
               
                   
                 SetImageType( ) 
               
             
          
           
               
                 Establish associations with map data and other map 
               
               
                 images, and setup projection. 
               
             
          
           
               
                   
                 GetMapData( ) 
                 [virtual] 
               
               
                   
                 SetMapData( ) 
                 [virtual] 
               
               
                   
                 GetProjection( ) 
               
               
                   
                 CreateProjection( ) 
               
               
                   
                 SetBaseImage( ) 
               
               
                   
                 SetProjection( ) 
               
             
          
           
               
                 Initialize image processing and generate images. 
               
             
          
           
               
                   
                 CanDither( ) 
                 [virtual] 
               
               
                   
                 GenerateImage( ) 
                 [protected, virtual] 
               
               
                   
                 GetImageAttributes( ) 
                 [virtual] 
               
               
                   
                 GetImageObject( ) 
               
               
                   
                 GetUpdateCount( ) 
                 [inline] 
               
               
                   
                 MakeImage( ) 
               
               
                   
                 UseDitherMap( ) 
                 [virtual] 
               
               
                   
                   
               
             
          
         
       
     
         [0033]    An exemplary implementation of the MapImage class is responsible for rendering data for a particular type of MapData object into an image. The format of the image is left to the implementer of the derived class. 
         [0034]    Derived classes must implement all pure virtual API methods. Other virtual methods must be implemented if the default behavior does not meet the needs of the derived class. Derived classes should initialize to some default state, such that a minimum number of method calls are required to accomplish loading data into memory. The minimal set of method calls required to accomplish this may be: 
         [0035]    SetImageType( . . . ) 
         [0036]    SetImageSize( . . . ) 
         [0037]    SetMapData( . . . ) 
         [0038]    MakeImage( . . . ) 
         [0039]    In an exemplary embodiment, it is the responsibility of the Projection class to provide an API for projection classes. The Projection class is abstract, meaning that it cannot be used by itself. It is a building block to be used when creating an implementation for a particular kind of projection. 
         [0040]    The Projection API has some methods that are implemented within the class, and some API methods that are defined as virtual methods. The API methods implemented are methods that are the same regardless of the type of projection, or they use specific implementations of other methods. 
         [0041]    The API methods that are defined as virtual are methods that need to be implemented when creating a derived class for a particular kind of projection. 
         [0042]    The presence of the [virtual] label in the table below denotes a virtual method that has a default implementation in this class, [pure virtual] denotes a virtual method with no default implementation, and the [protected] label indicates that derived classes can only access the method. Table 3, below, lists the methods of an exemplary embodiment of the MapProjection class. 
         [0000]    
       
         
               
             
               
               
               
             
               
             
               
               
               
             
           
               
                 TABLE 3 
               
               
                   
               
             
             
               
                 Initialize and query the projection. 
               
             
          
           
               
                   
                 CanSetDatum( ) 
                 [pure virtual] 
               
               
                   
                 Compute( ) 
                 [protected, pure virtual] 
               
               
                   
                 GetDatum( ) 
               
               
                   
                 GetEllipsoid( ) 
               
               
                   
                 GetOrigin( ) 
               
               
                   
                 GetRangeScale( ) 
               
               
                   
                 GetBounds( ) 
                 [pure virtual] 
               
               
                   
                 GetReferencePosition( ) 
               
               
                   
                 GetTypeString( ) 
               
               
                   
                 FetchTypeString( ) 
                 [protected, pure virtual] 
               
               
                   
                 SetDatum( ) 
               
               
                   
                 SetDatum( ) 
               
               
                   
                 SetNumericScale( ) 
               
               
                   
                 SetOrigin( ) 
               
               
                   
                 SetRangeScaleDegrees( ) 
               
               
                   
                 SetRangeScaleMeters( ) 
               
               
                   
                 SetReferencePosition( ) 
               
               
                   
                 ValidLatLonDeg( ) 
                 [inline] 
               
             
          
           
               
                 Perform conversions 
               
             
          
           
               
                   
                 ArcsecsToMeters( ) 
                   
               
               
                   
                 ArcsecsToProjection( ) 
                 [pure virtual] 
               
               
                   
                 ArcsecsToProjection( ) 
                 [pure virtual] 
               
               
                   
                 ArcsecsWGS84ToProjection( ) 
               
               
                   
                 ArcsecsWGS84ToProjection( ) 
               
               
                   
                 DegreesLocalToWGS84( ) 
               
               
                   
                 DegreesToMeters( ) 
               
               
                   
                 DegreesToProjection( ) 
                 [pure virtual] 
               
               
                   
                 DegreesToProjection( ) 
                 [pure virtual] 
               
               
                   
                 DegreesWGS84ToLocal( ) 
               
               
                   
                 DegreesWGS84ToProjection( ) 
               
               
                   
                 DegreesWGS84ToProjection( ) 
               
               
                   
                 MetersToArcsecs( ) 
               
               
                   
                 MetersToDegrees( ) 
               
               
                   
                 MetersToProjection( ) 
               
               
                   
                 MetersToProjection( ) 
               
               
                   
                 ProjectionToArcsecs( ) 
                 [pure virtual] 
               
               
                   
                 ProjectionToArcsecs( ) 
                 [pure virtual] 
               
               
                   
                 ProjectionToArcsecsWGS84( ) 
               
               
                   
                 ProjectionToArcsecsWGS84( ) 
               
               
                   
                 ProjectionToDegrees( ) 
                 [pure virtual] 
               
               
                   
                 ProjectionToDegrees( ) 
                 [pure virtual] 
               
               
                   
                 ProjectionToDegreesWGS84( ) 
               
               
                   
                 ProjectionToDegreesWGS84( ) 
               
               
                   
                 ProjectionToMeters( ) 
               
               
                   
                 ProjectionToMeters( ) 
               
               
                   
                   
               
             
          
         
       
     
         [0043]    An exemplary implementation of the Projection class is responsible for maintaining the conversion algorithms that the projection defines 
         [0044]    Derived classes must implement all pure virtual API methods. Derived classes should initialize to some default state such that a minimum number of method calls are required to use the projection. The minimal set of method calls required to accomplish this may be: 
         [0045]    SetOrigin( . . . ) 
         [0046]    SetReferencePosition( . . . ) 
         [0047]    SetRangeScale( . . . ) 
         [0048]      FIG. 1  is a block diagram of map objects in accordance with the present invention. In particular, a map object connectivity system  10  comprises a map image object  102 , a map data object  104 , a map projection object  106 , and a map data source  108 . The map image object  102  is connected to the map data object  104  and the map projection object  106 . The map data object  104  is connected to the map data source  108 . 
         [0049]    In operation, the map image object  102  and the map data object  104  are created. The map data object  104  is connected to the map data source  108 . The map data object  104  is connected to the map image object  102 . The map projection object  106  is connected to the map image object  102 . 
         [0050]    The map image object  102  requests map data from the map data object  104  and then generates a map image by projecting the map data using the map projection object  106 . 
         [0051]      FIG. 2  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention. In particular, a first map image object  202  and a second map image object  204  are connected to a single map data object  206 . The map data object  206  is connected to a map data source  208 . 
         [0052]    In operation, the first map image object  202  may generate a first map image based on data received from the map data object  206 . The second map image object  204  may generate a second map image which may have different characteristics from the first map image. The second map image is based on data received from the map data object  206 . The map image objects ( 202  and  204 ) may use the same map projection object or may use different map projection objects. 
         [0053]    The map image objects may be of different image type or of the same image type. Although the map image objects may be of the same image type, they may still differ in other characteristics, such as, for example, geographic coverage, image size, image format, scale, and/or any other configurable detail of the class from which the map image object is derived. 
         [0054]    Further, while two map image objects are shown connected to a single map data object, it should be appreciated that any number of map image objects may be connected to a single map data object. 
         [0055]      FIG. 3  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention. In particular, a first map image object  302  is connected to a second map image object  304 . In this configuration the first map image object  302  may generate a map image and store the map image in the memory space allocated to the map image of the second map image object  304 . 
         [0056]      FIG. 4  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention. In particular, a first map data object  402  is connected to a first map image object  404  and a second map image object  406 . A second map data object  410  is connected to a third map image object  408 . The third map image object  408  is connected to the second map image object  406 . The second map image object  406  is connected to the first map image object  404 . 
         [0057]    In operation, the first map image object  404  and the second map image object  406  may be generating different images based on a common map data object  402 . While the third map image object  410  may be generating an image based on the second map data object  410 . 
         [0058]      FIG. 5  is a block diagram of an exemplary embodiment of map object connectivity in accordance with the present invention. In particular, a first map data object  504  is connected to a first map image object  502 , a second map image object  506 , and a third map image object  510 . A second map data object  508  is connected to a fourth map image object  512 . The third map image object  510  and the fourth map image object  512  are connected to the second map image object  506 . The second map image object  506  is connected to the first map image object  502 . 
         [0059]    In operation, three map image objects ( 502 ,  506 , and  510 ) may each generate the same or different images based on the first map data object  504 . The fourth map image object  512  may be generating an image based on the second map data object  508 . The third map image object  510  and fourth map image object  512  generate their respective map image and store them in the memory of the second map image object  506 . The second map image object  506  stores a map image in the first map image object  502 . 
         [0060]      FIG. 6  is a flowchart of an exemplary embodiment of a map object connectivity method in accordance with the present invention. In particular, control begins at step  602  and continues to step  604 . 
         [0061]    In step  604 , a map data object is created. Control continues to step  606 . In step  606  a map image object is created. Control continues to step  607 . 
         [0062]    In step  607 , a map projection object is created. Control continues to step  608 . In step  608 , the map data object is connected to a map data source. The map data source may be a map database or another map data object previously created. Control continues to step  610 . 
         [0063]    In step  610 , an image size is set. Control continues to step  612 . In step  612 , an image type is set. Control then continues to step  614 . 
         [0064]    In step  614 , the map image object is connected to the map data object. Control continues to step  615 . In step  615 , the map image project is connected to the map projection object. Control continues to step  616 . 
         [0065]    In step  616 , map data is loaded from the map data object to the map image object. Control continues to step  618 . In step  618 , the map image object sets the projection of the map projection object. Control continues to step  620 . In step  620 , the map image is created. Control continues to step  622 . 
         [0066]    In step  622 , an application program gets the image attributes. Control continues to step  624 . In step  624 , an application program gets the map image. Control continues to step  626 , where the control sequence ends. 
         [0067]    The methods and systems for map image object connectivity, as shown in the above figures, may be implemented on a general-purpose computer, a special-purpose computer, a programmed microprocessor or microcontroller and peripheral integrated circuit element, an ASIC or other integrated circuit, a digital signal processor, a hardwired electronic or logic circuit such as a discrete element circuit, a programmed logic device such as a PLD, PLA, FPGA, PAL, or the like. In general, any process capable of implementing the functions described herein can be used to implement methods and systems for map image object connectivity according to this invention. 
         [0068]    Furthermore, the disclosed system may be readily implemented in software using object or object-oriented software development environments that provide portable source code that can be used on a variety of computer platforms. Alternatively, the disclosed methods and systems for map image object connectivity may be implemented partially or fully in hardware using standard logic circuits or a VLSI design. Other hardware or software can be used to implement the systems in accordance with this invention depending on the speed and/or efficiency requirements of the systems, the particular function, and/or a particular software or hardware system, microprocessor, or microcomputer system being utilized. The methods and systems for map image object connectivity illustrated herein can readily be implemented in hardware and/or software using any known or later developed systems or structures, devices and/or software by those of ordinary skill in the applicable art from the functional description provided herein and with a general basic knowledge of the computer and graphics arts. 
         [0069]    Moreover, the disclosed methods may be readily implemented in software executed on programmed general-purpose computer, a special purpose computer, a microprocessor, or the like. In these instances, the systems and methods of this invention can be implemented as program embedded on personal computer such as JAVA® or CGI script, as a resource residing on a server or graphics workstation, as a routine embedded in a dedicated encoding/decoding system, or the like. The system can also be implemented by physically incorporating the system and method into a software and/or hardware system, such as the hardware and software systems of a navigation processor, vehicle control processor, or image processor. 
         [0070]    It is, therefore, apparent that there is provided in accordance with the present invention, methods and systems for map image object connectivity. While this invention has been described in conjunction with a number of embodiments, it is evident that many alternatives, modifications and variations would be or are apparent to those of ordinary skill in the applicable arts. Accordingly, applicants intend to embrace all such alternatives, modifications, equivalents and variations that are within the spirit and scope of this invention.