System for communication of image information between multiple-protocol imaging devices
FIELD OF THE INVENTION 
     The present invention relates to imaging systems, and, more particularly, to systems for communicating image information between an input imaging device and an output imaging device in an imaging system. 
     DISCUSSION OF RELATED ART 
     An imaging system typically includes an input imaging device that generates image information, and an output imaging device that forms a visible representation of an image based on the image information. In a medical imaging system, for example, the input imaging device may include a diagnostic device, such as a magnetic resonance (MR), computed tomography (CT), conventional radiography (X-ray), or ultrasound device. Alternatively, the input imaging device may include a user interface device, such as a keypad, mouse, or trackball, also capable of generating medical image information. The output imaging device in a medical imaging system typically includes a continuous tone digital laser imager. The laser imager exposes an imaging media in response to the image information to form the visible representation. 
     The image information generated by the input imaging device includes image data containing digital image values representative of the image, and imaging requests specifying operations to be performed by the laser imager. Each of the digital image values corresponds to one of a plurality of pixels in the original image, and represents an optical density associated with the respective pixel. In response to an imaging request, the laser imager converts the digital image values to generate laser drive values used to modulate the intensity of a scanning laser. The laser drive values are calculated to produce exposure levels, on the imaging media, necessary to reproduce the optical densities associated with the pixels in the original image when the media is developed, either by wet chemical processing or dry thermal processing. The laser imager may perform a number of additional operations in response to the imaging requests generated by the input imaging. For example, the laser imager may manipulate the image data, prior to generating the laser drive values, to produce a variety of different format and/or appearance characteristics. 
     The image information processed by the laser imager has a format determined by an input protocol associated with the particular input imaging device. Medical imaging systems preferably are capable of handling image information generated according to a variety of diverse input protocols. An input protocol can be characterized as including an input driver protocol, which determines requirements for communication with a particular input imaging device, and an input interpreter protocol, which determines the format for interpreting image information generated by the input imaging device. The number of different input protocols results, to some degree, from the various types of input imaging devices presently in use, e.g., MR, CT, X-ray, ultrasound, each of which may generate image information according to a different protocol. The primary source of different input protocols is, however, the existence of a number of modalities, i.e., input imaging devices made by different manufacturers and having unique, manufacturer-specific input protocols. For example, manufacturers such as Siemens, Toshiba, GE, and Picker presently make CT-type input imaging devices that provide similar functionality, but which generate image information according to different modality-specific input protocols. 
     In addition to the ability to handle multiple input protocols, medical imaging systems preferably are capable of handling communication of image information to output imaging devices according to multiple output protocols. Like an input protocol, an output protocol can be characterized as including an output driver protocol, which determines requirements for communication with a particular output imaging device, and an output interpreter protocol, which determines the format for translating image information into a form understood by the output imaging device. Different output protocols primarily result from the availability of laser imaging output devices having different sets of functional capabilities. The different sets of functional capabilities present varying complexity that can lead to different output protocols. For example, Minnesota Mining &amp; Manufacturing Company (&#34;3M&#34;), of St. Paul, Minn., presently offers laser imagers having different sets of functional capabilities referred to as the &#34;831,&#34; &#34;952,&#34; and &#34;SuperSet&#34; sets, each of which is associated with a set-specific output protocol. 
     Existing medical imaging systems presently accommodate multiple input and output protocols on an ad-hoc basis by the design of a hardware and/or software interface specifically configured for a particular input protocol and a particular output protocol. The use of a custom-made interface is extremely inflexible. If communication with a different input imaging device is later required, the entire interface must be redesigned to handle the relationship between the new input protocol and the old output protocol. A change in the output imaging device similarly requires redesign of the interface to handle the relationship between the new output protocol and the old input protocol. Unfortunately, redesign of the interface is a cumbersome task that often requires a significant investment in hardware and/or software development time. Even seemingly minor modifications in functionality of an input or output imaging device can produce numerous, costly design changes that propagate throughout the interface. 
     Nevertheless, there are increasing demands for more flexible medical imaging systems capable of providing communication between a variety of input and output imaging devices having multiple protocols. It is desirable that such medical imaging systems not only provide flexibility with respect to current protocols, but also be capable of adaptation to handle future protocols in a cost-effective manner. Existing medical imaging systems generally fail to meet the above demands. 
     SUMMARY OF THE INVENTION 
     In view of the limitations of existing medical imaging systems, the present invention is directed to a medical imaging system for communicating image information between a plurality of different input imaging devices having different input protocols and a plurality of different output imaging devices having different output protocols. 
     The system of the present invention takes advantage of a reusable software architecture having a plurality of functionally independent components. The individual components can be configured in a communication pipeline to communicate image information between an input imaging device and an output imaging device according to desired protocols. Each component can be interchanged with a differently configured component to facilitate communication of image information according to a different protocol, thereby reconfiguring the pipeline to achieve significant flexibility. As a further advantage, the communication pipeline can be dynamically configured &#34;on the fly&#34; to incorporate components appropriate for the current environment. 
     Moreover, the software architecture is scalable to produce a plurality of communication pipelines, each of which can be configured according to desired protocols. Thus, the system of the present invention can support a different protocol by either swapping components to reconfigure a single communication pipeline, or by simply selecting an alternative among a plurality of differently configured communication pipelines in the scalable architecture. 
     Further, because each of the components is isolated and functionally independent, if redesign of a component is necessary, several programmers can be allocated to the effort with little added overhead, saving time and expense. The modularity of the architecture also enables necessary modifications or corrections to be made to a single component with little impact to the overall system. 
     Additional features and advantages of the present invention will be set forth in part in the description that follows, and in part will be apparent from the description, or may be learned by practice of the present invention. The advantages of the present invention will be realized and attained by means particularly pointed out in the written description and claims hereof, as well as in the appended drawings. 
     To achieve the foregoing advantages, as broadly embodied and described herein, the present invention provides, in a first embodiment, a software system for communicating image information between at least one of a plurality of different input imaging devices and at least one of a plurality of different output imaging devices, the software system comprising one or more input driver components, each of the input driver components being configured to receive image information from one of the input imaging devices, the image information being received according to one of a plurality of different input driver protocols, wherein each of the input driver protocols is specifically associated with one of the input imaging devices, one or more input interpreter components, each of the input interpreter components being configured to generate first imaging requests based on the image information received by one of the input driver components, the first imaging requests being generated according to one of a plurality of different input interpreter protocols, wherein each of the input interpreter protocols is specifically associated with one of the input imaging devices, one or more output interpreter components, each of the output interpreter components being configured to generate second imaging requests based on the first imaging requests generated by one of the input interpreter components, the second imaging requests being generated according to one of a plurality of different output interpreter protocols, wherein each of the output interpreter protocols is specifically associated with one of the output imaging devices, one or more output driver components, each of the output driver components being configured to communicate the second imaging requests generated by one of the output interpreter components to one of the output imaging devices, the second imaging requests being communicated according to one of a plurality of different output driver protocols, wherein each of the output driver protocols is specifically associated with one of the output imaging devices, and an interface executive component for defining one or more communication pipelines, each of the pipelines communicatively interconnecting one of the input imaging devices, one of the input driver components, one of the input interpreter components, one of the output interpreter components, one of the output driver components, and one of the output imaging devices. 
     In a second embodiment, the present invention provides an imaging system having a software system for communicating image information between at least one of a plurality of different input imaging devices and at least one of a plurality of different output imaging devices, the imaging system comprising one or more input driver components, each of the input driver components being configured to receive image information from one of the input imaging devices, the image information being received according to one of a plurality of different input driver protocols, wherein each of the input driver protocols is specifically associated with one of the input imaging devices, one or more input interpreter components, each of the input interpreter components being configured to generate first imaging requests based on the image information received by one of the input driver components, the first imaging requests being generated according to one of a plurality of different input interpreter protocols, wherein each of the input interpreter protocols is specifically associated with one of the input imaging devices, one or more output interpreter components, each of the output interpreter components being configured to generate second imaging requests based on the first imaging requests generated by one of the input interpreter components, the second imaging requests being generated according to one of a plurality of different output interpreter protocols, wherein each of the output interpreter protocols is specifically associated with one of the output imaging devices, one or more output driver components, each of the output driver components being configured to communicate the second imaging requests generated by one of the output interpreter components to one of the output imaging devices, the second imaging requests being communicated according to one of a plurality of different output driver protocols, wherein each of the output driver protocols is specifically associated with one of the output imaging devices, and an interface executive component for defining one or more communication pipelines, each of the pipelines communicatively interconnecting one of the input imaging devices, one of the input driver components, one of the input interpreter components, one of the output interpreter components, one of the output driver components, and one of the output imaging devices. 
     In a third embodiment, the present invention provides a software system for communicating image information between at least one of a plurality of different input imaging devices and at least one of a plurality of different output imaging devices, the software system comprising one or more input interface components, each of the input interface components being configured to receive image information from one of the input imaging devices, the image information being received according to one of a plurality of different input interface protocols, wherein each of the input interface protocols is specifically associated with one of the input imaging devices, and to generate first imaging requests based on the received image information, the first imaging requests being generated according to the one of the input interface protocols, one or more output interface components, each of the output interface components being configured to generate second imaging requests based on the first imaging requests generated by one of the input interface components, the second imaging requests being generated according to one of a plurality of different output interface protocols, wherein each of the output interface protocols is specifically associated with one of the output imaging devices, and to communicate the second imaging requests generated by one of the output interface components to one of the output imaging devices, the second imaging requests being communicated according to the one of the output interface protocols, and an interface executive component for defining one or more communication pipelines, each of the pipelines communicatively interconnecting one of the input imaging devices, one of the input interface components, one of the output interface components, and one of the output imaging devices. 
     In a fourth embodiment, the present invention provides an imaging system having a software system for communicating image information between at least one of a plurality of different input imaging devices and at least one of a plurality of different output imaging devices, the software system comprising one or more input interface components, each of the input interface components being configured to receive image information from one of the input imaging devices, the image information being received according to one of a plurality of different input interface protocols, wherein each of the input interface protocols is specifically associated with one of the input imaging devices, and to generate first imaging requests based on the received image information, the first imaging requests being generated according to the one of the different input interface protocols, one or more output interface components, each of the output interface components being configured to generate second imaging requests based on the first imaging requests generated by one of the input interface components, the second imaging requests being generated according to one of a plurality of different output interface protocols, wherein each of the output interface protocols is specifically associated with one of the output imaging devices, and to communicate the second imaging requests generated by one of the output interface components to one of the output imaging devices, the second imaging requests being communicated according to the one of the output interface protocols, and an interface executive component for defining one or more communication pipelines, each of the pipelines communicatively interconnecting one of the input imaging devices, one of the input interface components, one of the output interface components, and one of the output imaging devices. 
     It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only, and not restrictive of the present invention, as claimed. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The accompanying drawings are included to provide a further understanding of the present invention and are incorporated in and constitute a part of this specification. The drawings illustrate exemplary embodiments of the present invention and together with the description serve to explain the principles of the invention. 
     FIG. 1 is a functional block diagram of a medical imaging system for communication of image information between multiple-protocol imaging devices, in accordance with the present invention; 
     FIG. 2 is a diagram of the relationship between a plurality of diverse protocols and a set of base-class protocols, in accordance with the present invention; and 
     FIG. 3 is a functional block diagram of a client-server relationship applicable to the medical imaging system shown in FIG. 1, in accordance with the present invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     FIG. 1 is a functional block diagram of a medical imaging system 10 for communication of image information between multiple-protocol imaging devices, in accordance with the present invention. The medical imaging system 10 includes a plurality of input imaging devices 12, one or more input interface components 14, one or more output interface components 16, and one or more output imaging devices 18. Each of the input interface components 14 includes an input driver component 20 and an input interpreter component 22. Each of the output interface components 16 includes an output interpreter component 24 and an output driver component 26. An interface executive component 28 defines one or more (1 to N) communication pipelines 30. Each communication pipeline 30 communicatively binds one of the input imaging devices 12, one of the input driver components 20, one of the input interpreter components 22, one of the output interpreter components 24, one of the output driver components 26, and output imaging device 18 in a bi-directional manner. The output imaging device 18 may communicate with any of pipelines 30 on a shared basis. Alternatively, a plurality of output imaging devices 18 could be provided, each being communicatively interconnected with a particular pipeline 30. 
     The input interface components 14, output interface components 16, and interface executive component 28 are implemented as a software system that interfaces with input imaging devices 12 and output imaging device 18. The software system may be implemented as part of an output imaging device 18, such as a continuous tone digital laser imager, or as part of a discrete device controlling communication of image information between input imaging devices 12 and output imaging device 18. An example of a laser imager to which the software system may be readily applied is disclosed in copending U.S. patent application Ser. No. 07/981,075, of Schubert et al., the entire content of which is incorporated herein by reference. The image information generated by input imaging device 12 includes both requests for imaging operations, and image data containing digital image values representative of an image to be handled by output imaging device 18. For purposes of this description, pipeline 30 will be described as handling communication of image information in the form of imaging requests, with image information in the form of digital image values representative of the image being communicated by a separate communication path. It is conceivable, however, that pipeline 30 could be configured to handle communication of image information in the form of both requests for imaging operations and image data containing the digital image values. 
     Each of input interface components 14 is configured to receive the image information, via one of input driver components 20, from an input imaging device 12 according to one of a plurality of different input interface protocols. Each input interface protocol is specifically associated with one of input imaging devices 12, and reflects the modality-specific requirements for communication with the particular input imaging device. Each of the input interface components 14 also is configured to generate first imaging requests according to one of the input interface protocols, via one of input interpreter components 22, based on the content of the received image information. The first imaging requests represent instructions generated by input imaging device 12, as translated by input interpreter component 22 for communication to output interface component 16. 
     Each of output interface components 16 is configured to generate second imaging requests according to one of a plurality of different output protocols, via one of output interpreter components 24, based on the content of the first imaging request. The second imaging requests represent the content of the first imaging requests, as translated by output interpreter component 24 for communication to output imaging device 18. Each output interface protocol is specifically associated with the type of output imaging device 18 and, like the input interface protocol, reflects the requirements for communication with the particular output imaging device. In addition, each of the output interface components 16 is configured to communicate the second imaging requests to output imaging device 18, via output driver component 26, according to one of the output interface protocols. 
     The sub-components of input interface components 14 and output interface components 16, i.e., input driver component 20, input interpreter component 22, output interpreter component 24, and output driver component 26, are described together herein in recognition that an input interface component, as well as an output interface component, could be implemented as a single, integral software module. It is preferred, however, that an input interface component 14 be realized by a discrete input driver component 20 and a discrete input interpreter component 22 and, similarly, that an output interface component 16 be realized by a discrete output interpreter component 24 and a discrete output drive component 26. A discrete implementation of the sub-components divides the functionality of each interface component 14, 16 into smaller packages for better modularity. As an example, with added modularity, changes in hardware interface specifications for an input imaging device 12 require only reconfiguration of input driver component 20, instead of the entire input interface component 14. 
     Each of the input interface protocols includes both an input driver protocol applicable to input driver components 20 and an input interpreter protocol applicable to input interpreter components 22. The appropriate input driver protocol is determined by the communication requirements of a particular input imaging device 12, whereas the appropriate input interpreter protocol is determined by the image information format of the particular input imaging device. The image information format refers to the types of imaging requests generated according to the protocol of a particular input imaging device 12. The input driver protocol specifies the manner in which an input driver component 20 should carry out the transfer of image information from an input imaging device 12. The input interpreter protocol specifies the manner in which input interpreter component 22 should interpret the image information to generate the first imaging requests. The input driver and input interpreter protocols can vary significantly according to differences in the type of input imaging device 12, e.g., MR, CT, conventional X-ray, ultrasound, as well as the manufacturer of the input imaging device, e.g., Siemens, Toshiba, GE, or Picker. 
     Each of the output interface protocols includes an output interpreter protocol applicable to output interpreter components 24 and an output driver protocol applicable to output driver components 26. The output driver protocol is determined by the communication requirements of output imaging device 18, whereas the appropriate output interpreter protocol is determined by the image information format of the output imaging device. The output interpreter protocol specifies the manner in which output interpreter component 24 should interpret first imaging requests to generate second imaging requests in a form understood by output imaging device 18. The input driver protocol specifies the manner in which an output driver component 20 should carry out the transfer of second imaging requests to output imaging device 18. Like the input interface protocols, the output interface protocols are subject to variation. For example, both the output driver and output interpreter protocol can vary according to the type of functional capabilities provided by output imaging device 18, e.g., 831, 952, or Superset in the case of a laser imager manufactured by 3M. 
     Notwithstanding functions specific to a particular protocol, components 20, 22, 24, 26 of like type, e.g., all input driver components, are configured to perform several common tasks. For example, input driver components 20 share a set of common tasks necessary to communicate with a particular input imaging device 12. An input driver component 20 is configured to handle any hardware specifics such as interrupts, buffers, and handshaking necessary to transfer imaging information to and from a particular input imaging device 12. The input driver component 20 is further configured to handle any other specific needs of input imaging device 12, such as packetizing or initialization. The input driver component 20 performs all necessary communication tasks, isolating the remainder of pipeline 30 from any knowledge that communication is carried out via a serial interface, a parallel interface, a network interface, or any other mechanism. In summary, the responsibility of input driver component 20 is two-fold. First, input driver component 20 receives image information from input imaging device 12 and prepares the image information for the next stage of pipeline 30, i.e., input interpreter component 22. Second, input driver component 20 transmits any responses emerging from bi-directional pipeline 30 to input imaging device 12, as will be further explained below. 
     The input interpreter component 22, the next component in pipeline 30, also shares a common set of tasks with other input interpreter components, without regard to a specific input interpreter protocol. Primarily, after obtaining image information from an input driver component 20, an input interpreter component 22 analyzes requests contained in the image information and translates them to generate first imaging requests corresponding to operations provided by output imaging device 18. The first imaging requests include requests for a variety of common imaging services provided by output imaging device 18. In a typical medical imaging system, such requests may include, for example, requests to initiate an image print job by output imaging device 18, requests to abort a previously initiated image print job, requests to define or modify a format of an image to be printed, requests to delete a set of image data representative of a previously acquired image, and requests to store image data in a particular image location. 
     The manner in which input interpreter component 22 interprets the requests generated by input imaging device 12 may vary according to the specific input interpreter protocol. The input interpreter component 22 understands the precise format, instructions, and timing constraints inherent in the image information generated by a particular input imaging device 12. Nevertheless, all input interpreter components 22 still provide a common, basic function of generating first imaging requests. The input interpreter component 22 sends the first imaging requests along pipeline 30. Once the first imaging requests have been processed by downstream components in bi-directional pipeline 30, and a response has been received, input interpreter component 20 forms an appropriate response for input imaging device 12. The input interpreter component 22 sends the response along pipeline 30 to input imaging device 12, via input driver component 20, which handles communication requirements necessary to transmit the response to the input imaging device. 
     The output interpreter component 24 is the third component in pipeline 30. The output imaging device 18 may speak one of many different protocols, such as 831, 952, or Superset in the case of a laser imager manufactured by 3M. An output interpreter component 24 is configured to receive, via pipeline 30, first imaging requests generated by an input interpreter component 22, and to interpret the first imaging requests to generate second imaging requests, which conform to the particular protocol required by output imaging device 18. The second imaging requests correspond to the first imaging requests in substance, but are configured according to the output protocol understood by output imaging device 18.. Thus, the second imaging requests serve as requests for the same imaging services specified by first imagng requests. The manner in which an output interpreter component 24 interprets the instructions may vary according to the specific output interpreter protocol dictated by output imaging device 18, but all output interpreter components 24 share a common task of generating second imaging requests in a protocol understood by the output imaging device. The output interpreter component 24 sends the second imaging requests along pipeline 30. When output imaging device 18 processes the second imaging requests and formulates a response received via pipeline 30, output interpreter component 24 removes any output protocol-specific information and forms an appropriate response for input interpreter component 22. 
     The output driver component 26 is the fourth component in pipeline 30. Like input driver components 20, all output driver components 26 perform a common set of communication tasks. Specifically, an output driver component 26 is configured to handle any hardware specifics such as interrupts, buffers, and handshaking necessary to transfer imaging information to and from a particular output imaging device 18. The output driver component 26 isolates the remainder of pipeline 30 from any knowledge that communication with output imaging device 18 is carried out via a serial interface, a parallel interface, or a dual-port RAM, etc. The output driver component 26 transmits second imaging requests generated by an output interpreter component 24 to output imaging device 18, maintaining any communication requirements. Further, output driver component 26 receives responses from output imaging device 18, and prepares the response for transmission to output interpreter component 24 via bi-directional pipeline 30. 
     The interface executive component 28, which defines the structure of pipeline 30, is the fifth component of the software system. The interface executive component 28 is configured to communicatively interconnect a number of components 20, 22, 24, 26 having different protocols on a selected basis to provide significant flexibility. This flexibility provides a medical imaging system 10 capable of achieving communication between a variety of different input imaging devices 12 and one or more output imaging devices 18 having a variety of different functional capabilities. Thus, interface executive component 28 treats each functionally independent component 20, 22, 24, 26 as a &#34;black box&#34; with a clearly identified set of responsibilities and a defined interface. The interface executive component 28 selects the appropriate series of black boxes based on the environment, and binds them together with &#34;handles&#34; to one another to form the complete pipeline 30. As a further advantage, interface executive component 28 preferably is configured to dynamically bind the components &#34;on the fly&#34; to form a communication pipeline 30 appropriate for the current imaging environment. Moreover, interface executive component is configured to produce a scalable software architecture having a plurality (1-N) of communication pipelines 30 configured according to different protocols. The scalable architecture enables output imaging device 18 to communicate simultaneously with several input imaging devices 12 on a shared basis using the necessary protocols, as provided by each pipeline 30. Alternatively, a plurality of output imaging devices 18 can be provided, each being communicatively interconnected with a particular pipeline 30. 
     The interface executive component 28 scales the software architecture to match the requirements of the environments, creating as many pipelines 30 as there are input imaging devices 12 requiring an interface with an output imaging device 18. The interface executive component 28 selectively binds a series of components 20, 22, 24, 26 having specific protocols necessary to match a particular input imaging device 12, a particular output imaging device 18, and the required hardware interfaces. The nature of components 20, 22, 24, 26 enables them to be selectively &#34;swapped&#34; in or out of a pipeline 30 in a modular fashion by interface executive component 28. Each of the components 20, 22, 24, 26 is made interchangeable with another component of like type, but different protocol, by a series of software interfaces. Specifically, each component is configured according to a particular protocol, but includes a &#34;base-class&#34; software interface that translates the protocol into a base-class protocol generic to every component of like type. The base-class interface is preferably built into each component such that any component 20, 22, 24, 26 in a pipeline 30 can be replaced without affecting the configuration of the other components in the pipeline. Thus, individual components 20, 22, 24, 26 also can be reused, significantly reducing costs previously associated with redesign efforts. 
     For example, if pipeline 30 were to be configured for communication between a Siemens input imaging device 12 and an output imaging device 18 implementing 3M SuperSet functionality, all via serial data, interface executive component 28 would communicatively bind: (1) an input driver component 20 having an input driver protocol appropriate for receiving imaging information via a serial hardware interface associated with the Siemens input imaging device, (2) an input interpreter component 22 having an input interpreter protocol appropriate for generation of first imaging requests based on the format of the image information received form the Siemens input imaging device, (2) an output interpreter component 24 having an output interpreter protocol appropriate for generation of second imaging requests understood by the 3M SuperSet output imaging device, and (4) an output driver component 26 having an output driver protocol appropriate for communication of the second imaging requests via a serial hardware interface associated with the 3M SuperSet output imaging device. 
     Alternatively, if the pipeline 30 described above were to be modified for communication between a Toshiba input imaging device 12 and a 3M SuperSet output imaging device 18, all via serial data, it would only be necessary to &#34;swap&#34; the input driver component 20 and input interpreter component 22 with components configured according to input driver and input interpreter protocols, respectively, appropriate for the Toshiba modality. The output interface component 16, which includes a 3M Superset-configured output interpreter component 24 and a 3M Superset serial-configured output driver component 26, would already be configured according to the requirements of output imaging device 18, independently of input imaging device 12, and therefore would be unaffected by the modification. Thus, interface executive component 28 would communicatively bind: (1) an input driver component 20 having an input driver protocol appropriate for receiving imaging information via a serial hardware interface associated with the Toshiba input imaging device, (2) an input interpreter component 22 having an input interpreter protocol appropriate for generation of first imaging requests based on the format of the image information received form the Toshiba input imaging device, (2) an output interpreter component 24 having an output interpreter protocol appropriate for generation of second imaging requests understood by the 3M SuperSet output imaging device, and (4) an output driver component 26 having an output driver protocol appropriate for communication of the second imaging requests via a serial hardware interface associated with the 3M SuperSet output imaging device. 
     As another alternative, if the pipeline 30 described above were to be modified for communication between a Toshiba input imaging device 12 and a 3M 952 output imaging device 18, all via serial data, only modification of output interface component 16 would be necessary. Specifically, interface executive component 28 would communicatively bind: (1) an input driver component 20 having an input driver protocol appropriate for receiving imaging information via a serial hardware interface associated with the Toshiba input imaging device, (2) an input interpreter component 22 having an input interpreter protocol appropriate for generation of first imaging requests based on the format of the image information received form the Toshiba input imaging device, (2) an output interpreter component 24 having an output interpreter protocol appropriate for generation of second imaging requests understood by the 3M 952 output imaging device, and (4) an output driver component 26 having an output driver protocol appropriate for communication of the second imaging requests via a serial hardware interface associated with the 3M 952 output imaging device. Thus, input interface component 14, including a general serial-configured input driver component 20 and a Toshiba-configured input interpreter component 22, would be unaffected by the modification. 
     Finally, if the pipeline 30 described above were to be modified for communication between a Toshiba input imaging device 12 having a serial hardware interface and a 3M 952 output imaging device 18, having a dual-port RAM interface, only modification of output interface component 16 would be necessary. Specifically, interface executive component 28 would communicatively bind: (1) an input driver component 20 having an input driver protocol appropriate for receiving imaging information via a serial hardware interface associated with the Toshiba input imaging device, (2) an input interpreter component 22 having an input interpreter protocol appropriate for generation of first imaging requests based on the format of the image information received form the Toshiba input imaging device, (2) an output interpreter component 24 having an output interpreter protocol appropriate for generation of second imaging requests understood by the 3M 952 output imaging device, and (4) an output driver component 26 having an output driver protocol appropriate for communication of the second imaging requests via a dual-port RAM hardware interface associated with the 3M 952 output imaging device. Thus, input interface component 14, including a general serial-configured input driver component 20 and a Toshiba-configured input interpreter component 22, would be unaffected by the modification. 
     To facilitate interchangeability, as described above, the software interfaces between components 20, 22, 24, 26 must be pre-defined to make each type of component generic. At the same time, however, an individual component 20, 22, 24, 26 must be configured to implement functions specific to a particular protocol. In accordance with the present invention, the solution lies in object-oriented techniques that are used to develop a generic base-class protocol for each type of component, e.g., input driver component 20. The generic base-class protocol specifies the functions provided by a component and the procedures for accessing such functions. Each specific protocol component &#34;inherits&#34; from the corresponding base class protocol, and implements the interface to conform to the environment. The term &#34;inheritance&#34; is used herein to refer to an object-oriented programming concept by which abstract data types can be extended to allow for type/subtype relationships. Rather than reimplementing shared characteristics, a class can inherit selected data members and member functions of other classes. 
     Class inheritance allows the members of one class to be used as if they were members of a second class. No additional programming is required to implement the subclass, except for those operations that either extend or replace the members inherited from the other classes. As an object-oriented system develops, subclasses are constructed out of existing classes until the appropriate functionality is developed. The construction of subclasses results in the formation of a class hierarchy. The class hierarchy is rooted by a special class, referred to as the base class. The base class contains a minimal set of behavior common to all subclasses. In accordance with the present invention, each component 20, 22, 24, 26 is configured according to a specific protocol, but also serves as a sub-class of the base class protocol. Because each component 20, 22, 24, 26 inherits from the base-class protocol and implements a minimal set of functions such that they meet base-class requirements, it can be directly interchanged with any other component of like type that inherits from the same base-class protocol. The interchangeability resulting from the object-oriented techniques produces a &#34;direct-connect&#34; software architecture in which each component can be effectively plugged into pipeline 30 without the need for additional interface development. 
     FIG. 2 is an example of an object-oriented protocol hierarchy that facilitates interchangeability of components 20, 22, 24, 26. The protocol hierarchy illustrates the implementation of components 20, 22, 24, 26 for specific protocols that each &#34;inherit&#34; from a genetic base-class protocol. For example, an input driver base protocol 32 may encompass a plurality of &#34;inheriting&#34; input driver protocols for different hardware interface requirements associated with an input imaging device 12, such as a general serial input driver protocol 34, an SCSI input driver protocol 36, a Siemens serial input driver protocol 38, or a parallel input driver protocol 39. A base-class input interpreter protocol 40 may encompass a plurality of inheriting input interpreter protocols for different types of input imaging devices 12 or manufacturers, such as a GE input interpreter protocol 42, a Toshiba input interpreter protocol 44, a Siemens input interpreter protocol 46, or a Picker input interpreter protocol 48. As shown in FIG. 2, base-class input interpreter protocol 40 may also encompass inheriting protocols for user interface devices such as a keypad protocol 50. 
     Similarly, a base-class output interpreter protocol 52 may encompass a plurality of inheriting output interpreter protocols for different types of output imaging devices 18, such as a 3M SuperSet output interpreter protocol 54, a 3M 831 output interpreter protocol 56, or a 3M 952 output interpreter protocol 58. Finally, a base-class output driver protocol 60 may encompass a plurality of inheriting output driver protocols for different hardware interface requirements associated with output imaging device 18, such as a dual-port RAM output driver protocol 62, a serial output driver protocol 64, or a parallel output driver protocol 65. Each of the inheriting protocols described above includes protocol-specific functions provided by a component 20, 22, 24, 26, but implements such functions via a generic interface that inherits from the corresponding base-class protocol 32, 40, 52, 60. For each base-class protocol 32, 40, 52, 60, described above, a variety of additional inheriting protocols can be implemented, according to the requirements of the medical imaging system environment. 
     As shown in FIG. 3, interface executive component 28 preferably defines pipeline 30 according to a client-server architecture. In FIG. 3, an arrow pointing from a component A to a component B indicates that component A is a client component of server component B. The bi-directional arrows between input driver component 20 and input imaging device 12 and between output driver component 26 and output imaging device 18 do not represent a client-server relationship, but rather the hardware/software interfaces of medical imaging system 10. As indicated by the arrows in FIG. 3, interface executive component 28 preferably defines the client-server relationship such that input interpreter component 22 is a client component of both input driver component 20 and output interpreter component 24, and output interpreter component 24 is a client component of output driver component 26. Consequently, input driver component 20 and output interpreter component 24 are server components for input interpreter component 22, and output driver component 26 is a server component for output interpreter component 24. The interface executive component 28, itself, is a client component of input driver component 20, input interpreter component 22, output interpreter component 24, and output driver component 26. 
     In the client-server relationship described above, both input driver component 20 and output driver component 26 are purely server components for input interpreter component 22 and output interpreter component 24, respectively. The input driver component 20 and output driver component 26 are responsible for low-level hardware requirements and are under control of the higher-level input interpreter component 22 and output interpreter component 24, respectively. The input interpreter component 22 is a client component of output interpreter component 24, which provides a set of functions by which the input interpreter component controls output imaging device 18. The output interpreter component 24 never initiates communication with input interpreter component 22, but rather provides services at the request of the input interpreter component. Finally, every component 20, 22, 24, 26 is a server component for interface executive component 28. Thus, interface executive component 28 ultimately controls the entire software system. 
     Communication between components 20, 22, 24, 26, 28 in the client-server relationship is carried out by the issuance of remote procedure calls (RPC&#39;s). A remote procedure call is a common communication mechanism often used in complex distributed software systems. A client component executes a particular function by issuing a remote procedure call to a corresponding server component. The use of remote procedure calls hides the specific details and dependencies, i.e., protocol-specific characteristics, of the individual components. The remote procedure call handles all of the mechanisms necessary for intercomponent communication. As a result, the communication mechanisms remain generic, eliminating the need for the design of protocol-specific mechanisms in each component. Each component 20, 22, 24, 26 is configured to provide services to a client component, but is unaware of which or how many components are actually using it as a server component. The components 20, 22, 24, 26 simply perform the requests of client components without exhibiting protocol-specific dependencies. 
     A remote procedure call is used to execute a function in the following manner. First, when a software process being performed by a client component needs to execute a particular function, the process simply calls the function by its identifier. A layer of software residing within the client component, commonly referred to as a &#34;client stub,&#34; traps the function call. If the client stub determines that the software code necessary to perform the called function actually exists within another server component, the client stub creates a message enclosing any data passed with the function call, as well as any necessary packetizing and addressing. The client stub then sends the message to the server component via the real time operating system existing in the software system. The server module contains a layer of software code, known as the server stub, that receives the message. The server stub strips apart the message and actually calls the correct local function with any data pulled from the message. The local function executes as if it were originally called locally, returning any information requested. The server stub creates a response based on the returned information, and sends the response to the client component via the operating system. Upon receipt of the response, the client stub pulls out the returned information and passes the information to the local software process that originally called the function. The local software process then continues unaware that any inter-module communication occurred. 
     The following sections provide details concerning the manner in which each base-class protocol can be implemented in an exemplary embodiment of medical imaging system 10, in accordance with the present invention. In particular, sections A-D provide exemplary definitions and requirements of services provided by each of components 20, 22, 24, 26, represented for purposes of illustration in the C++ object-oriented programming language, with comments included where applicable. Where C++ code is used below to exemplify the functionality of a particular component, the label &#34;host&#34; may be used to refer to input imaging device 12 and the label &#34;laser imager&#34; or &#34;LI&#34; may be used to refer to output imaging device 18. 
     A. The Input Driver Base-Class Protocol 
     The input driver base-class protocol, in this exemplary embodiment, includes seven remote procedure calls that input driver component 20 is required to provide for its client components, interface executive component 28 and input interpreter component 22. With the remote procedure calls, a client component can directly interface with an external input imaging device 12 via input driver component 20. The seven remote procedure calls are described below in terms of the types of parameters handled and the functions performed. 
     
         ______________________________________                                    
1.   xmit.sub.-- message                                                  
                 Parameters:    Type:                                     
                 message        char *                                    
                 Returns:       Type:                                     
                 Driver return code                                       
                                DRIVER.sub.-- RC                          
______________________________________                                    
 
    
     The above RPC passes a message to the input driver component to transmit to input imaging device 12. All communication requirements for transmission of the message to input imaging device 12 are handled by input driver component 20. 
     
         ______________________________________                                    
2.   receive.sub.-- message                                               
                   Parameters:   Type:                                    
                   message       char *                                   
                   Returns:      Type:                                    
                   Driver return code                                     
                                 DRIVER.sub.-- RC                         
______________________________________                                    
 
    
     The above RPC retrieves a message from input driver component 20 that has been sent from the host. Again, all communication requirements for transmission of the message to input imaging device 12 are handled by input driver component 20. 
     
         ______________________________________                                    
3.   set.sub.-- xmit.sub.-- timeout                                       
                   Parameters:   Type:                                    
                   timeout       int                                      
                   Returns:      Type:                                    
                   Driver return code                                     
                                 DRIVER.sub.-- RC                         
______________________________________                                    
 
    
     The above RPC sets a timeout value that input driver component 20 uses when sending a message to input imaging device 12. 
     
         ______________________________________                                    
4.  set.sub.-- async.sub.-- func                                          
                Parameters:   Type:                                       
                client ptr    FE.sub.-- CLIENT.sub.-- PTR                 
                method ptr    FE.sub.-- METHOD.sub.-- PTR                 
                Returns:      Type:                                       
                Driver return code                                        
                              DRIVER.sub.-- RC                            
______________________________________                                    
 
    
     The above RPC gives the input driver component 20 a handle to an asynchronous handler associated with the client component. The above RPC provides a means by which input driver component 20 informs the client component of an asynchronous event that has occurred. The only asynchronous event that will occur relative, to input driver component 20, is MSG --  PENDING, which indicates that a message has been fully received by the input driver component from the input imaging device 12 and is ready for input interpreter component 22. 
     
         ______________________________________                                    
5.  set.sub.-- debug.sub.-- level                                         
                 Parameters:   Type:                                      
                 debug level   DEBUG.sub.-- LEVEL                         
                 Returns:      Type:                                      
                 Driver return code                                       
                               DRIVER.sub.-- RC                           
______________________________________                                    
 
    
     The above RPC allows the client components to set the debug level of input driver component 20. The debug levels are NO --  DEBUG, LOW --  DEBUG, MEDIUM --  DEBUG, and HIGH --  DEBUG. This parameter affects the information displayed during debugging. 
     
         ______________________________________                                    
6.   start.sub.-- comm                                                    
                 Parameters:    Type:                                     
                 none                                                     
                 Returns:       Type:                                     
                 Driver return code                                       
                                DRIVER.sub.-- RC                          
______________________________________                                    
 
    
     The above RPC activates communication between input driver component 20 and input imaging device 12. 
     
         ______________________________________                                    
7.     stop.sub.-- comm                                                   
                  Parameters:    Type:                                    
                  none                                                    
                  Returns:       Type:                                    
                  Driver return code                                      
                                 DRIVER.sub.-- RC                         
______________________________________                                    
 
    
     The above RPC disables communication between input driver component 20 and input imaging device 12. 
     As indicated above, each RPC returns from input driver component 20 one of three driver return codes: (1) RPC --  OK, (2) PORT --  BUSY, and (3) NO --  MESSAGE. The driver return codes can be defined in C++ as follows: 
     
         ______________________________________                                    
//Set return types for I/O Driver interface                               
typedef enum {                                                            
 RPC.sub.-- OK, //RPC was issued and acknowledged                         
 PORT.sub.-- BUSY, //Transmit RPC failed, port already transmitting       
 NO.sub.-- MESSAGE //Receive RPC failed, no message pending               
} DRIVER.sub.-- RC;                                                       
______________________________________                                    
 
    
     The actual base-class protocol for input driver component 20 can be defined in C++ as follows: 
     
         ______________________________________                                    
class INPUT.sub.-- INTERFACE                                              
protected:                                                                
 INT32 return.sub.-- code;                                                
                    // RC for OS operations                               
 //Expect generic pipe interface from lower level hardware ports          
 PORT.sub.-- ID port;                                                     
                    //This port ID                                        
 DEBUG.sub.-- LEVELS debug.sub.-- level;                                  
                    //Current debug level                                 
 FE.sub.-- CLIENT.sub.-- PTR client;                                      
 FE.sub.-- CLIENT.sub.-- METHOD.sub.-- PTR async.sub.-- event.sub.--      
handler;                                                                  
public:                                                                   
 INPUT.sub.-- INTERFACE(PORT.sub.-- ID newport);                          
 ˜INPUT.sub.-- INTERFACE(void);                                     
 //RPC&#39;s that are available to clients                                    
 //Hide hardware interface via an event driven RPC interface              
 virtual DRIVER.sub.-- RC xmit.sub.-- message(char *message) = 0;         
 virtual DRIVER.sub.-- RC receive.sub.-- message(char *message) =0;       
 virtual DRIVER.sub.-- RC set.sub.-- xmit.sub.-- timeout(int timeout)     
=0;                                                                       
 virtual DRIVER.sub.-- RC set.sub.-- async.sub.-- func(FE.sub.-- CLIENT.su
b.-- PTR,                                                                 
 FE.sub.-- CLIENT.sub.-- METHOD.sub.-- PTR) =0;                           
 virtual DRIVER.sub.-- RC start.sub.-- comm(void);                        
 virtual DRIVER.sub.-- RC stop.sub.-- comm(void);                         
 void set.sub.-- debug.sub.-- levels(DEBUG.sub.-- LEVELS);                
};                                                                        
______________________________________                                    
 
    
     B. The Input Interpreter Base-Class Protocol 
     The input interpreter base-class protocol, in this exemplary embodiment, includes four remote procedure calls that input interpreter component 22 is required to provide for its client component, interface executive component 28. With the remote procedure calls, interface executive component 28 can communicate with input interpreter component 22. The four remote procedure calls for input interpreter component 22 are described below in terms of the types of parameters handled and the functions performed. 
     
         ______________________________________                                    
1.  rcvConfiguration                                                      
                  Parameters:     Type:                                   
                  pointer to parameters                                   
                                  Param.sub.-- Blk                        
                  Returns:        Type:                                   
                  void            n/a                                     
______________________________________                                    
 
    
     The above RPC passes a pointer to input interpreter component 22 that points to configuration parameters for the component. The parameters have been stored since the last power-down sequence of system 10. The parameters are stored in a read-only block of a memory associated with output imaging device 18. Thus, any changes made by input interpreter component 22 will not be reflected on the next power-up. 
     
         ______________________________________                                    
2.  li.sub.-- event.sub.-- handler                                        
                  Parameters:    Type:                                    
                  laser imager event                                      
                                 IO.sub.-- EVENT                          
                  Returns:       Type:                                    
                  void           n/a                                      
______________________________________                                    
 
    
     The above RPC receives asynchronous events from input driver component 20. The asynchronous events, which include the receipt of messages from an input imaging device 12, are described above with reference to input driver component 20. 
     
         ______________________________________                                    
3.  io.sub.-- event.sub.-- handler                                        
                 Parameters:                                              
                           Type:                                          
                 io event  LI.sub.-- INTERFACE.sub.-- EVENT               
                 Returns:  Type:                                          
                 void      n/a                                            
______________________________________                                    
 
    
     The above RPC receives asynchronous events from output imaging device 18 via output interpreter component 24 and output driver component 26. The asynchronous events received from output imaging device 18 are described in more detail below with reference to output interpreter component 24. 
     
         ______________________________________                                    
4.  set.sub.-- debug.sub.-- level                                         
                 Parameters:   Type:                                      
                 debug level   DEBUG.sub.-- LEVEL                         
                 Returns:      Type:                                      
                 Driver return code                                       
                               DRIVER.sub.-- RC                           
______________________________________                                    
 
    
     The above RPC allows the client component, interface executive component 28, to set the debug level for input interpreter component 22. The debug levels include NO --  DEBUG, LOW --  DEBUG, MEDIUM --  DEBUG, and HIGH --  DEBUG. This parameter affects the information displayed during debugging. 
     As noted above, input interpreter component 22 provides a mechanism for handling asynchronous events received from output imaging device 18. The events serve to inform input interpreter component 22 of a status change at output imaging device 18. Various events indicating the status of output imaging device 18 may include: (1) FP --  status change which indicates a film processor associated with the output imaging device has changed its status, (2) PR --  status --  change which indicates imaging hardware associated with the output imaging device has changed its status, (3) IMS --  status --  change which indicates an image management system responsible for formatting image data within the output imaging device has changed its status, (4) JOB --  status --  change which indicates an imaging job has changed its status, and (5) XFR --  status --  change which indicates a transfer job, involving a background transfer of image data, has changed its status. The function of the above status events is to avoid the need for input interpreter component 22 to continuously poll output imaging device 18. 
     The actual base-class protocol for input interpreter component 22 can be defined in C++ as follows: 
     
         __________________________________________________________________________
class FRONTEND.sub.-- EXECUTIVE {                                         
protected:                                                                
 INT32 return.sub.-- code;                                                
                    // RC for OS operations                               
 int exec.sub.-- id;                                                      
 Semaphore event.sub.-- reply;                                            
                    // async event received                               
 Semaphore event.sub.-- free;                                             
                    // async event mailbox free                           
 Mailbox event.sub.-- mbox;                                               
                    // event mailbox                                      
 FRONTEND.sub.-- EXECUTIVE(int, LI.sub.-- INTERFACE *,INPUT.sub.--        
INTERFACE *);                                                             
 ˜FRONTEND.sub.-- EXECUTIVE(void);                                  
 LI.sub.-- INTERFACE *li.sub.-- handle;                                   
                    //Handle to LI interface                              
 INPUT.sub.-- INTERFACE *input.sub.-- handle;                             
                    //Handle to IO interface                              
 DEBUG.sub.-- LEVELS debug.sub.-- level;                                  
                    //Debug level for module                              
 Param.sub.-- Blk parameters;                                             
                    //Pointer to parameters                               
 LI.sub.-- async.sub.-- data li.sub.-- async.sub.-- data;                 
                    //Data from LI events                                 
public:                                                                   
 virtual void io.sub.-- event.sub.-- handler(IO.sub.-- EVENT              
event)=0;//input driver ev handler                                        
 virtual void li.sub.-- event.sub.-- handler(LI.sub.-- INTERFACE.sub.--   
EVENT,LI.sub.-- async.sub.-- data)=0;                                     
 virtual void rcvConfiguration(Param.sub.-- Blk)=0;//receive pointer of   
param block                                                               
 virtual void set.sub.-- debug.sub.-- level(DEBUG.sub.-- LEVELS level);   
//set to new debug level                                                  
};                                                                        
__________________________________________________________________________
 
    
     C. The Output Interpreter Base-Class Protocol 
     The input interpreter component 22 interfaces with output interpreter component 24 via a set of imaging objects. The imaging objects serve as parameters for the remote procedure calls and contain all of the available information concerning the characteristics of output imaging device 18 and the imaging process. The input interpreter component 22 can use any part of the information and disregard the rest. There are six imaging object definitions including (1) a box object, (2) a format object, (3) an image object, (4) a test image object, 5) a string object, and 6) a variety of general imaging parameter objects. 
     A format object is used to describe an entire sheet of imaging media on which output imaging device 18 will form an image. The format object holds information relating to film type, film size, border color, border density, etc. The charactersitics of the format object can be defined in C++ as follows: 
     
         __________________________________________________________________________
class FORMAT {                                                            
public:                                                                   
 FORMAT(FORMAT.sub.-- ID);                                                
                   // Constructor                                         
 FORMAT(void);     // Constructor                                         
 void init(void);  // Initialize parameters to defaults                   
 FORMAT.sub.-- ID id;                                                     
                   // Format to which this box belongs                    
 TABLE bkgnd.sub.-- color.sub.-- table;                                   
                   // Background/border color media table                 
 TABLE bkgnd.sub.-- color.sub.-- mixing.sub.-- table;                     
                   // Background/border color mixing table                
 LEVEL bw.sub.-- border.sub.-- level;                                     
                   // B&amp;W border level                                    
 COLOR color.sub.-- brd.sub.-- level;                                     
                   // Border Color levels                                 
 LEVEL bw.sub.-- density.sub.-- max;                                      
                   // B&amp;W maximum density                                 
 FILM.sub.-- TYPE film.sub.-- type;                                       
                   // Type of film to use                                 
 FILM.sub.-- SIZE film.sub.-- size;                                       
                   // Size of film to use                                 
};                                                                        
__________________________________________________________________________
 
    
     A box is a rectangular area of the film sheet designated to hold an image. The box has many characteristics including location, size, contrast, color, etc. The box definitions are associated with a particular format. That is, several boxes are used in conjunction with a particular format. The following C++ code describes the box object and its characteristics: 
     
         __________________________________________________________________________
class BOX {                                                               
public:                                                                   
 BOX(BOX.sub.-- ID id,FORMAT.sub.-- ID id),                               
                   // Constructor                                         
 BOX(void);        // Constructor                                         
 void init(void);  // Initialize parameters to defaults                   
 BOX.sub.-- ID id; // Box id #                                            
 FORMAT.sub.-- ID format.sub.-- id;                                       
                   // Format the box                                      
 TABLE beta.sub.-- x1;                                                    
                   // Horizontal axis beta pass 1                         
 TABLE beta.sub.-- y1;                                                    
                   // vertical axis beta pass 1                           
 TABLE beta.sub.-- x2;                                                    
                   // Horizontal axis beta pass 2                         
 TABLE beta.sub.-- y2,                                                    
                   // Vertical axis beta pass 2                           
 TABLE color.sub.-- media.sub.-- table;                                   
                   // Color media table to use                            
 TABLE contrast.sub.-- table;                                             
                   // B&amp;W contrast table to use                           
 TABLE color.sub.-- contrast.sub.-- table;                                
                   // Color contrast table to use                         
 TABLE color.sub.-- mixing.sub.-- table;                                  
                   // Color mixing table to use                           
 FRAME frame;      // Frame to use around border                          
 LOCATION x.sub.-- location;                                              
                   // Horizontal pixel location                           
 LOCATION y.sub.-- location;                                              
                   // Vertical pixel location                             
 Switch.sub.-- mirroring;                                                 
                   // Turn mirroring on and off                           
 Switch rotation;  // Turn rotation on and off                            
 OUTPUT.sub.-- SIZE output.sub.-- size.sub.-- x1;                         
                   // X output size pass 1                                
 OUTPUT.sub.-- SIZE output.sub.-- size.sub.-- y1;                         
                   // Y output size pass 1                                
 OUTPUT.sub.-- SIZE output.sub.-- size.sub.-- x2;                         
                   // X output size pass 2                                
 OUTPUT.sub.-- SIZE output.sub.-- size.sub.-- y2;                         
                   // Y output size pass 2                                
 OFFSET window.sub.-- x.sub.-- offset;                                    
                   // Window X offset from corner                         
 OFFSET window.sub.-- y.sub.-- offset;                                    
                   // Window Y offset from corner                         
 LENGTH window.sub.-- x.sub.-- length;                                    
                   // Horizontal length of window                         
 LENGTH window.sub.-- y.sub.-- length;                                    
                   // Vertical length of window                           
};                                                                        
__________________________________________________________________________
 
    
     An image is represented by image data containing digital image values. The image data is stored in an image memory associated with output imaging device 18. The image object is used to associate certain characteristics with the image. As indicated by the above code, the characteristics may include pixel length, pixel width, pixel depth, color format, etc. When printing, an image is used to fill the boxes defined for the format that is to be used. The following C++ code describes the image object and its characteristics: 
     
         ______________________________________                                    
class IMAGE {                                                             
public:                                                                   
 IMAGE(void);   // constructor                                            
 IMAGE(IMAGE.sub.-- ID id),                                               
                // constructor                                            
 void init(void);                                                         
                // Initialize parameters to defaults                      
 IMAGE.sub.-- ID id;                                                      
                // Identification Number                                  
 COLOR.sub.-- FORMAT mode;                                                
                // color image format                                     
 LENGTH x.sub.-- length;                                                  
                // horizontal image length in pixels                      
 LENGTH y.sub.-- length;                                                  
                // vertical image length in lines                         
 DEPTH image.sub.-- depth;                                                
                // depth of image 8-12 bits                               
 DURATION timeout;                                                        
                // acquire timeout for this image                         
 Switch permanent;                                                        
                // image will be held for a while                         
};                                                                        
______________________________________                                    
 
    
     A test image object is used to symbolize images used for testing purposes. The images are software generated and have different attributes than an image. The following C++ code describes the test image object and its characteristics: 
     
         __________________________________________________________________________
class TEST.sub.-- IMAGE {                                                 
public;                                                                   
 TEST.sub.-- IMAGE(void);                                                 
                   // constructor                                         
 TEST.sub.-- IMAGE(IMAGE.sub.-- ID id);                                   
                   // constructor                                         
 void init(void);  // Initialize parameters to defaults                   
 IMAGE.sub.-- ID id;                                                      
                   // Identification Number                               
 COLOR.sub.-- FORMAT mode;                                                
                   // color image format                                  
 LENGTH x.sub.-- length;                                                  
                   // horizontal image length in pixels                   
 LENGTH y.sub.-- length;                                                  
                   // vertical image length in lines                      
 DEPTH image.sub.-- depth;                                                
                   // depth of image 8-12 bits                            
 DURATION timeout; // acquire timeout for this image                      
 TEST.sub.-- IMAGE.sub.-- TYPE image.sub.-- type;                         
                   // type of test pattern                                
 LEVEL red.sub.-- density;                                                
                   // Constant density - red density;                     
 LEVEL green.sub.-- density;                                              
                   // Constant density - green density;                   
 LEVEL blue.sub.-- density;                                               
                   // Constant density - blue density;                    
};                                                                        
__________________________________________________________________________
 
    
     A string object is used to hold ASCII text in the image memory. The string object also allows the use of parameters such as length, intensity, type, etc. The following C++ code describes the string object and its characteristics: 
     
         __________________________________________________________________________
class STRING {                                                            
public:                                                                   
 STRING(void);    // constructor                                          
 STRING(IMAGE.sub.-- ID id);                                              
                  // constructor                                          
 void init(void); // Initialize parameters to defaults                    
 STRING.sub.-- ID id;                                                     
                  // id of string                                         
 TEXT.sub.-- TYPE type;                                                   
                  // Type of the text                                     
 char *text;      // string                                               
 LEVEL bw.sub.-- foregnd.sub.-- intensity;                                
                  // B&amp;W forground intensity                              
 LEVEL bw.sub.-- backgnd.sub.-- intensity;                                
                  // B&amp;W forground intensity                              
 COLOR color.sub.-- foregnd.sub.-- intensity;                             
                  // Color foreground intensities                         
 COLOR color.sub.-- backgnd.sub.-- intensity;                             
                  // Color background intensities                         
 LENGTH width;    // width of string                                      
 LENGTH lead;     // # of blank lines between ASCII lines                 
};                                                                        
__________________________________________________________________________
 
    
     The general parameters object is used to hold all process configuration parameters. This object can be used to set the parameters in the laser imager, or to read the current settings of the parameters. Examples of some parameters are default beta tables, default color contrast, default destination, default film size and type, etc. A few parameters are read-only, and thus cannot be set, such as the amount of memory available, the current software revision, the total prints queued, etc. The following C++ code describes the general parameter object and its characteristics. 
     
         __________________________________________________________________________
class PARAMETERS {                                                        
public:                                                                   
 PARAMETERS(void);                                                        
                 // Constructor                                           
 void set.sub.-- defaults(void);                                          
                 // Initialize to defaults                                
 DURATION acq.sub.-- timeout;                                             
                 // Acquisition timeout 1..65535 seconds                  
 TABLE def.sub.-- beta.sub.-- x1;                                         
                 // Default horizontal axis beta pass 1                   
 TABLE def.sub.-- beta.sub.-- y1;                                         
                 // Default vertical axis beta pass 1                     
 TABLE def.sub.-- beta.sub.-- x2;                                         
                 // Default horizontal axis beta pass 2                   
 TABLE def.sub.-- beta.sub.-- y2;                                         
                 // Default vertical axis beta pass 2                     
 LEVEL def.sub.-- bw.sub.-- border;                                       
                 // Default B&amp;W Border level                              
 COLOR def.sub.-- color.sub.-- border;                                    
                 // Default color border level                            
 COLOR.sub.-- FORMAT def.sub.-- cformat;                                  
                 // Default acquisiton image format                       
 TABLE def.sub.-- bw.sub.-- contrast;                                     
                 // Default contrast table while in B&amp;W                   
 TABLE def.sub.-- color.sub.-- contrast;                                  
                 // Default contrast table while in color                 
 TABLE def.sub.-- color.sub.-- mix;                                       
                 // Default mixing table while in color                   
 LEVEL def.sub.-- max.sub.-- density;                                     
                 // Default maximum density value                         
 DEPTH def.sub.-- depth;                                                  
                 // Default bits per pixel                                
 DESTINATION def.sub.-- destination;                                      
                 // Default destination for print images                  
 LEVEL def.sub.-- bw.sub.-- dmax;                                         
                 // Default B&amp;W maximum density value.                    
 IMAGE.sub.-- TYPE def.sub.-- image.sub.-- type;                          
                 // Default acceptible image type                         
 FILM.sub.-- TYPE def.sub.-- film.sub.-- type;                            
                 // Default media type                                    
 FILM.sub.-- SIZE def.sub.-- film.sub.-- size;                            
                 // Default media size                                    
 LENGTH def.sub.-- image.sub.-- xsize;                                    
                 // Default width of image in pixels                      
 LENGTH.sub.-- def.sub.-- image.sub.-- ysize;                             
                 // Default length of image in lines                      
 Switch fixed.sub.-- formatting;                                          
                 // Switch for fixed formatting                           
 FIXED.sub.-- FORMAT fixed.sub.-- format;                                 
                 // Fixed format number                                   
/** Read only parameters **/                                              
 long int fixed.sub.-- image.sub.-- pattern;                              
                 // Image acquisition pattern                             
 MEMORY memory;  // Memory status structure                               
 OP.sub.-- MODE op.sub.-- mode;                                           
                 // Operational mode                                      
 RELEASE revision;                                                        
                 // Current revision                                      
 SYSTEM system;  // Imaging system of the Laser Imager                    
 int total.sub.-- queued,                                                 
                 // Total prints queued in the system                     
 int total.sub.-- completed;                                              
                 // Total prints completed in current jobs                
 int total.sub.-- failed;                                                 
                 // Total prints failed in current jobs                   
};                                                                        
__________________________________________________________________________
 
    
     One of the major responsibilities of output interpreter component 24 is to relay the status of the output imaging device 18 to the client component, input interpreter component 22. The status relay process has two steps. When output interpreter component 24 notes a status change in output imaging device 18, the event handler in the client component is called directly by the output interpreter component. The event handler is passed a status event. Again, the possible status events, which were described above with reference to the input interpreter base-class protocol, include (1) the FP --  status --  change, (2) the PR --  status --  change, (3) the IMS --  status --  change, (4) the JOB --  status --  change, and (5) the XFR --  status --  change. The output interpreter component 24 notifies the client, input interpreter component 22, of the above status changes, so that the input interpreter component does not need to continuously poll the laser imager. 
     It is the responsibility of the client, input interpreter component 22, to either ignore the status change or request further information. All status information is contained within five status objects. There is status object for the film processor, the printer, the image management system, jobs, and background jobs (transfers). Each status object has a status field which can be easily checked to see if warnings or errors exist. If warnings or errors exist, further examination of the warnings structure or the error structure can be done. Again, the client can choose to use only the information it needs. The following C++ code shows the definition for each of the status objects and the structures they contain: ##SPC1## 
     The output interpreter component 24, in this exemplary embodiment, provides fifteen types of remote procedure calls. With the use of the above described imaging objects and the remote procedure calls, the client can fully operate output imaging device 18. Note that all of the parameters contained in the imaging objects described above are initialized to an &#34;unassigned value&#34;. If the parameter is not changed by the client, the output interpreter component 24 will ignore it. This feature allows the client to use only the parameters that it needs. Each of the remote procedure calls provided by output interpreter component 24 is described below. Unless otherwise indicated, the return for each of the following remote procedure calls is a Laser Imager Response Object of type LI --  response, which will be further described later in this disclosure. 
     1. Media Print RPCs 
     
         ______________________________________                                    
a.        print     Parameters:  Type:                                    
______________________________________                                    
                    copies (opt) int                                      
______________________________________                                    
 
    
     The above RPC initiates a general print from a laser imager functioning as output imaging device 18. The above RPC is designed to be used with fixed-formatting The format is a currently selected fixed format. Copies is an optional parameter indicating the number of copies to produce. The images that have been acquired since the last print will be used for the print. 
     
         ______________________________________                                    
b.      print    Parameters:  Type:                                       
______________________________________                                    
           format     int                                                 
           image list LIST                                                
           copies  (opt)                                                  
                      int                                                 
           density (opt)                                                  
                      int                                                 
           destination (opt)                                              
                      DESTINATION                                         
______________________________________                                    
 
    
     The above RPC initiates a print from the laser imager. Format is the format ID to use. Image list indicates which images to use to fill the format. Copies is an optional parameter indicating the number of copies to produce. Density is an optional integer which is used when a density test patch is desired. The integer value corresponds to an image ID. Destination is an optional parameter that defines a destination for the output rather than the default. 
     
         ______________________________________                                    
c.     print.sub.-- test                                                  
                  Parameters:  Type:                                      
______________________________________                                    
            format     int                                                
            image list LIST                                               
            dens.sub.-- id                                                
                       IMAGE.sub.-- ID                                    
            copies (opt) int                                              
            destination (opt)                                             
                       DESTINATION                                        
______________________________________                                    
 
    
     The above RPC initiates a print from the laser imager. Format is the format ID to use. Image list indicates which images to use to fill the format. Dens --  id is an integer that represents the image id of a density test patch. Copies is an optional parameter indicating the number of copies to produce. Destination is an optional parameter which defines a destination for the output rather than the default. 
     
         ______________________________________                                    
d.        abort     Parameters:  Type:                                    
______________________________________                                    
                    job ID       JOB.sub.-- ID                            
______________________________________                                    
 
    
     The above RPC aborts a job having the corresponding id. 
     
         ______________________________________                                    
e.        abort     Parameters:  Type:                                    
______________________________________                                    
                    none         n/a                                      
______________________________________                                    
 
    
     The above RPC aborts all jobs that have been started. 
     2. Formatting RPCs 
     
         ______________________________________                                    
a.       define   Parameters:   Type:                                     
______________________________________                                    
                  format object FORMAT                                    
______________________________________                                    
 
    
     The above RPC defines a format with the exact parameters as found in the format object. All parameters equal to NOT --  ASSIGNED are not included in the definition. 
     
         ______________________________________                                    
b.        define     Parameters:  Type:                                   
______________________________________                                    
                     box object   BOX                                     
______________________________________                                    
 
    
     The above RPC defines a box with the exact parameters as found in the box object. All parameters equal to NOT --  ASSIGNED are not included in the definition. 
     
         ______________________________________                                    
c.        modify     Parameters:  Type:                                   
______________________________________                                    
                     box object   BOX                                     
______________________________________                                    
 
    
     The above RPC modifies the box that matches the id specified in the box object. All parameters equal to NOT --  ASSIGNED in the box object are not modified. 
     
         ______________________________________                                    
d.       modify     Parameters: Type:                                     
______________________________________                                    
              box object                                                  
                        BOX                                               
              x.sub.-- shift                                              
                        LENGTH                                            
              y.sub.-- shift                                              
                        LENGTH                                            
______________________________________                                    
 
    
     The above RPC modifies the box that matches the id specified in the box object. The location of the box is shifted by the amounts specified in x --  shift and y --  shift. All parameters equal to NOT --  ASSIGNED in the box object are not modified. 
     
         ______________________________________                                    
e.       modify     Parameters: Type:                                     
______________________________________                                    
                    format object                                         
                                FORMAT                                    
______________________________________                                    
 
    
     The above RPC modifies the format that matches the id specified in the box object. All parameters equal to NOT --  ASSIGNED in the format object are not modified. 
     
         ______________________________________                                    
f         remove      Parameters:  Type:                                  
______________________________________                                    
                      none         n/a                                    
______________________________________                                    
 
    
     The above RPC deletes the last image acquired. 
     
         ______________________________________                                    
g.        remove      Parameters:  Type:                                  
______________________________________                                    
                box object BOX                                            
                def (opt)  Bool                                           
                all (opt)  Bool                                           
______________________________________                                    
 
    
     The above RPC deletes the box with an id matching that of the received BOX object. DEF is an optional parameter that when set to TRUE causes the job to be deferred and processed in the background. If not received, DEF is set to FALSE. ALL is an optional parameter that when set to TRUE causes all defined boxes to be deleted. If not received, ALL is set to FALSE. 
     
         ______________________________________                                    
h.       remove     Parameters:  Type:                                    
______________________________________                                    
              format object                                               
                         FORMAT                                           
              def (opt)  Bool                                             
              all (opt)  Bool                                             
______________________________________                                    
 
    
     The above RPC deletes the format with id matching that of the received FORMAT object. DEF is an optional parameter that when set to TRUE causes the job to be deferred and processed in the background. If not received, DEF is set to FALSE. ALL is an optional parameter that when set to TRUE causes all defined formats to be deleted. If not received, ALL is set to FALSE. 
     
         ______________________________________                                    
i.       remove     Parameters:  Type:                                    
______________________________________                                    
              image object                                                
                         IMAGE                                            
              def (opt)  Bool                                             
              all (opt)  Bool                                             
______________________________________                                    
 
    
     The above RPC deletes the image with id matching that of the received IMAGE object. DEF is an optional parameter that when set to TRUE causes the job to be deferred and processed in the background. If not received, DEF is set to FALSE. ALL is an optional parameter that when set to TRUE causes all defined images to be deleted. If not received, ALL is set to FALSE. 
     
         ______________________________________                                    
j.       remove.sub.-- all                                                
                      Parameters: Type:                                   
______________________________________                                    
                      def (opt)   Bool                                    
______________________________________                                    
 
    
     The above RPC deletes all images, boxes, formats and tables defined in the laser imager. DEF is an optional parameter that when set to TRUE causes the job to be deferred and processed in the background. If not received, DEF is set to FALSE. 
     
         ______________________________________                                    
h.     remove.sub.-- fixed.sub.-- images                                  
                        Parameters:                                       
                                   Type:                                  
______________________________________                                    
                        none       n/a                                    
______________________________________                                    
 
    
     The above RPC deletes all images stored via fixed format store RPCs. 
     
         ______________________________________                                    
3. Image Manipulation RPCs                                                
a.        store     Parameters:  Type:                                    
______________________________________                                    
                    none         n/a                                      
______________________________________                                    
 
    
     This remote procedure call is strictly used with fixed formatting. This remote procedure call acquires the next image into the next available fixed image location. The locations range from 1 to N where N is the format specific. 
     
         ______________________________________                                    
b.       store     Parameters: Type:                                      
______________________________________                                    
                   id          FIXED.sub.-- ID                            
______________________________________                                    
 
    
     This remote procedure call is strictly used with fixed formatting. This remote procedure call acquires the next image into the location specified by id. The locations range from 1 to N were N is the format specific. 
     
         ______________________________________                                    
c.        store     Parameters:  Type:                                    
______________________________________                                    
                    image        IMAGE                                    
______________________________________                                    
 
    
     The above RPC acquires the next image. The return information regarding image size is placed in LI --  response. 
     
         ______________________________________                                    
d.       store    Parameters: Type:                                       
______________________________________                                    
                  image       TEST.sub.-- IMAGE                           
______________________________________                                    
 
    
     The above RPC acquires the next image as a test pattern. The return information regarding image size is placed in LI --  response. 
     
         ______________________________________                                    
e.        store     Parameters:  Type:                                    
                    string       STRING                                   
______________________________________                                    
 
    
     The above RPC stores the text and the id in the STRING object. This allows the client component to recall the text at any time via the id. The return information regarding string size is placed in LI --  response. 
     
         ______________________________________                                    
f.        transfer  Parameters:  Type:                                    
                    image        IMAGE                                    
______________________________________                                    
 
    
     The above RPC transfers the next image as a background job. The return information regarding image size is available when image transfer is complete. 
     
         ______________________________________                                    
g.        reserve   Parameters:  Type:                                    
                    image        IMAGE                                    
______________________________________                                    
 
    
     The above RPC allocates enough image memory to hold the image described by the IMAGE object. 
     4. Process Configuration/Status RPC 
     
         ______________________________________                                    
a.      set     Parameters:    Type:                                      
                parameter object                                          
                               PARAMETER                                  
______________________________________                                    
 
    
     The above RPC sets the imaging parameters for the laser imager. All parameters set to NOT --  ASSIGNED will be left unchanged. 
     5. Status RPCs 
     
         ______________________________________                                    
a.      show    Parameters:    Type:                                      
                parameter object                                          
                               *PARAMETER                                 
______________________________________                                    
 
    
     The above RPC retrieves the imaging parameters for the laser imager. 
     
         ______________________________________                                    
b.     show.sub.-- fixed                                                  
                  Parameters:   Type:                                     
                  parameter object                                        
                                *PARAMETER                                
______________________________________                                    
 
    
     The above RPC retrieves the fixed formating imaging parameters for the laser imager. All other members in the parameter object are left unchanged. All other members in the parameter object are left unchanged. 
     
         ______________________________________                                    
c.     show.sub.-- mem                                                    
                  Parameters:   Type:                                     
                  parameter object                                        
                                *PARAMETER                                
______________________________________                                    
 
    
     The above RPC retrieves the memory conditions of the laser imager. 
     
         ______________________________________                                    
d.     show       Parameters:   Type:                                     
                  image object  *IMAGE                                    
______________________________________                                    
 
    
     The above RPC retrieves the length and width of the image with id matching the id given in the image object. All image information is placed in the image object. 
     
         ______________________________________                                    
e.     show       Parameters:   Type:                                     
                  printer object                                          
                                *PRINTER                                  
______________________________________                                    
 
    
     The above RPC retrieves the status of the printer with id matching the id given in the printer object. All printer information is placed in the printer object. 
     
         ______________________________________                                    
f.     show       Parameters:   Type:                                     
                  job object    *JOB                                      
______________________________________                                    
 
    
     The above RPC retrieves the status of the job with id matching the id given in the job object. All job information is placed in the job object. 
     
         ______________________________________                                    
g.     show       Parameters:   Type:                                     
                  printer object                                          
                                *XFR                                      
______________________________________                                    
 
    
     The above RPC retrieves the status of the transfer job with id matching the id given in the transfer job object. All transfer job information is placed in the transfer job object. 
     
         ______________________________________                                    
h.       show.sub.-- formats                                              
                       Parameters: Type:                                  
                       string      *char                                  
______________________________________                                    
 
    
     The above RPC retrieves a string of id&#39;s of the defined formats. 
     
         ______________________________________                                    
i.       show.sub.-- images                                               
                       Parameters: Type:                                  
                       string      *char                                  
______________________________________                                    
 
    
     The above RPC retrieves a string of id&#39;s of the acquired images. 
     
         ______________________________________                                    
j.      show.sub.-- con.sub.-- tables                                     
                       Parameters: Type:                                  
                       string      *char                                  
______________________________________                                    
 
    
     The above RPC retrieves a string of id&#39;s of the defined contrast tables. 
     
         ______________________________________                                    
k.      show.sub.-- con.sub.-- tables                                     
                       Parameters: Type:                                  
                       string      *char                                  
______________________________________                                    
 
    
     The above RPC retrieves a string of id&#39;s of the defined color contrast tables. 
     
         ______________________________________                                    
l.  set.sub.-- debug.sub.-- level                                         
                 Parameters:   Type:                                      
                 debug level   DEBUG.sub.-- LEVEL                         
                 Returns:      Type:                                      
                 Driver return code                                       
                               DRIVER.sub.-- RC                           
______________________________________                                    
 
    
     The above RPC allows the client component to set the debug level of input interpreter component 22. The debug levels are NO --  DEBUG, LOW --  DEBUG, MEDIUM --  DEBUG, and HIGH --  DEBUG. This parameter affects the information displayed during debugging. 
     One advantage of the interface to output interpreter component 24 is that every remote procedure call returns a similar object. This object is called, most appropriately, the laser imager response object, as indicated above. Within the laser imager response object is a plethora of information regarding the result of the remote procedure call. However, the client may chose to examine only the information relevant to its needs. The laser imager response object has three main fields. The first is a simple boolean value entitled success. The boolean value reflects whether the request associated with the remote procedure call was accomplished or whether it failed. This information may satisfy the needs of most client components. The second field, success --  data, returns any values that the client component expects if the command was successful. Normally, there will not be any information for a successful command. However, one example of information returned for a successful command would be the image size that is returned after a successful store image command. The third field, errors, is used to explain why the remote procedure call failed. This field is actually a comprehensive bit field of errors that the laser imager may incur. Again, this field is only valid if success is false. 
     The C++ code listed below describes the laser imager response object. The class defines the response received from the laser imager after a command has been issued. If the command executed successfully, the SUCCESS flag is set to TRUE. Any data that is received upon a successful completion will be stored in Success --  Data. If the command failed, the SUCCESS flag is set to FALSE. The cause of the failure is stored in the Failures structure 
     
         __________________________________________________________________________
class LI.sub.-- response {                                                
friend SS.sub.-- EXECUTIVE;                                               
Command cmd;    // SS command                                             
public:                                                                   
LI.sub.-- response(void);                                                 
                // constructor                                            
Bool success;   // Command executed to completion                         
Success.sub.-- Data success.sub.-- data;                                  
                  // Only valid upon successful completion                
Failures errors;                                                          
                // If command failed, errors causing failure              
};                                                                        
typedef struct {                                                          
unsigned AcqEff                                                           
           : 1; // Acquistion Error                                       
unsigned AcqLockout                                                       
                : 1;                                                      
                  // Acquistion never attempted, not available            
unsigned BadBoxId                                                         
                : 1;                                                      
                  // Box ID does not exists for modification              
unsigned BadDepth                                                         
                : 1;                                                      
                  // Pixel depth error                                    
unsigned BadFmtId                                                         
                : 1;                                                      
                  // Format ID does not exist                             
unsigned BadPar                                                           
           : 1;   // Bad Parameter                                        
unsigned BadCConTbl                                                       
                : 1;                                                      
                  // Bad Color Contrast Table                             
unsigned BadCMediaTbl                                                     
                : 1;                                                      
                  // Bad Color Media Table                                
unsigned BadConTbl                                                        
                : 1;                                                      
                  // Bad Contrast Table                                   
unsigned BadCMixTbl                                                       
                : 1;                                                      
                  // Bad Color Mixing Table                               
unsigned BadDensTest                                                      
                : 1;                                                      
                  // Image is not a valid density test patch              
unsigned BadDest                                                          
           : 1;   // Invalid destination                                  
unsigned BadImgId                                                         
                : 1;                                                      
                  // Image was not found                                  
unsigned BadJobId                                                         
                : 1;                                                      
                  // Job was not found                                    
unsigned BadMedia                                                         
                : 1;                                                      
                  // Media type correct                                   
unsigned BadMode                                                          
                : 1;                                                      
                  // Incorrect input mode (color/b&amp;w)                     
unsigned BoxInUse : 1                                                     
                // Box is currently being used                            
unsigned Busy  : 1;                                                       
                // Module is already doing an image transfer              
unsigned CConInUse  : 1;                                                  
                // Color Contrast table currently being used              
unsigned ConInUse : 1;                                                    
                // Contrast table is currently being used                 
unsigned ConnectErr : 1;                                                  
                // Hardware connection problem                            
unsigned EibParamErr : 1;                                                 
                // EIB parameter error                                    
unsigned EibSrcErr : 1;                                                   
                // Invalid EIB source                                     
unsigned EibTranErr : 1;                                                  
                // EIB transfer parameters invalid                        
unsigned Empty  : 1;                                                      
                // Mbox is currently empty                                
unsigned FifoErr : 1;                                                     
                // FIFO overflow                                          
unsigned FmtFull  : 1;                                                    
                // would be more than 255 boxes in a format               
unsigned FmtInUse : 1;                                                    
                // Format currently being used                            
unsigned FmtOvrLap : 1;                                                   
                // The boxes in this format overlap                       
unsigned FmtOffSheet : 1;                                                 
                // box in this format will not fit on media               
unsigned FmtTMCon                                                         
                : 1;                                                      
                  // Too many contrast tablesin this format               
unsigned FmtTMCCon                                                        
                : 1;                                                      
                  // Too many color cont tables in this format            
unsigned FmtTMCMix : 1;                                                   
                  // Too many color mix tables in this format             
unsigned FmtTMCMedia : 1;                                                 
                  // Too many color med. tables in this format            
unsigned FmtTMImgs                                                        
                : 1;                                                      
                  // Too many images specified in image list              
unsigned Full                                                             
           : 1; // MBOX is full                                           
unsigned InModInUse : 1;                                                  
                // Input Module is currently being used                   
unsigned ImgInUse : 1;                                                    
                // Image is currently being used                          
unsigned ImgInvalid : 1;                                                  
                // Image has not been fully stored yet                    
unsigned JobDone : 1;                                                     
                // Job has already terminated                             
unsigned MagErr // Magnification error                                    
unsigned MaxFmts : 1;                                                     
                // There would be more than 255 formats                   
unsigned MaxJobs : 1;                                                     
                // Would exceed max # concurrent jobs                     
unsigned MemBoundErr : 1;                                                 
                  // Invalid image memory address                         
unsigned MemErr : 1;                                                      
                // Memory error occured during store                      
unsigned MemFull : 1;                                                     
                // Image Memory is full                                   
unsigned MissPar : 1;                                                     
                // Missing Parameter                                      
unsigned MovErr : 1;                                                      
                // Move would cause box location to become neg.           
unsigned NoMem : 1;                                                       
                // Not enough memory to execute command                   
unsigned NVRamErr : 1;                                                    
                  // Problem with the Non-Volatile memory                 
unsigned ParityErr : 1;                                                   
                // Hardware parity error                                  
unsigned PassErr : 1;                                                     
                // Double pass required, single pass module               
unsigned QueueFull : 1;                                                   
                // Print Queue full. No more jobs possible.               
unsigned ResErr : 1;                                                      
                // Image size did not match reserved memory               
unsigned SetUpErr : 1;                                                    
                // Request does not match system configuration            
unsigned SizeErr : 1;                                                     
                // Size in Img Header does not match image size           
unsigned StoErr : 1;                                                      
                // Video or Digital signal error during acquisition       
unsigned TimeOut : 1;                                                     
                // Image acquistion could not be completed                
unsigned TooLong : 1;                                                     
                // Message is too long to fit in the mbox                 
unsigned Unkillable : 1;                                                  
                // Job(s) cannont be killed                               
unsigned UnknownCmd : 1;                                                  
                  // Unknown command issued                               
unsigned WinErr : 1;                                                      
                // Window specified is incorrect size                     
} Failures;                                                               
__________________________________________________________________________
 
    
     The following structure holds data that input imaging device 18 (the laser imager) returns if the command executes correctly. Thus, this data is only valid if no errors occurred during execution. 
     
         ______________________________________                                    
typedef struct{                                                           
ID id;        // Place holder for a return ID                             
LENGTH  x.sub.-- size;                                                    
              // Place holder for an Image size                           
LENGTH  y.sub.-- size;                                                    
              // Place holder for an Image size                           
LISTlist;   // Place holder for an ID list                                
}Success.sub.-- Data;                                                     
______________________________________                                    
 
    
     The actual base class for output interpreter component 24 can be defined in C++ as follows: 
     
         __________________________________________________________________________
class LI.sub.-- INTERFACE {                                               
public:                                                                   
 LI.sub.-- INTERFACE(PORT.sub.-- ID new.sub.-- id, OUTPUT.sub.-- INTERFACE
 *p);//constructor                                                        
 ˜LI.sub.-- INTERFACE(void);                                        
 INT32 return.sub.-- code;           // RC for OS operations              
 DRIVER.sub.-- RC out.sub.-- driver.sub.-- rc;                            
                                     // RC from output driver             
 DEBUG.sub.-- LEVELS debug.sub.-- level;                                  
                                     // Debug level for module            
 Semaphore rpc.sub.-- reply;         // RPC response complete             
 Semaphore rpc.sub.-- free;          // RPC mailbox free                  
 Semaphore event.sub.-- reply;       // async event received              
 Semaphore event.sub.-- free;        // async event mailbox free          
 PORT.sub.-- ID exec.sub.-- id;                                           
 Mailbox rpc.sub.-- mbox;            // RPC mailbox                       
 Mailbox event.sub.-- mbox;          // event mailbox                     
 OUTPUT.sub.-- INTERFACE *output.sub.-- handle;                           
 FE.sub.-- PTR client;               // client module using us            
 FE.sub.-- METHOD.sub.-- PTR client.sub.-- async.sub.-- handler;          
                                     // pointer to async handler          
 virtual Bool output.sub.-- ev.sub.-- handler(enum IO.sub.-- EVENT event) 
=0                                   //asynch event handler               
 virtual void set.sub.-- async.sub.-- func(FE.sub.-- PTR,FE.sub.--        
METHOD.sub.-- PTR)=0;                //set ptr to FE handler              
 /*** Laser Imager Client Interface ***/                                  
 // Basic Transparent Command                                             
 virtual LI.sub.-- response send(char *);                                 
                                     //send generic text                  
 virtual LI.sub.-- response receive(char                                  
                                     //receive generic text               
 // Print Commands                                                        
 virtual LI.sub.-- response print(int copies=1)=0;                        
                                     //Fixed format print                 
 virtual LI.sub.-- response print(FORMAT.sub.-- ID id,LIST *images,       
  int copies=1,DESTINATION d=Film.sub.-- Processor.sub.-- 1)=0;           
 virtual LI.sub.-- response print.sub.-- test(FORMAT.sub.-- ID id,LIST    
*images,                                                                  
   IMAGE.sub.-- ID dens.sub.-- id,int copies=1,                           
   DESTINATION d=Film.sub.-- Processor.sub.-- 1)=0;                       
 virtual LI.sub.-- response abort(JOB.sub.-- ID id)=0;                    
 virtual LI.sub.-- response abort(void)=0;                                
                                     //Abort all jobs                     
 // Formatting Commands                                                   
 virtual LI.sub.-- response define(BOX box)=0;                            
                                     //Define a box                       
 virtual LI.sub.-- response define(FORMAT format)=0;                      
                                     //Define a format                    
 virtual LI.sub.-- response modify(BOX box)=0;                            
                                     //Modify a box                       
 virtual LI.sub.-- response modify(LENGTH X.sub.-- SHIFT, LENGTH Y.sub.-- 
SHIFT, BOX                                                                
  box)=0;                                                                 
 virtual LI.sub.-- response modify(FORMAT format)=0;                      
                                     //Modify a format                    
 virtual LI.sub.-- response remove(FIXED.sub.-- ID);                      
                                     //Remove image from a position       
 virtual LI.sub.-- response remove(BOX box,Bool def=FALSE,Bool            
all=FALSE);                          //Del box                            
 virtual LI.sub.-- response remove(FORMAT format,Bool def=FALSE,Bool      
  all=FALSE);                                                             
 virtual LI.sub.-- response remove(IMAGE image,Bool def=FALSE,Bool        
all=FALSE);                                                               
 virtual LI.sub.-- response remove.sub.-- fixed.sub.-- images(void);      
                                     //Remove all fixed images            
 virtual LI.sub.-- response remove.sub.-- all(Bool def=FALSE);            
                                     //Delete everything                  
 // Manipulation Commands                                                 
 virtual LI.sub.-- response reserve(IMAGE image)=0;                       
                                     //Reserve memory                     
 virtual LI.sub.-- response store(void)=0;                                
                                     //Store next image                   
 virtual LI.sub.-- response store(FIXED.sub.-- ID)=0;                     
                                     //Store image for a position         
 virtual LI.sub.-- response store(IMAGE image)=0;                         
                                     //Store an image                     
 virtual LI.sub.-- response store(TEST.sub.-- IMAGE image)=0;             
                                     //Store a test image                 
 virtual LI.sub.-- response store(STRING string)=0;                       
                                     //Store a test image                 
 virtual LI.sub.-- response transfer(IMAGE image)=0;                      
                                     //Transfer an image                  
 // Mailbox Commands                                                      
 virtual LI.sub.-- response clear(MAILBOX mbox)=0;                        
                                     //Clear a mailbox                    
 virtual LI.sub.-- response receive(MAILBOX mbox,char *msg)=0;            
                                     //Get a msg into a mbox              
 virtual LI.sub.-- response send(MAILBOX mbox,char *msg)=0;               
                                     //Send a message to a mbox           
 // Process configuration / status commands                               
 virtual LI.sub.-- response set(PARAMETERS ptr)=0;                        
                                     //set imaging parameters             
 virtual LI.sub.-- response show.sub.-- fixed(PARAMETERS *);              
 virtual LI.sub.-- response show.sub.-- mem(PARAMETERS *ptr);             
                                     //show image memory                  
 virtual LI.sub.-- response show(PARAMETERS *ptr)=0;                      
                                     //show imag. params.                 
 virtual LI.sub.-- response show(IMAGE *ptr)=0;                           
                                     //show info of image                 
 virtual LI.sub.-- response show(Film.sub.-- Processor *ptr)=0;           
                                     //show status of a FP                
 virtual LI.sub.-- response show(Image.sub.-- Mgmnt.sub.-- System         
*ptr)=0;                             //show IMS status                    
 virtual LI.sub.-- response show(Printer *ptr)=0;                         
                                     //show status of Printer             
 virtual LI.sub.-- response show(Job *ptr)=0;                             
                                     //show status of a Job               
 virtual LI.sub.-- response show(Xfr *ptr)=0;                             
                                     //show status of Xfr job             
 virtual LI.sub.-- response show.sub.-- formats(char *ptr)=0;             
                                     //string of defined frmts            
 virtual LI.sub.-- response show.sub.-- images(char *ptr)=0;              
                                     //string of defined images           
 virtual LI.sub.-- response show.sub.-- con.sub.-- tables(char            
                                     //string of cont tables              
 virtual LI.sub.-- response show.sub.-- ccon.sub.-- tables(char           
                                     //string of color con tbls           
};                                                                        
__________________________________________________________________________
 
    
     D. The Output Driver Base-Class Protocol 
     The output driver base-class protocol, in this exemplary embodiment, is virtually identical to the input driver base-class protocol. The output driver component 26 provides five remote procedure calls for output interpreter component 24. With the five remote procedure calls, output interpreter component 24 can directly interface with an output imaging device 18, such as a laser imager. Each of the five remote procedure calls is described below: 
     
         ______________________________________                                    
1.   xmit.sub.-- message                                                  
                 Parameters:    Type:                                     
                 message        char *                                    
                 Returns:       Type:                                     
                 Driver return code                                       
                                DRIVER.sub.-- RC                          
______________________________________                                    
 
    
     The above RPC passes output driver component 24 a message to transmit to input imaging device 12 via pipeline 30. The output driver component 26 handles all requirements for communication with output imaging device 18. 
     
         ______________________________________                                    
2.   receive.sub.-- message                                               
                  Parameters:    Type:                                    
                  message        char *                                   
                  Returns:       Type:                                    
                  Driver return code                                      
                                 DRIVER.sub.-- RC                         
______________________________________                                    
 
    
     The above RPC retrieves a message from output driver component 26 that has been sent from output imaging device 18. Again, output driver component 26 handles all requirements for communication with output imaging device. 
     
         ______________________________________                                    
3.   set.sub.-- xmit.sub.-- timeout                                       
                  Parameters:    Type:                                    
                  timeout        int                                      
                  Returns:       Type:                                    
                  Driver return code                                      
                                 DRIVER.sub.-- RC                         
______________________________________                                    
 
    
     The above RPC sets the timeout value that output driver component 26 should use when sending to the output imaging device 18. 
     
         ______________________________________                                    
4.  set.sub.-- async.sub.-- func                                          
                Parameters:   Type:                                       
                client ptr    FE.sub.-- CLIENT.sub.-- PTR                 
                method ptr    FE.sub.-- METHOD.sub.-- PTR                 
                Returns:      Type:                                       
                Driver return code                                        
                              DRIVER.sub.-- RC                            
______________________________________                                    
 
    
     The above RPC gives output driver component 26 a handle to the asynchronous handler of the client component, output interpreter component 24. The above RPC is used to inform the client component of asynchronous events that have occurred. The only event is MSG --  PENDING which indicates a message has been fully received from output imaging device 18 and is ready for the output interpreter component 24. 
     
         ______________________________________                                    
5.  set.sub.-- debug.sub.-- level                                         
                 Parameters:   Type:                                      
                 debug level   DEBUG.sub.-- LEVEL                         
                 Returns:      Type:                                      
                 Driver return code                                       
                               DRIVER.sub.-- RC                           
______________________________________                                    
 
    
     The above RPC allows the client component to set the debug level for output driver component. The debug levels are NO --  DEBUG, LOW --  DEBUG, MEDIUM --  DEBUG, and HIGH --  DEBUG. This parameter affects the information displayed during debugging. 
     As noted above, each RPC returns one of three driver return codes: (1) RPC --  OK, (2) PORT --  BUSY, and (3) NO --  MESSAGE. The driver return codes can be defined in C++ code as follows: 
     
         ______________________________________                                    
//set return types for I/O Driver interface                               
typedef enum {                                                            
 .sup. RPC.sub.-- OK,  //RPC was issued and acknowledged                  
 .sup. PORT.sub.-- BUSY,  //Transmit RPC failed, port already             
transmitting                                                              
 .sup. NO.sub.-- MESSAGE  //Receive RPC failed, no message pending        
} DRIVER.sub.-- RC;                                                       
______________________________________                                    
 
    
     The actual base class protocol for output driver component 26 can be defined in C++ code as follows: 
     
         ______________________________________                                    
class OUTPUT.sub.-- INTERFACE                                             
public:                                                                   
 OUTPUT.sub.-- INTERFACE(PORT.sub.-- ID newport);                         
 ˜OUTPUT.sub.-- INTERFACE(void);                                    
 virtual DRIVER.sub.-- RC xmit.sub.-- message(char *message) = 0;         
 virtual DRIVER.sub.-- RC receive.sub.-- message(char *message) = 0;      
 virtual DRIVER.sub.-- RC set.sub.-- xmit.sub.-- timeout(int timeout) =   
0;                                                                        
 virtual DRIVER.sub.-- RC set.sub.-- async.sub.-- func(CLIENT.sub.--      
PTR,                                                                      
CLIENT.sub.-- METHOD.sub.-- PTR) = 0; //                                  
 PORT.sub.-- ID port;  //This port ID                                     
______________________________________                                    
 
    
     Having described the exemplary embodiments of the invention, additional advantages and modifications will readily occur to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. Therefore, the specification and examples should be considered exemplary only, with the true scope and spirit of the invention being indicated by the following claims.