United States Patent (19)
`Padzensky
`
`US006098092A
`Patent Number:
`11
`(45) Date of Patent:
`
`6,098,092
`*Aug. 1, 2000
`
`54 SERVER TO DYNAMICALLY GENERATE
`GRAPHICS FOR THE WORLD WIDE WEB
`
`75 Inventor: David Jay Padzensky, Campbell, Calif.
`
`73 ASSignee: Sison Graphics, Inc., Mountain View,
`
`c:
`*
`
`Notice:
`Notice:
`
`inued
`d
`Thi
`is patent issued on a continued pros-
`ecution application filed under 37 CFR
`1.53(d), and is subject to the twenty year
`patent term provisions of 35 U.S.C.
`154(a)(2).
`
`5,822,511 10/1998 Kashyap et al. ................... 395/182.06
`5,823,781. 10/1998 Hitcock et al. ......................... 434/118
`5,828,887 10/1998 Yeager et al. ...
`395/712
`5,832,271 11/1998 Devanbu ................................. 395/705
`5.835,911 11/1998 Nakagawa et al. ..................... 707/203
`5,845,084 12/1998 Cordell et al. .......................... 709/234
`5,848.291 12/1998 Milne et al. .
`395/806
`5,848,427 12/1998 Hyodo .........
`... 707/513
`5,870,559 2/1999 Leshem et al. .
`709/224
`5,880,740 3/1999 Halliday et al.
`345/435
`5,884,056 3/1999 Steele ..........
`... 395/339
`5,886,709 3/1999 Willman ......
`... 345/440
`5,926,179 7/1999 Matsuda et al.
`345/355
`5,956,038 9/1999 Rekimoto ................................ 345/419
`OTHER PUBLICATIONS
`21 Appl. No.: 08/745,378
`CGM, Graphicap and Fontcap Supplement, Fred Clare.
`http://ngwww.sis.ucar.edu/ngdoc/ng4.1alpha/Supplements/
`22 Filed:
`Nov. 8, 1996
`cgm Supp/cgm Supp.html, Jun. 21, 1995.
`O 709:20.702. DATAPLOT, Overview, S.Baum www.lp.fu-berlin.de/
`52) -rr 1203; 709/221; 707/
`baum/DATAPLOT/), Mar. 25, 1996.
`58 Field of Search ............................... 395/200.33, 157,
`395/155, 800, 712, 182.06, 806, 615, 326;
`Primary Examiner-Framk J. Asia
`345/428, 440,355, 419, 128/660.01; 709/203,
`Assistant Examiner-Thong Vu
`221; 707/203; 434/118
`Attorney, Agent, or Firm Wagner, Murabito & Hao LLP
`57
`ABSTRACT
`A method and arrangement for dynamically generating
`computer displayable graphics for the World Wide Web is
`provided. Upon receiving a request from an end user over
`the web, a Server executes a program Stored in its memory
`to retrieve data from a Selected data Source Such as a
`continuously updated database. Next, the Server executes a
`Second program Stored in its memory using the data
`retrieved as input to generate computer graphics. The Second
`program is written in a flexible and easy to use general
`purpose graphics generating programming language. The
`Server Sends the computer graphics generated over the World
`Wide Web to the end user who requests it.
`27 Claims, 16 Drawing Sheets
`
`7
`
`56)
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`... 395/157
`5,204,947 4/1993 Berstein et al. ..
`... 395/140
`5,276,789
`1/1994 Besaw et al. .....
`... 395/155
`5,359,710 10/1994 Aono et al. .......
`... 395/800
`5,619,710 4/1997 Travis, Jr. et al.
`5,649,186 7/1997 Ferguson ................................. 395/610
`5,657,460 8/1997 Egan et al. .............................. 395/326
`5,715,823 2/1998 Wood et al. ......
`... 128/660.01
`5,729,741
`3/1998 Liaguno et al. ........................ 395/615
`5,732.216 3/1998 Logan et al.......
`... 395/200.33
`5,764,235 6/1998 Hunt et al. .............................. 345/428
`5,791,992 8/1998 Crump et al. ............................. 463/41
`5,793,966 8/1998 Amstein et al. ..
`395/200.33
`5,819,302 10/1998 Nielsen ................................... 707/523
`
`
`
`CLIENT
`
`CPU
`
`120
`
`MEMORY
`
`130
`
`SYSTEMBUS 140
`
`DISPLAY MONITOR
`10
`
`HTMLPAGE
`45
`
`100
`
`HTTP REUEST
`140
`
`NETWORK 135
`
`SERVER
`
`CPU
`
`16
`
`SYSTEMBUS
`
`MEMORY
`170
`
`11
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 1
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 1 of 16
`
`6,098,092
`
`
`
`CLIENT
`
`MEMORY
`
`130
`
`SYSTEM BUS 140
`
`DISPLAY MONITOR
`110
`
`HTML PAGE
`145
`
`HTTP REOUEST
`140
`
`
`
`NETWORK 135
`
`SERVER
`
`17O
`
`FIGURE 1
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 2
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 2 of 16
`
`6,098,092
`
`CLIENT COMPUTER 1 OO
`
`MEMORY
`
`BROWSER
`205
`
`130
`
`
`
`
`
`HTTP SERVER SOFTWARE
`
`204
`
`INTERPRETER
`
`
`
`
`
`DATA
`PARAMETER
`RETIEWAL
`PROGRAM
`2O1
`
`GRAPHICS
`PROGRAM
`2O2
`
`SOFTWARE 200
`
`MEMORY 170
`
`SERVER 150
`
`FIGURE 2
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 3
`
`

`

`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 4
`
`

`

`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 5
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet S of 16
`
`6,098,092
`
`CFLAGS = - 0
`picmaker : initfont.0 picmaker. Olex.yy.0 y.tab.O
`CC-O picmaker initfont.0 picmaker.0 lex.yy.0 y.tab.0 -lm
`
`leX.yy.C: leX.y.tab.C
`lex -Oy lex.
`
`y.tab.C: parser.y
`yaCC-V -d -t -Oy parser.y
`
`clean:
`-rm * 'bak *.0
`-rm COre leX.yy.C y.tab.C y.tab.h y.Output
`
`FIGURE 5
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 6
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 6 of 16
`
`6,098,092
`
`# include <bstring.h>
`# include "initfont.h"
`
`unsigned long int font255;
`
`void initfont (void) {
`char C;
`bzero (font, sizeof (font));
`
`font ' ' ) = OOOOOOOOOOO;
`font '
`' ) = 01 01 0100010;
`font " " ' ) = 02424000000;
`font 'if') = 02476247624;
`font 'S' = 03650301274;
`font ' '6' = 04204102042;
`font '8' = OOOOOOOOOOO;
`font " '' ) = 01 01OOOOOOO;
`font' (') = 00410101004;
`font')" = O1004040410;
`font ' ' ' ) = 05234763452;
`font " + ") = OOO 10342000;
`font ' ' ) = OOOOOOO 1020;
`font'. ' ) = 00000340000;
`font ' ' ) = OOOOOOOOO10;
`font ' ' ) = 00204102040;
`font 'O') = 03446526234;
`font '1') = 010301 01034;
`font '2' = 03442142O76;
`font '3') = 0740234O274;
`font '4') = 0444476O404;
`font '5' = O764O74O274;
`font' 6") - 03440744234;
`font '7" - O7604102040;
`font '8") = 03442344234;
`font '9") = 0344236O234;
`font': ' ) = 0001 OOO 1000;
`font'; ' ) = OOO 10001020;
`font ('C') = 0041020 1004;
`font' - ') = 00034.0034.00;
`font' > ' ) = 02O10041020;
`font'? ' ) = 03442040010;
`font ('G' = 00000000000;
`font 'A' | = 03442764242;
`font 'B' | = O7442744274;
`font 'C' - 03442404234;
`font D = 07422222274;
`
`to E.S.E.
`
`FIGURE 6
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 7
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 7 of 16
`
`6,098,092
`
`font 'G' = 03640464236;
`font ('H') = 04242764242;
`font ( '
`' ) = 034101 01034;
`font 'J' ) = 01604042434;
`font' K') = 044506.05044;
`font 'L' = O4040404O76;
`font ("M") = 04266524242;
`font 'N' = O4262524642;
`font 'O') = 03442424234;
`font ("P") = 07442744040;
`font 'O') = 034.42524636;
`font 'R' = O7442744442;
`font 'S' = 0364034O274;
`font 'T' = O7610101010;
`font 'U') = 04242424234;
`font "W" = O4242422410;
`font "W") = 04242525224;
`font ("X") = 04224102442;
`font ("Y") = 04224101010;
`font "Z") = 07604102O76;
`for (c = 'a'; c < = 'Z'; C++ )
`font (c) = font C-32;
`
`FIGURE 6 (COnt.)
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 8
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 8 of 16
`
`6,098,092
`
`1 OOO 10
`1 11 1 OO
`1 OOO 1 O
`1 11 1 OO
`
`FIGURE 7
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 9
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 9 of 16
`
`6,098,092
`
`extern unsigned long int font (255;
`Void initfont (Void);
`
`FIGURE 8
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 10
`
`

`

`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 11
`
`

`

`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 12
`
`

`

`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 13
`
`

`

`6,098,092
`
`U.S. Patent
`
`Sheet 13 of 16
`Aug. 1, 2000
`Void picout (void) {
`int i, j,
`printf("P6\n%d %d\n255\n", width, height);
`for ( i = 0; i < height; i++)
`for (j = 0, j < width ; j++) {
`putchar (picture j+ (i"width).r);
`putchar (picture j+ (i"width) .g);
`putchar (picture j + (i"width).b)
`}
`
`}
`int main () {
`initfont ();
`color.r = colorg = color. b = 255;
`yyparse (),
`picOut () ,
`
`FIGURE 9 (cont.)
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 14
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 14 of 16
`
`6,098,092
`
`typedef struct {
`Unsigned charr, g, b ;
`} rgb;
`
`extern int width, height, XOffset, yoffset;
`extern long picsize ;
`extern rgb picture ;
`extern rgb Color;
`extern intyydebug;
`
`FIGURE 10
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 15
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 15 of 16
`
`6,098,092
`
`-
`init 100, 100
`color = 127, 127, 127
`fill 50, 50-
`1103
`
`# Outside border
`
`Color = 0, 0, 0
`vline 0, 99 at O
`vline 0, 99 at 1
`wline 0, 99 at 2
`vline 0, 99 at 3
`hline 0, 99 at O
`hline 0, 99 at 1
`hline 0, 99 at 2
`hline 0, 99 at 3
`vline 0, 99 at 99
`vline O, 99 at 98
`vline 0, 99 at 97
`wline 0, 99 at 96
`hline 0, 99 at 99
`hline 0, 99 at 98
`hline 0, 99 at 97
`hline 0, 99 at 96
`
`# Label border
`Color = 0, 0, 0
`vline 30, 50 at 20
`hline 20, 80 at 30
`Color = 200, 200, 200
`wline 30, 50 at 80
`hline 20, 80 at 50
`fill 50, 40
`
`# Drawer handle
`Color = 0, 0, 0
`plot 30, 70, to 40, 80
`plot 40, 80, to 60, 80
`plot 60,80, to 70, 70
`plot 70, 70, to 65,70
`plot 65,70, to 60, 75
`plot 60, 75, to 40, 75
`plot 40, 75, to 35, 70
`plot 35, 70, to 30, 70
`
`color = 255, 255, 0
`fill 35, 72
`Color = 0, 0, 0
`draw "some text" at 24, 38
`
`1 104
`
`1105
`
`1106
`
`1107
`
`FIGURE 1 1
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 16
`
`

`

`U.S. Patent
`
`Aug. 1, 2000
`
`Sheet 16 of 16
`
`6,098,092
`
`
`
`SOMETEXT
`
`N
`N
`N
`N N N
`N N
`
`N
`N
`
`FIGURE 12
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 17
`
`

`

`1
`SERVER TO DYNAMICALLY GENERATE
`GRAPHICS FOR THE WORLD WIDE WEB
`FIELD OF THE INVENTION
`The invention generally relates to client-Server network
`environments such as the World Wide Web or private
`“Intranets', and more particularly relates to dynamically
`generating graphics in Such environments.
`PRIOR ART
`In the So-called information age, information that used to
`take weeks to Search and retrieve is now available contem
`poraneously at our fingertips. The proliferation of client
`Server networkS Such as the Internet, and in particular the
`World Wide Web (hereinafter the Web), makes a large
`amount of information accessible to anyone connected to the
`Internet. So-called “Intranets,” which are essentially
`Smaller, private versions of the Web, are also proliferating
`rapidly in many industries. In general except where other
`wise noted, the discussion herein applies equally to the Web
`and to Web-like Intranets.
`In general, the layout language for a Web document is
`Hypertext Markup Language (HTML). Each Web document
`is given a “Uniform Resource Locator” (URL) which is
`essentially an address path identifying the Server which
`hosts the desired document plus the location of the docu
`ment on the server. Using “browser' software such as
`Netscape". Navigator, an end-user can Send a request from
`a client computer to access a document Stored at a particular
`URL. When the server receives the user's request, it sends
`the requested HTML Web document to the client where the
`document can be displayed. The communications protocol
`used in making Such a request and in transferring Web
`documents is “Hypertext Transfer Protocol” (HTTP). For
`more information about the Web, see for example T.
`Berners-Lee, R. Cailliau, A. Loutonen, H. F. Nielsen, and A.
`Secret, “The World Wide Web, Communications of the
`ACM, vol. 37(8), August 1994.
`HTML allows any Web document to include hypertextual
`“links' to other Web documents including graphical images.
`The effect of a hypertextual link, as well known by practi
`tioners of the art, is that when the document containing the
`link is displayed to an end-user at a client computer, the
`end-user can access the linked document by pointing and
`Selecting a corresponding icon or highlighted text in the
`displayed document, a graphics image that has already been
`created and Stored in a graphic file is retrieved and Sent over
`the Web to the requested end-user for display.
`However, there are instances in which graphics images
`generated in real-time or dynamically may be desirable. For
`example, an end-user may want a real-time financial data
`graph from currently available data, or a test graph while the
`test is still ongoing, etc. In that case, the end-user Sends a
`Special request to the Server which retrieves the data and
`generates the requested graphics in real-time. The graphic is
`then sent to the end-user over the Web.
`Currently, to generate graphics from the data received, the
`Server executes a Stored Software program written by the
`content author (i.e., the web developer) in a popular high
`level programming language Such as C. However, the graph
`ics generating Software program is written for, and hence
`limited to a specific application. In addition, a certain level
`of proficiency with the high-level programming language is
`needed to write Such a program.
`Thus, a need exists for a Web server adapted to allow
`customized graphical images to be created dynamically and
`easily for transmitting over the Web.
`
`5
`
`15
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`6,098,092
`
`2
`SUMMARY OF THE INVENTION
`Accordingly, the present invention provides a Server that
`is adapted to allow customized graphical images to be
`created dynamically and easily for transmitting over the
`Web.
`The present invention meets the above need with a server
`that is coupled to a client-Server network Supporting hyper
`textual protocol and adapted to allow general purpose graph
`ics generating programs of wide application to be easily
`developed and modified without much prior familiarity
`knowledge. The server comprises a system bus, a CPU
`coupled to the System bus, and a graphical image generating
`means coupled to the System bus.
`The graphical image generating means comprises: means
`for accessing a plurality of computer graphics instructions
`which are written in a general purpose computer graphics
`language, an interpreter for interpreting the computer graph
`ics instructions and graphical parameters received from a
`data Source, and means that is responsive to the interpreter
`for generating the graphical image in accordance with a
`uniform protocol of the client-Server network. In response to
`a request from a client computer of the network, the graphi
`cal image generating means dynamically accesses the com
`puter graphics instructions that is developed or modified by
`the user, interprets the computer graphics instructions with
`data parameters, and generates the graphical image.
`All the features and advantages of the present invention
`will become apparent from the following detailed descrip
`tion of its preferred embodiment whose description should
`be taken in conjunction with the accompanying drawings.
`BRIEF DESCRIPTION OF THE DRAWINGS
`FIG. 1 is an illustration of a high level architectural view
`of a Web connection between a client computer and a web
`SCWC.
`FIG. 2 is an illustration of the modules of the Software
`program relative to the Web connection between client
`computer 100 and server 150 as shown in FIG. 1 in
`accordance to the present invention.
`FIG. 3 is an illustration of the leX programming codes for
`lexical analyzer file leX.l.
`FIG. 4 is an illustration of the yacc programming codes
`for parser file parsery.
`FIG. 5 is an illustration of the programming codes for
`program file makefile.
`FIG. 6 is an illustration of the C programming codes for
`program file initfont.c.
`FIG. 7 is an illustration of the binary representation of the
`character “B”.
`FIG. 8 is an illustration of the C programming codes for
`header file initfont.h.
`FIG. 9 is an illustration of the C programming codes for
`program file picmaker.c.
`FIG. 10 is an illustration of the C programming codes for
`header file picmaker.h.
`FIG. 11 is an illustration of an exemplary Picmaker
`graphics generating program.
`FIG. 12 is an illustration of a graphic generated by the
`exemplary Picmaker program shown in FIG. 10.
`DETAILED DESCRIPTION OF THE
`INVENTION
`In the following detailed description of the present
`invention, numerous Specific details are Set forth in order to
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 18
`
`

`

`3
`provide a thorough understanding of the present invention.
`However, it will be obvious to one skilled in the art that the
`present invention may be practiced without these specific
`details. In other instances well known methods, procedures,
`components, and circuits have not been described in detail
`as not to unnecessarily obscure aspects of the present
`invention.
`Reference is made to FIG. 1 illustrating a high level
`architectural view of a Web connection between a client
`computer and a server computer. In FIG. 1, client computer
`100 consists of CPU 120, memory 130, and display monitor
`110 which are connected together by system bus 140.
`Memory 130 stores browser Software to communicate to
`server computer 150. It will be understood by a person of
`ordinary skill in the art that client computer 100 can also
`include other elements not shown in FIG. 1 Such as disk
`drives, keyboard, etc. Server computer 150, on the other
`hand, includes CPU 160 and memory 170 which are con
`nected together by system bus 180. Memory 170 stores
`HTTP server Software as well as the instruction codes in
`accordance with the present invention. A perSon of ordinary
`skill in the art will understand that memories 130 and 170
`may also contain additional information Such as applications
`programs, network communication programs (e.g., TCP/IP
`protocol), operating System Software, data, etc. Client com
`25
`puter 100 and server computer 150 are linked together by
`network 135.
`In an exemplary exchange, an end-user uses client com
`puter 100 to execute the browser program stored in memory
`130 to request, retrieve, and display network documents
`(e.g., Web pages). Each request by client computer 100 for
`retrieval of a network document is formulated in accordance
`with the network protocol (e.g., HTTP) and transmitted
`across network 135 to server computer 150. Server com
`puter 150 receives HTTP requests such as request 140 and
`35
`processes them using the HTTP Server Software (e.g., stan
`dard network server software) stored in memory 170. The
`HTTP server software of computer 100 then instructs CPU
`160 to retrieve HTML page 145 from data stored in memory
`170 and to transmit a copy of Web page 145 back to client
`computer 100 for display on monitor 110.
`In accordance with the present invention, Web page 145,
`when displayed, includes a hypertextual icon or highlighted
`text that, upon being clicked-on by the end-user, results in
`the end-user's browser sending another request to CPU 160
`to execute a software program stored in memory 170 to
`dynamically generate graphics. AS described earlier, the
`general mechanism of hypertextual linkage is well-known
`and common with HTML Web pages.
`FIG. 2 illustrates a high level architectural view of the
`present invention relative to the Web connection between
`client computer 100 and server 150 as shown in FIG. 1. In
`particular, FIG. 2 illustrates the modules of the Software
`program to dynamically generate graphics on the Web in
`accordance to the present invention. The Software modules
`of program 200 include data parameters retrieval program
`201, graphics program 202, and an interpreter 203. Data
`parameters retrieval program 201 is designed to retrieve data
`in real time from a data Source (e.g., from direct user input
`or from a continuously updated database). It should be clear
`to a perSon of ordinary skill in the art that this Software
`module is common and can easily be developed. Graphics
`program 202 is developed to be used together with the data
`parameters retrieved by data parameters retrieval program
`201 to generate graphics dynamically. In the preferred
`embodiment, graphics program 202 is written in the Pic
`maker programming language which is further discussed
`
`4
`below. As a programming language, Picmaker offers flex
`ibility and ease of programming thereby allowing graphics
`programs that are fully generalizable to any graphics appli
`cation for the Web to be written. AS Such, graphics program
`202 can be easily written and/or modified to suit any Web
`graphics application. The computer instructions in graphics
`program 202 Specify images to be generated.
`Preferably, access to graphics program 202 is made avail
`able on-line to the user at client computer 100 to allow
`programming instructions to be changed and modified by the
`user for customization purpose. This revised graphics pro
`gram 202 is then transmitted back to server 150 for execu
`tion in place of the original graphics program 202.
`Alternately, graphics program 202 can be written by a user
`on client computer 100 and sent to server 150, in response
`to a prompt from server 150 for the filename and its path,
`together with the request for dynamically generated graphi
`cal image. It should be clear to a perSon of ordinary skill in
`the art that providing the user on-line access to a program for
`modification and programming purpose and allowing the
`user to upload a program to the Server are well-known and
`can be easily accomplished.
`Interpreter 203 is developed to interpret the commands of
`the Picmaker programming language for CPU 160 thereby
`allowing CPU 160 to carry out the instructions of graphics
`program 202. Based on the commands provided by graphics
`program 202 and data parameters provided by data param
`eters retrieval program 201, interpreter 203 generates a
`Portable Pixmap (PPM) file which is a public domain
`format. The PPM file can then be converted into a GIF image
`using a PPM-to-GIF filter which is available in the public
`domain. Interpreter 203 is further discussed below.
`Operationally, in response to HTTP request 205 from
`client computer 100 generated by the clicking of a hyper
`textual icon or highlighted text on the Web page provided by
`server 150, data parameters retrieval program 201 first
`downloads data from a data Source Such as a continuously
`updated data base or from direct user input. The data is
`stored in a specially formatted input file. The downloaded
`data and commands from graphics program 202 are Supplied
`as input to interpreter 203 which, with the help of CPU 160,
`generates the desired graphics in the form of PPM file. The
`PPM file is converted into a GIF image. Next, the GIF image
`is provided to HTTP server software 204. HTTP server
`Software 204 sends the GIF image to client computer 100 as
`a HTML document 206. Thus, the current invention
`describes a modular apparatus that is capable of dynamically
`generating any generalized graphics application for the Web.
`Programming language Picmaker is discussed next. The
`Syntax of programming language Picmaker is listed in Table
`1.
`
`TABLE 1.
`
`init width, height
`arc center-x, centery, radius, Start-degree, end-degree
`arc (width) center-x, centery, radius, Start-degree, end
`degree
`circle center-x, centery, radius, Start-degree, end
`degree
`circle (width) center-x, center-y, radius
`color = i, g, b
`draw "string at x, y
`draw (size) “string at x, y
`fill x,y
`hline x1, x2 aty
`vline y1, y2 at x
`hline (density) x1, x2 at y
`
`6,098,092
`
`15
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 19
`
`

`

`6,098,092
`
`S
`
`TABLE 1-continued
`vline (density) y1, y2 at x
`origin x,y
`plot x1, y1
`plot x1, y1 to x2, y2
`
`6
`in Table 1. An interpreter may be a common gateway
`interface (CGI) program that outputs a file in HTML lan
`guage. In the preferred embodiment, the interpreter is writ
`ten in C programming language. The interpreter consists of
`the following programming files leX.1, parsery, makefile,
`initfont.c., initfont.h, picmaker.c, and picmaker.h. Generally,
`a programming language interpreter consists of three main
`parts: a lexical analyzer, a parser, and a dictionary. For
`programming language Picmaker, files leX.1, parsery, and
`picmaker.c represent the lexical analyzer, the parser, and the
`dictionary, respectively. Discussion on programming lan
`guage development can be found, for example, in John
`Levine, Tony Mason, and Doug Brown, “Lex & Yacc” (2d
`ed. 1992) which is herein incorporated by reference as
`background material.
`Reference is now made to FIG. 3 illustrating the lex
`programming codes for lexical analyzer file leX.1. Alexical
`analyzer is a program written to define the lexemes used in
`the programming language. Similar to words in natural
`language, lexemes are fundamental building blocks that
`make up the programming language. Lexical analyzer pro
`gram leX.1 defines all the lexemes that are used in the
`programming language Picmaker namely “num”, “Strlit,
`“line”, “Hline”, “Vline”, “Plot”, “At”, “Init”, “Color,
`“Fill”, “Arc”, “Circle”, and “Origin”. As an example, to
`define the lexeme “Hline', lexical analyzer program leX.1
`first define the lexeme “line” which can be constructed by a
`combination of either upper or lower case letter "l' (i.e.,
`Ll), either upper or lower case letter “i” (i.e., Ii), either
`upper or lower case letter “n” (i.e., Nn), and either upper
`or lower case letter “e” (i.e., Eel). The lexeme “line” is then
`combined with either upper case or lower case letter “h”
`(i.e., Hh) to become the lexeme Hline. Other lexemes are
`defined in a Similar fashion. It should be clear to a perSon of
`ordinary skill in the art that other lexemes can easily be
`added to lexical analyzer program leX.l.
`FIG. 4 illustrates the yacc programming codes for parser
`file parsery. A parser file is written to combine the lexemes
`defined in the lexical analyzer program to create valid
`Sentences in the programming language. While Sentences
`consist of words in natural language, Sentences consist of
`lexemes in programming languages. Parser program parsery
`defines all the valid combinations of lexemes (i.e.,
`Sentences) that make up the commands of programming
`language Picmaker listed in Table 1. AS an example, the
`lexeme “Plot' is combined with two lexemes “Num’ sepa
`rated by a comma character to create the sentence “Plot Num
`, Num'. This Sentence is used to communicate the com
`mand “Plot X, y” which draws a point at (x, y). Other
`Sentences are created in a similar fashion.
`FIG. 5 illustrates the programming codes for program file
`Makefile. In essence, a Makefile is used to provide the
`computer/CPU with a list of files, modules, and sub
`programs needed to compile a program. An analogy for
`Makefile is a recipe for a dish.
`Referring now to FIG. 6 illustrating the C programming
`codes for initfont.c. Initfont.c is a program module for the
`programming language Picmaker and assigns a bitmap pic
`ture to each computer keyboard character. For example, the
`character “B” is given a bitmap picture having a 3-bit binary
`notation value of 07442744274. For reference, the binary
`equivalent of this value is 000 111 100 100 010 111 100 100
`010 111 100. Referring now to FIG. 7 which illustrates the
`above binary representation for the character B. AS Shown,
`the one’s (1S), which are highlighted for emphasis, form the
`character B. In assigning a bitmap picture to each computer
`keyboard character, the characters can be treated and gen
`erated as graphics.
`
`The command init requires two parameters width and
`height. Init Sets up a rectangle with the dimensions width
`and height and clears it all out to black. The origin (0, 0) is
`initialized to the upper-left corner.
`The command arc center-X, center-y, radius, Start-degree,
`end-degree requires parameters center-X, center-y, radius,
`Start-degree, end-degree. It draws an arc with a center point
`of (center-X, center-y), a radius of radius pixels, starting at
`Start-degree, and going counterclockwise to end-degree. On
`the other hand, the command arc (width) center-X, center-y,
`radius, Start-degree, end-degree draws an arc as above but
`with a line width that is width pixels wide.
`The command circle center-X, center-y, radius requires
`parameters center-X, center-y, radius. It draws a circle with
`a center point of (center-X, center-y) and a radius of radius.
`The command circle (width) center-X, center-y, radius
`requires parameters width, center-X, center-y, radius. It
`draws a circle with a center point of (center-X, center-y) and
`a radius of radius but with a line width that is width pixels
`wide.
`The command color=r, g, b requires three parameters r, g,
`and b. It Sets the current color wherein r, g, b are values
`between 0 and 255 levels of red, green, and blue respec
`tively.
`The command draw "string at x, y requires two param
`eterS X and y. It writes the text specified by String Starting at
`coordinate axes (x, y). The command draw (size)"string” at
`X, y requires parameters size, String, X, and y. It writes the
`text specified by String starting at coordinate axes (x, y) but
`magnified size times.
`The command fill x, y requires parameters X and y. It fills
`an area with the current color starting at coordinate axes (x,
`y).
`The command hline X1, X2 at y requires parameters X1,
`X2, and y. It draws a horizontal line between two points (x1,
`y) and (x2, y). The command Vline y1, y2 at X requires
`parameters y1, y2 and X. It draws a vertical line between two
`points (x, y1) and (x, y2).
`Likewise, the command hline (density) x1, x2, at y
`requires parameterS density, X1, X2, and y. It draws a dotted
`horizontal line between two points (x1, y) and (x2, y) Since
`it only draws every density pixels. The command Vline
`(density) y1, y2, at X requires parameters density, y1, y2, and
`X. It draws a dotted vertical line between two points (x, y1)
`and (x, y2) since it only draws every density pixels.
`The command origin X, y requires two parameterS X and
`y. It changes the origin of the graphics to the absolute
`position X, y. In other words, an origin command which
`follows another origin command will not reset the origin
`relative to the first. Rather, it will always reset the origin
`relative to the upper-left corner (i.e., coordinate axes (0, 0)).
`The command plot X, y requires parameterS X and y. It
`draws a point (x, y) in the current color. The command plot
`X1, y1 to X2, y2 requires parameters X1, y1, X2, and y2. It
`draws a line vector from point (x1, y1) to (x2, y2).
`In accordance with the present invention, a Picmaker
`programming language interpreter is written and Stored in
`memory 170 of server 150 to interpret the commands listed
`
`15
`
`25
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`LENNOX EXHIBIT 1035
`Lennox Industries Inc. v. Rosen Technologies LLC, IPR2023-00715, Page 20
`
`

`

`6,098,092
`
`7
`FIG. 8 illustrates the C programming codes for header file
`initfont.h. Header file initfont.h defines an array having 255
`elements and linkS program module initfont.c to this array.
`In So doing, the contents of program module initfont.c are
`indexed and can easily be retrieved in much the same way
`a library catalog index the book titles and their locations.
`FIG. 9 illustrates the C programming codes for dictionary
`file picmaker.c. Program file picmaker.c provides the mean
`ing to the command Sentences created in parser file parsery
`above by listing the C programming codes associated with
`each command. In other words, for each command, pic
`maker.c provides the programming StepS utilizing the Sup
`plied command parameters to accomplish the goal of the
`command. AS an example, take the command "Plot X, y'
`which draws a point having coordinate axes (x, y) in the
`current color. The C programming codes to carry out this
`command include:
`X+=XOffset, incrementing the X value by Xoffset to , take
`into account the origin of the graph
`y+=yoffset, incrementing the y value by yoffset to , take
`into account the origin of the graph
`
`15
`
`25
`
`8
`user. Similarly, graphical imageS can also be customized by
`allowing the user on client computer to write his own
`Picmaker graphics program and upload it to Server 150. AS
`an example, the drawer shown in FIG. 12 can be redrawn
`and new text added to the user's liking by making cha