WO1995010090A1

WO1995010090A1 - Desk top image conferencing

Info

Publication number: WO1995010090A1
Application number: PCT/US1994/009769
Authority: WO
Inventors: Robert A. Davidsen
Original assignee: Grumman Aerospace Corporation
Priority date: 1993-10-04
Filing date: 1994-09-09
Publication date: 1995-04-13

Abstract

An interactive XWindow image conferencing system permits users on different workstations to share an image (10-14) and use different drawing colors (15, 16) to mark up the image in real time (17-19). Each participant is permitted to assign himself or herself a different drawing color so that his or her comments can be distinguished from others, and so that the conference member will know who is making which changes (15, 16, 19). Conference participants can be added or removed at any time without affecting other conference participants (19).

Description

DESK TOP IMAGE CONFERENCING

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates to a system which permits different workstations to share an image and allows the different workstation users to mark up the image in real-time with different drawing colors for each user.

2. Description of Related Art

Redlining, or desk top image conferencing, in which users on different work stations can share an image and use different drawing colors to mark up the image, enhances communication between remote individuals by allowing them to share and discuss visual information. However, existing redlining applications have been limited in functionality. Most are restricted to specific hardware architectures and proprietary raster image formats, and do not allow for concurrent updating of images.

Instead, the conventional systems either require drawings to be updated separately and combined later, or they provide for control by a chairman who is the only one who

can annotate the drawing at a given time. This impedes the free flow of ideas and drastically increases the time length of a redlining procedure. Often, conference participants are not identified and are not given any option for differentiating their annotations from one another. Further, many systems lock participants out of the conference once it has started and prevent others from leaving.

SUMMARY OF THE INVENTION It is an objective of the invention to provide a redlining system which does not exhibit any of the above-mentioned problems.

It is a further objective of the invention to provide a redlining system in which users are allowed to simultaneously annotate a drawing area and the mark ups are shown on all displays at the same time.

It is a still further objective of the invention to provide a redlining system in which each participant can assign himself or herself a different drawing color so that his or her comments can be distinguished from the comments of others.

It is also an objective of the invention to provide a redlining system in which participants may not only read existing images from a file, but also may grab images from another window on their display and bring it into the conference. It is another objective of the invention to provide a redlining system in which users can scroll their image without affecting others while also providing a method of scrolling each user to the same location.

It is yet another objective of the invention to provide a redlining system in which conference participants can be added or removed at any time without affecting other conference participants.

These and other objectives of the invention are achieved by a system which includes a plurality of workstations or terminals capable of displaying and editing an image, and of receiving and transmitting images to other terminals. Means are provided for permitting each user to select a color and for causing all terminals in the conference to recognize the color. In addition, means are provided for creating various display elements on each terminal, referred to as widgets, for adding new users to a session, and for performing the functions of, for example, saving an image, reading an image, changing colors, positioning an image, grabbing an image, clearing an image, and removing a user. While the system is preferably implemented by software, details of which will be described below, it is to be understood that the software is a means for changing physical parameters of hardware components, including the plurality of terminals and connecting means such as a modem or LAN interface, which are required in order to implement the program. These parameters may include, for example, the brightness of phosphors on a display and the electrical state of locations in an image memory. BRIEF DESCRIPTION OF THE DRAWINGS

Figure 1 is a schematic block diagram of a preferred redlining system.

Figure 2 is a flowchart illustrating a main routine carried out by the preferred system.

Figures 3a and 3b form a flowchart of a subroutine for setting up an operator interface for the preferred system.

Figure 4 is a flowchart of a subroutine for initializing colors in the display set up by the subroutine of Figures 3a and 3b.

Figure 5 is a flowchart of a subroutine for allocating colors in the subroutine of Figure 4.

Figure 6 is a flowchart of a subroutine of the subroutine of Figure 5 for modifying default colors to cause different displays to show the same colors.

Figure 7 is a flowchart of a subroutine of the subroutine of Figure 6 for matching colors on different displays.

Figure 8 is a flowchart of a preferred callback routine for adding new users to an image conference. Figure 9 is a flowchart of a subroutine of the callback routine of Figure 8 for adding a new user to a conference.

Figure 10 is a flowchart of a subroutine of the subroutine of Figure 9 for transferring an image to the new user.

Figure 11 is a flowchart of a preferred method of converting an image which uses one set of colors to a second identical image which may be on a different display and uses a different set of colors, in the form of a subroutine of the subroutine of Figure 10.

Figure 12 is a flowchart of a preferred callback routine for storing the contents of a draw window to a file.

Figure 13 is a flowchart of a subroutine of the callback routine of Figure 12 for saving a bitmap.

Figure 14 is a flowchart of a subroutine of the subroutine of Figure 12 for preferred method of saving a color xwd image.

Figure 15 is a flowchart of a preferred callback routine for copying contents of an image in a file onto a draw window. Figure 16 is a flowchart of a subroutine of the callback routine of Figure 15

for reading a bitmap into an image conferencing session.

Figure 17 is a flowchart of a subroutine of the subroutine of Figure 16 for retrieving a bitmap.

Figure 18 is a flowchart of a subroutine of the subroutine of Figure 15 for reading a color xwd file image into an image conference session.

Figure 19 is a subroutine of the subroutine of Figure 15 for reading an ASCII file into an image conference session.

Figure 20 is a flowchart of a preferred callback routine for updating team names and colors.

Figure 21 is a flowchart of a preferred callback routine for updating a scrolled drawing location of each user to a selected user.

Figure 22 is a flowchart of a subroutine of the subroutine of Figure 15 and of the callback routine of Figure 21 for setting the scrollbars controlling the image to a desired horizontal/ vertical position.

Figures 23a and 23b form a flowchart of a preferred callback routine for grabbing a window. Figure 24 is a flowchart of a preferred callback routine for clearing a drawing area for each conference participant.

Figure 25 is a flowchart of a subroutine of the callback routine of Figure 24 for clearing all drawing areas.

Figure 26 is a flowchart of a subroutine of the subroutines of Figures 3a, 3b, 10, and 25 for clearing a single drawing area.

Figure 27 is a flowchart of a callback routine for removing a participant from an image conferencing session.

Figure 28 is a flowchart of a preferred method by which a participant selects a drawing color.

Figure 29 is a flowchart of a preferred method by which a participant selects a drawing mode.

Figure 30 is a flowchart of a subroutine for setting a drawing mode in order to implement the method of Figure 29.

Figure 31 is a flowchart for drawing an annotation in every display in the conference. Figures 32(a) - 32(c) form a flowchart of a subroutine of the subroutine of Figure 31 for making an annotation.

Figure 33 is a flowchart of a subroutine for removing current text that is displayed in a window.

Figure 34 is a flowchart of a subroutine for re-displaying a window.

Figure 35 is a flowchart of a subroutine for re-displaying a part of a window.

Figure 36 is a flowchart of a subroutine for re-displaying current text strings.

Figure 37 is a flowchart of a subroutine of Figure 36 for checking whether a window is in text mode and has a current text string in buffer.

Figure 38 is a flowchart of a subroutine for erasing annotations from a portion of a window while leaving the background intact.

Figure 39 is a flowchart of a subroutine used for re-displaying the background image.

Figure 40 is a flowchart of a callback routine for enabling a scroll bar to move a picture. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

The preferred system is controlled by an object-based program written for an

XWindows graphics environment in which the various functions of the program are performed by discrete subroutines or callback routines. Apparatus for carrying out the program, shown in schematic form in Figure 1, includes a plurality of computers or workstations 1,2,3, ...,n capable of editing color images, and a communications network 5 such as a LAN capable of supporting interactive communication between the individual computers or workstations. It is to be understood that the transfer of data in the form of electromagnetic signals is implied whenever the following program requires an image to appear on all workstations participating in the conference.

The main program routine is shown in Figure 2. Initially, an application context is created so that the program may control windows from different displays (step 12), after an initial check for proper authority to use the software (step 10) and initialization of the Xt toolkit (step 11). The main program routine then carries out the steps of opening a default display (step 13) reading input arguments to check if an erase function is to be implemented (step 14), initializing team names (step 15), initializing team colors (step 16), and creating the various display elements (step 17), referred to as widgets, at which time the conference is ready to proceed by incrementing a display counter (step 18) and entering a main program loop (step 19). Those skilled in the art will appreciate that the initialization subroutines are standard subroutines, except as noted below, and will easily be implemented by those skilled in the art. The optional erase function, checked in step 14, allows annotations to be removed from a background image. If the application is brought up with a no erase flag, for example to eliminate the need for the extra pixmap necessary to separate annotations from the background image, then the erase button is removed from the drawing panel and annotations cannot be deleted.

The main program loop (step 19) involves monitoring the conference participants for callback routines. These interrupts, described individually below, include adding new users to the session (when the main program loop is first entered, the chairman is the only member of the conference), saving an image, reading an image, changing colors (i.e., changing the available set of colors), positioning an image, grabbing a window, clearing an image from a screen, removing a user, selecting a drawing color (which involves changing the actual color a conference member draws with from the available set of colors), selecting a drawing button, drawing an object, and scrolling an image.

The screen set-up subroutine called in step 17, which is used whenever a new participant is added to the conference, is shown in Figures 3a and 3b. Except as noted below, each of steps 100-126 will be easily implemented by those familiar with programming in an XWindows environment using convention widget or icon creating subroutines or objects. In order to create the display through which the user calls the various subroutines, the variables are initialized (steps 100-101), a shell and graphics context are created (steps 102-103), and the main window is set up (step 104). The subroutine then creates a form for action buttons (step 105), drawing buttons (step 106), and color buttons (step 107), a drawing area for images (step 108), "pop-up" windows which initiate callback routines (described below) for grabbing windows (step 109) and changing team colors or team names (step 110), as well as pop-up windows for creating a new session (step 111), reading a new image (step 112), for which there are three options ~ black/white (xbm format), color (xwd format), or

ASCII files, for saving a drawing to file (step 113), and finally pop-up windows for help, information, and the copyright display generation functions (steps 114-116). In addition, pixmaps are created for saving the image and any changes together (step 117) and, after checking for the erase option (step 118), for saving the background image without annotations (step 119).

While the screen is being set-up in the manner described above, any callbacks (interrupts) are registered (step 120) and the initial colors are set (step 121), as explained in more detail below in connection with Figures 4-7. The widgets are then realized (step 122) and the display is complete. The window is named (step 123), the drawing area is cleared (step 124), scroll bars are sized based on the size of the drawing area (step 125), and the copyright notice is displayed (step 126).

As shown in Figure 4, the first step (step 320) in the initialize colors subroutine (step 121 in Figure 3(b)) is to allocate the main colors in the default color map, exemplary default colors being black, white, red, green, blue, yellow, cyan, and magenta, for a conventional display. The subroutine for allocating colors is detailed in Figure 5. In addition, Catia colors are allocated in the default color map (step 330), locations of the eight drawing colors in the default color map are found (step 340), the drawing color is set to the first color (step 350), and color buttons with current drawing colors and drawing names are filled in and displayed, the form having been created in step 107 (Figure 3(a)).

As shown in Figure 5, after initialization of a counter to zero (step 370), a loop is set up which looks up a color name in the default color map (step 380) and places the color name in an XColor structure (step 390) until all colors have been placed (step 400). If there is room in the default color map (step 410), these XColor structures are placed in the default color map, after checking whether they are already there (step 420).

Initially, in the color replacement subroutine, all the values in the default color map are queried (step 430) and a counter is initialized to zero (step 440). The subroutine for replacing the default colors then flags which cells in the default color map can change and which cannot change (steps 450-470) until all cells have been checked (step 480). While cells are still available and not all of the new colors have been added to the default color map, the subroutine increments a variable identifying the next color to change upon determining that the new color already is protected in the default color map, or if a new cell is not able to be allocated (steps 490-510). The subroutine for determining whether a color is protected and which is called in step 490 is detailed in Figure 7. If the new cell can be allocated and the new color is not already protected, the subroutine stores a new color in the default color map

(step 520), modifies the array of color structures to include the new color (step 530), and sets the touch index of the new color to true (step 540) before incrementing the variable identifying the next color to change. When no more cells are available and all new colors have been added to the default color map (steps 550-560), the subroutine sets a flag (step 570) and frees temporary storage (step 580).

The preferred system supports multiple images. New background images can be arbitrarily placed within the drawing area and concatenated with other images.

When new background images are brought into the conference, one by one, each user will get his or her own copy. The most time-consuming part of this task is verifying that all the images look alike because each computer or workstation may use a different set of colors in its default color map. To rectify this problem, colors in each system are matched to one another before images are copied.

The subroutine shown in Figure 7 essentially finds the best match between an XColor and an array of XColor structures. It is useful for mapping a color on one display to a color map on another display. The method essentially calculates a difference in colors and obtains the smallest difference. The first step (step 590) is to initialize the subroutine loop counter to zero. If a continue flag is true (step 600), the differences between red, green, and blue values of the input color and the current index are calculated (step 610), as is the distance between the input and test color (step 620), and if the current test color is closer to the actual color than a previously saved color (step 630), the color number and difference are saved (step 640) and the counter is incremented (step 650). When there are no more colors to check (step

660), the continue flag is set to false (step 670) and the pixel value of the input color is set to the pixel value of the best match (step 680). If the best match color is within the tolerance of the input (step 690), a flag is set to indicate that a sufficient match was found (step 700) and the modify default colors routine proceeds back to step 500 of the subroutine shown in Figure 6. If the best match is not within color tolerances, then the next free color is obtained in step 510, and the subroutine proceeds as described above. The subroutine in Figure 7 is not only used to add colors to a color map, but to match colors in different color maps when copying images as will be discussed below in connection with Figure 11.

Once in the conference, a participant has the ability to sponsor or bring others into the loop at any time. The "session" button displays a window detailing these options. Workstations may be selected from a scrollable list of common users, pre¬ defined from a startup file, and/or another display name may be keyed into the text area. There is also the option of giving the new user the current image, a portion of it, or just a blank drawing region.

The routine for creating a new user begins with removal of the session pop up (step 700) and placement of a clock cursor on all displays (step 710). First, the routine checks if a new display name was entered in the text area (steps 720-730). If the name is non-blank, the "add additional display" variable is set to true (step 740). Whether or not the variable is true, the routine checks the number of new displays selected from the scrollable list (step 750) and if the number of new displays plus existing displays does not exceed the maximum (step 760), gets the display names from a scrollable list (step 770) and initializes a counter to zero (step 780). The routine then proceeds to open a new session for each display name, providing error messages for displays that have problems (steps 790-830). After new sessions have been opened from those selected in the scrollable list, if a display name was entered in the text area (step 840), another session is opened (step 850). If there is a problem with the new display, then the error is set to true and the new display name is added to the list of bad displays (steps 860-880). If the bad display list contains any names

(step 890), the bad display error pop up is generated (step 900). The display error pop up is also displayed if the maximum is exceeded (step 930). In both cases, after display of the error pop up, the clock cursors are removed from the displays (steps

920-940) and the session is considered to be complete.

The subroutine called in steps 800 and 850 of the above-described new user callback routine for opening the session is detailed in Figure 9. Step 950 opens up the connection to the display for the new user and step 960 checks whether the display connection has actually been opened. If not, an error code is set (step 1040) and the error code returned to the parent callback routine (step 1050). If the display is not null, the initialize display subroutine is called (step 970), space is allocated for new widgets (step 980), and the create widgets routine shown in Figures 3(a) and 3(b) is called (step 990). After creating the necessary widgets, a clock cursor is put on the new display (step 1000), the number of displays is incremented (step 1010). If a drawing image is requested, it is copied to the new display using the new display image call (step 1020 and 1030).

The new display image call is shown in Figure 10. This subroutine involves transferring pixmaps or bitmaps from one user to a new user. In step 1101, after checking for the erase option, an image pixmap (the pixmap containing background images without annotations) is obtained from the original user. In step 1102, a draw pixmap, or a pixmap containing contents of the image pixmap plus drawing modifications, is obtained from the original user. The subroutine then queries the color map colors from the original user (step 1103), queries color map colors from the new user (step 1104), clears the new user's display (step 1105) (see Figure 26) and, after another erase option check (step 1106), copies the image from the image pixmap to an image formatted for the new user (step 1107). This step is described in more detail in connection with Figure 11.

After copying the image, the draw pixmap is also copied to an image formatted for the new user (step 1108). These images are put into the new user's draw pixmap (step 1109) and, after yet another erase option check (step 1110), are also put into the image pixmap (step 1111), the user's display is then with the image from the draw pixmap (step 1112), and the color memory is cleared (step 1113). A subroutine for step 1112 is shown in Figure 34.

As detailed in Figure 11, the copy image subroutine called in step 1107 converts an image which uses one set of colors to a second identical image on a different display which uses a different set of colors, and begins with the steps of calculating the number of pixels per line of image data (step 1170), creating a new blank image on the second display (step 1180), initializing a counter to zero (step

1190), and finding the best color match between a current color in the input image and a set of colors used for the output image to create an index of best color matching (steps 1200-1220). Counters are then set up to iterate through the rows and columns of the new image (steps 1230-1260). Each pixel from the original image is then updated in the new image based upon the mapping between the new color sets (step

1260-1270).

After all annotations have been added to the drawing, the drawing may be stored by selecting the image save button. A pop-up window prompts the user for a name for the file, including directory path, and whether to save it in black/ white or color. The entire image, the currently displayed image or a specified size of the image may be saved. Anyone in the conference may save the picture.

This callback routine is shown in Figure 12 and first causes any words currently being added to be saved in the draw pixmap (step 1300). Interactively, three parameters are entered through a pop-up window: (1) the name of the image including a directory path (step 1310), (2) the image format (black/white or color (step 1320)), and (3) the size of the image (step 1330). The file name obtained is the file name stored in the saved text widget and the image format is obtained from a saved toggle button widget. If the desired image size is valid (steps 1340-1410), the pop-up is removed (step 1420), and the image is saved in a color or black/white format (steps 1430-1450).

The save bitmap subroutine called in step 1440 of the subroutine of Figure 12 and detailed in Figure 13 places a clock cursor on all displays (step 1460), removes files with the same name if present (step 1470), and queries all colors in the default color map to convert them to black or white (step 1480). The colors are queried again in their natural state (step 1490), and an image is obtained from the draw pixmap (step 1500) in preparation for copying the image from "normal" colors to an image using black/white colors (step 1510). In step 1520, the pixmap is created, and in step 1530, the black/white image is copied to the pixmap. The drawing color is then set to black (step 1540), a second pixmap is created (step 1550), and the bitmap is copied from the first to the second pixmap (step 1560). The drawing color is set back to the selected drawing color (step 1570), and data is written from the second pixmap to the output file (step 1580). If a writing error is found, a display error pop up is generated (steps 1590-1600), after which the pixmap and colormap space are freed (step 1610), and the clock cursors are removed (step 1620).

The save color subroutine shown in Figure 14 and called in step 1450 of the subroutine of Figure 12 involves removing files with the same name if they already exist (step 1630), followed by a check of whether the file name is proper (step 1640) and an error message if necessary (step 1650), placing a clock cursor on the displays

(step 1660), querying colors in the default color map (step 1670), getting a copy of the image from the draw pixmap (step 1680), converting the image header information to an X- window dump (xwd) header (step 1690), calculating the size of the image data (step 1700), writing the xwd header, xwd title, X- colors and image data to file (step 1710), closing the file (step 1720), and removing the clock cursors from the display

(step 1730). Although new users could start by marking up a blank image, there are three ways the background image may be changed: These are IMAGE (READ), GRAB and CLEAR functions. The image (READ) function is carried out via a pop-up window which displays a directory name and a set of files in that directory that may be read. The directory can be modified to scan a different set of files. Three different image formats are available:

1) black/white, which is a standard X-window bitmap format (xbm),

2) color, which is a standard X-window dump (xwd) format, and

3) ASCII file, which is an ASCII text file. Only short files may be completely read into the application.

As shown in Figure 15, five parameters are entered through the READ IMAGE pop-up window: the directory path of the file; a scrollable list of files within the directory; whether or not to clear the draw window before reading the file; the placement of the image to the origin or to the current position; and the above- mentioned image format. The read image subroutine begins by getting the number of selected files in the scrollable list (step 1800). If no file has been selected, a display error pop up appears (step 1820). Upon selection of a file, the first selected item in the scrollable list is converted to a character string (step 1830), and the directory path and file name are combined into one character string (step 1840). The clear value is fetched form the read pop up (step 1850) and the placement value is also fetched (step 1860). If the placement is not at the origin (step 1870), the global X,Y parameters are set to the current scroll location (step 1890) before getting the

value of the image format from the read pop up (step 1880). If the clear is set, the clear all (see Figure 25) subroutine is called to clear all drawing areas (steps 1900- 1910). After checking for the clear, the slider position for each user is set to the slider position location of the current workstation (step 1920) (see Figure 22). The three different image formats are then queried and the appropriate subroutines called (steps 1930-1970).

The read bitmap subroutine is shown in Figure 16. Initially, a clock cursor is put on all displays (step 1980), and a loop counter initialized to zero (step 1990). The loop calls a subroutine for reading a bitmap file into the drawing region (step 2020) before clearing out a current text word (step 2030) and repeating. When the counter has reached the number of displays (step 2000), the clock cursors are removed (step 2040).

The procedure called in step 2020 for reading a bitmap file into a drawing region is shown in Figure 17. Initially, the bitmap file is read into the pixmap (step 2100) and if there is a problem, a display error pop up appears (steps 2101-2102). After the bitmap file is read into the pixmap, the drawing color is set to black (step

2103). The bitmap is copied from the pixmap to the draw pixmap (step 2104) and if, as determined in step 2105, the erase function is allowed, the bitmat is also copied to the image pixmap (step 2106). Whether or not the erase function is allowed, the drawing color is set back to the selected drawing color (step 2107). The display area is updated from the draw pixmap (step 2108). The subroutine for reading a colored file image into a image conference session is shown in Figure 18. The subroutine first checks whether its possible to open the file and read the xwd header, and whether the xwd header is valid, and displays an error pop up if necessary (steps 2130-2180). Space is then allocated for reading the window name (step 2190) and a display error pop up generated if necessary (steps 2200-2210). After checking whether there is a problem reading the X colors (steps 2220-2230), the size of image data is calculated (step 2240), and if there is no problem reading the image data (steps 2250-2260), the xwd information is converted to an X-image structure (step 2270), a clock cursor is put on all displays (step 2280), a loop counter is initialized to zero (step 2290), and the image is copied into the current session window for each display (steps 2300-2310), with the subroutine ending by removing the clock cursors from the displays (steps 2320).

The subroutine called in step 1970 of the subroutine shown in Figure 15 for reading an ASCII file into a session is shown in Figure 19. Again, the subroutine checks for whether it is possible to open the file (steps 2330 and 2340) and put the clock cursor on all displays (step 2350). A loop counter is initialized to zero (step 2360) and the following steps are performed in the loop: first, information is queried about the font used in the draw window (step 2380) a location for putting text in the window is initialized (step 2390), and the drawing color is set to black (step 2400). When this has been done for all displays (step 2370), another loop is set up at step

2410 with the counter initialized in step 2420. This loop performs a subloop for each text line and is set up at step 2430. This inner loop will put the current text line in each display. First, a maximum height flag is checked (step 2440) and if the maximum height has not been reached, the text string is drawn into the draw pixmap

(step 2450). If the erase function is allowed, as determined at step 2460, the text string is also drawn into the image pixmap (step 2470), after which the height position is adjusted for drawing text (step 2480). When the maximum height is reached, the maximum height flag is set to end the loop (steps 2490, 2560) and the outer loop proceeds to the next text line (step 2410). When this is completed, another loop is set up by initializing the counter to zero (step 2500-2510), and the drawing color is set to the selected drawing color (step 2520) before updating the display area from the draw pixmap (step 2530). The file is closed at step 2540 and the clock cursors are removed at step 2550.

As indicated above, the application contains buttons for eight drawing colors. The default colors are the standard colors of the spectrum: black, white, red, green, blue, yellow, cyan and magenta. Each participant assigns himself or herself a color to draw with and that color button is labeled with the user's name. A start up file in the chairman's home directory lists default user names for each of the drawing colors.

A colors button above the panel displays a pop-up window for assigning a name to or changing the color of a drawing color button. The user can scroll, view and copy one of the colors in the default color map to a drawing color. All changes are reflected on each terminal in the conference.

Another callback routine, illustrated in Figure 20, is initiated by pressing the save button on the color pop up. This routine updates both team colors and team names that may have been altered by one user in the image conference session. The first step is to put a clock cursor on all displays (step 3000) and initiate a loop (steps

3010-3020) in which the subroutine gets the index number of a color in the color map

(step 3030), gets red, green, blue values in the color map (step 3040), and gets a team name associated with the color (step 3050). When all of the new team colors have been associated with the new team names, the subroutine updates the team colors and team names for each user in the session and updates the value of each individual's current drawing color (steps 3060). The subroutine then enters another loop (steps

3070 and 3080) in which the color panel is updated with new colors and names (step

3090) and the drawing color is reset in case the value has changed (step 3100). Finally, the clock cursor is removed from all displays (step 3110).

The set slider position subroutine of step 1920 in Figure 15 is detailed in Figure 22. This subroutine involves a loop set up at steps 2560 and 2570 which begins by resetting a push variable to cancel any new annotations a user may be creating (step 2580), and then calculating the maximum horizontal position allowed (step 2590), setting the horizontal position to a desired value, but no greater than the maximum (step 2600), calculating the maximum vertical position (step 2610), and setting the vertical position to the desired value but no greater than the maximum allowed (step 2620). This subroutine is also used for updating a scrolled drawing location of each user to a particular workstation, and is actuated by pushing a position button as shown in Figure 21 (step 2630), getting the horizontal and vertical scroll bar locations (step 2640), and setting the slider position for every display (step 2650). The grab function allows any user in the conference to grab the contents of an

X-window on their display and bring it into the drawing area. A pop-up window aids this process. For example, images from CAD/CAM systems or spreadsheets may brought into the current image conference.

As shown in Figure 23(a) the grab function is initiated when a mouse is pressed on a window. At this time, the location of the mouse and window being selected is queried (step 2700) and if a child of the root window was pressed, the grab window is set to the child window (step 2730), and the window is raised in case it is obscured (step 2740), or if a child of the root window was not pressed, the grab window is set to the root window (step 2720).

When the mouse is released during the grab, as shown in Figure 23b, a list of all color maps installed on the system is obtained (step 2800), the attributes of the grabbed window are also obtained (step 2801), and a check is made to see if the grabbed window is fully displayed (steps 2802-2803). The mouse control is then released (step 2804), a clock cursor is put on all displays (step 2805), the Xlmage structure of the grabbed window's location on the root window is obtained (step 2806), and the grab pop up is unmanaged (step 2807). The grab popup is checked for selection of the clear all drawing areas function (steps 2811-2812) and whether or not to place the image at the origin or current scrolled location (steps 2814-2815). If there is more than one color map installed (step 2808), then based on the user's selection, either the default color map or the first non-default color map is obtained (step 2816). Finally, the image is transferred to all session windows (step 2809 or step 2817), and the clock cursors are removed (step 2818).

The clear function allows one to start over with a completely blank image. When the clear button is pushed (step 2900), a clear all subroutine for clearing the drawing for each session participant is called (step 2910), as shown in Figure 24. As shown in Figure 25, the clear all subroutine called in step 2910 of the callback routine of Figure 24 is a loop set up by steps 2920 and 2930 in which a clear drawing area subroutine is called (step 2940) for each of the number of displays. As shown in Figure 26, the clear drawing area subroutine called in step 2940 of the subroutine of Figure 25, and also in the subroutines of Figures 3a, 3b, and 10, involves clearing out the drawing area (step 2950), clearing out the draw pixmap (step 2960), clearing out the image pixmap (step 2980) if the erase function is allowed (step 2970), and removing any text strings currently being added to the drawing area (step 2990).

The Quit callback routine shown in Figure 27 is used to remove a user from a session and involves setting a destroy number to the user's number (step 4200), unmanaging the user's top-level shell (step 4210), destroying the shell (step 4220), freeing the user's memory (step 4230), moving the last user's data to the location of the exiting user and resetting the last user's instance number to the one it is being moved to (step 4240), and decrementing the number of users. If there are no more users, the application is destroyed and the main routine exited (steps 4260-4280). The color subroutine shown in Figure 28 is the process of selecting the user's current drawing color. The participant pushes a color button (steps 3800-3870), the program tracks which button was pushed (steps 3890-3960) and the drawing color is modified (step 3970). In this manner, all new annotations in the drawing area will reflect the color change.

Along the bottom of the application is a set of icons showing the available set of annotations which may be made to a drawing. As shown in Figure 29, upon pushing one of the buttons (steps 5000-5070), the corresponding object will be added to the image when drawn with the mouse. The set includes line, free-hand, oval, filled oval, rectangle, filled rectangle and text. After the corresponding drawing mode is set (steps 5080-5150), the initDrawOption subroutine (step 5160) is called.

Initially, in the initDrawOption called in step 5160, the grab pop up is unmanaged if it is managed (steps 3201-3202), and then when the mouse is released (step 3203), the subroutine uses a loop to put white highlighting on the border of each draw button (steps 3204-3206). Red highlighting is put on the border of the draw button selected (step 3207) and if there is a word in the text buffer, a text object is drawn on the image using the draw object subroutine (steps 3208-3209). The type of draw action is then set (step 3210), the push flag is set to false indicating that the mouse must be pushed again to start a new annotation (step 3211), the grab active flag is set to false (step 3212), the text buffer is cleared (step 3213), the rubberband mode is reset (step 3214), and a new cursor is set up (step 3215). The draw object subroutine shown in Figure 31 is called whenever annotations are made to the drawing. It is triggered when text is keyed in and during button press and button release events for indicating ovals, lines, etc. After calculating the global coordinates of the annotation (step 3360), the line width value is obtained (step 3370), and a loop is set up (steps 3380-3390) to make the annotation on each display. In this loop, the value of the line width for the current display is obtained (step 3400), the line width is changed to the desired value (step 3410), the drawing color is set to the color of the annotation (step 3420), and the annotation is drawn (step 3421) using the subroutine of Figures 32(a)-32(c), after which the line and color widths of the current display are reset (steps 3422-3423).

The subroutine called in step 3421 (Figures 32(a)-32(c)) includes the step of getting the current line width (step 3424), after which local coordinates of the annotation are calculated (step 3430), final coordinates and dimensions of the annotation are prepared in local coordinates (step (3431) and translated to global coordinates (step 3432), a check of location validity is made (step 3433) and checks are made for boundaries and rubberbanding (steps 3434 and 3435). The GC line width is then set to one (step 3436) the type of annotation checked (step 3436) and the appropriate action performed. These actions preferably include the drawing of lines, multiple lines, ovals, filled ovals, rectangles, filled rectangles, and text (steps 3450- 3660). The panel with drawing objects also include methods to erase annotations if allowed (steps 3670 and 3680) and change the line width (step 3700). The erase function removes annotations and restores the original background image. By changing the scales on the line width, the width of line geometry changes. The line width scale also increases/decrease the size of the erase area. Finally, the drawing color is reset to the user's drawing color (step 3710), the type of annotation is queried (steps 3720-3770) and the window is re-displayed (step 3780) using the re-display procedure shown in Figure 34.

A procedure for removing current text from a window which is not yet in the

Draw pixmap is shown in Figure 33. In step 3800, the dimensions of the string to be erased using the current font are obtained, and the global X, Y coordinates of the string are obtained in step 3810. These are used to obtain the width and height of the string (step 3820) and, if either X or Y is less than zero, the respective X and Y coordinate is set to zero (steps 3830-3880). Finally, the portion of the Draw pixmap which has not been erased is copied back into the window (step 3890) using the re¬ display procedure shown in Figure 35.

The re-display procedure shown in Figure 34 begins with the step of obtaining the width and height of the window (step 3900), copying the displayed portion of the Draw pixmap into the window (step 3910), and redisplaying current text strings in the window (step 3920). The procedure for copying a portion of the Draw pixmap back into the window (step 3890) begins with calculating local coordinates of the refresh region from global coordinates (step 3930) and then copying the region of the draw pix map into the window (step 3940).

As shown in Figure 36, in order to re-display current text strings of all displays in each participant's window (step 3920 in Figure 34), a loop is set up to check if there is a text word in any display (steps 3960 and 3980-4000), the color of the text word being set to the color of that display and the current text word being drawn into the window until all displays have been carried out, at which time the color is set back to the current drawing color for all displays (3970).

Figure 37 shows the procedure for determining whether a window is in text mode and a current text string is in buffer. It returns a true or false indicator (steps 4010-4030).

In order to erase annotations from a portion of a window while leaving the background intact, as shown in Figure 38, the current value of the line width is obtained (step 4040), the width of the erase area is set to ten times the line width (step

4050), the height of the erase area is also set to ten times the line width (step 4060), the upper-left hand corner of the erase area is obtained and global coordinates calculated (steps 4070-4080), and a loop is set up to copy contents of the image pix map into the window and Draw pixmap for each display. This latter procedure (step 4110) first checks to determine whether the erase option has been selected, calculates local coordinates of the refresh region from global coordinates (step 4130), copies the region of the image pixmap into the draw pixmap (step 4140) and copies a region of the image pixmap into the window (step 4150).

The final callback routines permit the display portion of the image in the drawing region to be shifted by adjusting the scrollbars, as opposed to selecting the position button in the manner described above. Both the horizontal and vertical scrollbars allow the image to be shifted in single pixel increments or dragged by larger pixel increments while the position button causes each participant in the current image conference session to be scrolled to the viewing location of the user in control of the position button. In this manner, one participant can get everyone to view the same location. The sideH move subroutine is the callback routine for when the horizontal scrollbar is used to move the picture. A similar routine, sideN move may be used when the picture is moved vertically. Initially, if the display is in text mode, temporary text is stored in the image (step 4160). The current scrollbar values are then obtained (step 4170), the x value of the top-left hand corner of the shown picture is obtained (step 4180), and if the saved pop up is displayed, the x value is updated in the save pop up. In either case, the shown portion of the picture is updated to reflect this new scrolled location (step 4200-4210).

While the scroll image callback routine completes a detailed description of a preferred embodiment in sufficient detail to enable anyone skilled in the art to make and user the invention, and represents the best mode known to the Inventor for practicing the invention, those skilled in the art will nevertheless appreciate that numerous variations of the above-described embodiment can be made with the scope of the invention, particular if a graphics context other than XWindows is used, and that it is accordingly intended that the invention not be limited by the above description, but rather that it be defined solely by the appended claims.

Claims

I claim:

1. A system for desktop image conferencing, comprising: a plurality of workstations, each including a display; means for creating a background color image on one of said displays to open a conference; means for transferring said background color image to remaining ones of said displays; means for a permitting user of any of said workstations to change or add to the background color image for all of said displays; means for annotating the background color image in any one of said displays; means for transferring said annotations to remaining ones of said displays; and means for assigning a different color and name to a user of each of the displays such that a user of any of said displays can identify the originator of the background color image or annotation by the color of said image or annotation.

2. A system as claimed in claim 1, further comprising means for adding a new user to said conference at any time and for assigning a new color to said new user.

3. A system as claimed in claim 1, further comprising means for creating X- windows in each of said displays and for transferring said images and annotations to said X-windows.

4. A system as claimed in claim 1 , further comprising means for creating widgets

on each of said displays, said widgets including action buttons, drawing buttons, and color buttons, said action buttons including buttons for adding a new user to a session, saving an image, reading an image, changing colors, positioning an image, grabbing a window, clearing a display, removing a user, selecting a color, selecting a drawing button, drawing an object, and scrolling an image, said drawing buttons including buttons for selecting various objects to be drawn on the screen, and said color buttons including buttons representing various colors which may be selected for identifying a user.

5. A system as claimed in claim 1 , further comprising means for comparing color data received from one of the displays with a default color of another of the displays so that each of the colors in a transferred image approximates a color of an original image by calculating a difference in colors and obtaining the smallest difference.

6. A system as claimed in claim 1, further comprising means for permitting each participant in the conference to sponsor or bring others into a conference, and for selecting new participants from a scrollable list of common users, predefined from a startup file, or from a display name keyed into a text area.

7. A system as claimed in claim 1, further comprising means for giving a new user a current image, a portion of the current image, or just a blank drawing region.

8. A system as claimed in claim 1, wherein images are transferred from the sponsor to a new user in the form of Xlmages, wherein said Xlmage consisting of an image data structure used in an XWindow programming environment.

9. A system as claimed in claim 1, further comprising means for saving an Xlmage in the form of a bitmap or in a standard xwd color image, said Xlmage consisting of a data structure used in an XWindow programming environment.

10. A system as claimed in claim 1, further comprising means for storing contents

of a draw window in a file, said means for storing the contents of the draw window including means for creating a pop-up window through which three parameters may be entered: (1) the name of the image including a directory path, (2) the image format (black/white or color), and (3) the size of the image.

11. A system as claimed in claim 1, further comprising means for changing the background image for all users, said means including means for reading the background image in one of three image formats:

1. black/white; 2. color;

3. ASCII files.

12. A system as claimed in claim 1, further comprising means for placing a new background image arbitrarily within the drawing area and concatenating the new background image with other images, said means for placing a background image in the drawing area including means for transferring copies to each user and means for

matching colors before the images are copied.

13. A system as claimed in claim 1, further comprising means for changing one of a plurality of standard drawing colors or a name assigned to one of said colors, said changing means including means for allowing a user to scroll, view, and copy one of the colors in a default colormap to a selected drawing color, and means for displaying said color and name changes on said user's display.

14. A system as claimed in claim 1 , further comprising means for changing the background image for all users by grabbing images from other windows on a display and bringing them into the conference.

15. A system as claimed in claim 1, further comprising means for permitting users to scroll their image without affecting other users, and means for scrolling each user's image to a same location.

16. In a desktop image conferencing system, a plurality of workstations, each including a display; means for creating a background color image on one of said displays to open a conference; means for transferring said background color image to remaining ones of said displays, the improvement comprising: means for permitting users to scroll their image without affecting other users, and means for scrolling each user's image to a same location.

17. In a desktop image conferencing system, a plurality of workstations, each including a display; means for creating a background color image on one of said displays to open a conference; means for transferring said background color image to remaining ones of said displays, the improvement comprising: means for changing the background image for all users by grabbing images from other windows on a display, and means for bringing the grabbed images into the conference.

18. A method for desktop image conferencing, comprising the steps of: creating a background color image on one of a plurality of displays to open a conference; transferring said background color image to remaining ones of said plurality of displays; permitting a user of any of said displays to change or add to the background color image for all of said displays; permitting a user to annotate the background color image in any one of said displays; transferring annotations made by a user to remaining ones of said displays; and assigning a different color and name to a user of each of the displays such that

a user of any of said displays can identify the originator of the background color image or of the annotations by the color of said image or annotation.

19. A method as claimed in claim 18, further comprising the steps of adding a new user to said conference at any time and assigning a new color to said new user.

20. A method as claimed in claim 18, further comprising the steps of creating X- windows in each of said displays and transferring said images and annotations to said X-windows.

21. A method as claimed in claim 18, further comprising the step of creating widgets on each of said displays, said widgets including action buttons, drawing buttons, and color buttons, said action buttons including buttons for adding a new user to a session, saving an image, reading an image, changing colors, positioning an image, grabbing a window, clearing a display, removing a user, selecting a color, selecting a drawing button, drawing an object, and scrolling an image, said drawing buttons including buttons for selecting various objects to be drawn on the screen, and said color buttons including buttons representing various colors which may be selected for identifying a user.

22. A method as claimed in claim 18, further comprising the steps of comparing color data received from one of the displays with a default color of another of the displays so that each of the colors in a transferred image approximates a color of an original image by calculating a difference in colors and obtaining the smallest difference.

23. A method as claimed in claim 18, further comprising the step of permitting each participant in the conference to sponsor or bring others into a conference, and for selecting new participants from a scrollable list of common users, predefined from a startup file, or from a display name keyed into a text area.

24. A method as claimed in claim 18, further comprising the step of giving a new user a current image, a portion of the current image, or just a blank drawing region.

25. A method as claimed in claim 18, wherein images are transferred from the sponsor to a new user in the form of Xlmages, said Xlmage consisting of an image data structure used in an XWindow programming environment.

26. A method as claimed in claim 18, further comprising the steps of saving an Xlmage in the form of a bitmap or in a standard xwd color image, said Xlmage

consisting of a data structure used in an XWindow programming environment.

27. A method as claimed in claim 18, further comprising the steps of storing contents of a draw window in a file by creating a pop-up window through which three parameters may be entered: (1) the name of the image including a directory path, (2) the image format (black/white or color), and (3) the size of the image.

28. A method as claimed in claim 18, further comprising the step of changing the

background image for all users by reading the background image in one of three image formats:

1. black/white; 2. color;

3. ASCπ files.

29. A method as claimed in claim 18, further comprising the steps of placing a new background image arbitrarily within the drawing area and concatenating the new background image with other images by transferring copies to each user and matching colors before the images are copied.

30. A method as claimed in claim 18, further comprising the steps of changing one of a plurality of standard drawing colors or a name assigned to one of said colors by allowing a user to scroll, view, and copy one of the colors in a default colormap to a selected drawing color, and displaying the color and name changes on one of said displays.

31. A method as claimed in claim 18, further comprising the step of changing the background image for all users by grabbing images from other windows on a display and bringing them into a conference.

32. A method as claimed in claim 18, further comprising the steps of permitting users to scroll their image without affecting other users, and scrolling each user's image to a same location.

33. In a desktop image conferencing method, including the steps of: creating a background color image on one of said displays to open a conference; transferring said background color image to remaining ones of said plurality of display, the improvement comprising the steps of: permitting users to scroll their image without affecting other users, and scrolling each user's image to a same location.

34. In a desktop image conferencing method, including the steps of: creating a background color image on one of said displays to open a conference; transferring said background color image to remaining ones of said plurality of displays, the improvement comprising the step of: changing the background image for all users by grabbing images from other windows on a display and bringing them into the conference.