I|||||||||||l||||I|||||fl||||||||||||||||||l||||l|||||||l||||||l||||||||
`US006Ti'138]B1
`
`(12) United States Patent
`Klein
`
`(1(I) Patent No.:
`(45) Date of Patent:
`
`US 6,771,381 B1
`Aug. 3, 2004
`
`(54)
`
`lJlS'l'RII.llJ'l'|<ll) C()Ml"I.i'l'|<IR
`ARCHITECTURE AND PROCESS FOR
`VIRTUAI. COPYING
`
`(T6)
`
`lnvenlorz
`
`I.:Ill!'('I'lCl3 C. Klein. 1010 Wayne Ave.,
`Silver Spring, MD (US) 20910
`
`[ ' } Ntitice:
`
`Subject in any disclaimer. the lerrn nfthi.H'.
`palenl is exlended or adjusted under 35
`U.S.(f.
`|54(h) hy (I days.
`
`(21) Appl. No.: l}9f43-8.300
`(22)
`Filed:
`Nov. 12, 1999
`
`[GU]
`
`Related US. Application Data
`Provisional application No. I‘){J;"lU8,'FOB, Iiled on Nov. I3,
`1908.
`
`Int. Cl? *n
`0n GIJGK l5i'lJ0
`(51)
`án
`(52) US. Cl.
`353fl.l5; 358.-’l.l
`
`(58) Field of Search .
`3,-3:i,'1.l. I.fi. 1.I3.
`3:'>Sf1_|:':, l_l(:, 402, 403, 40?, 42$; ?|[l:'8,
`I4. 15. 33. 62. 63. 64. 65. 7'3. T3
`
`(56)
`
`U.S.
`5.560.405 A "
`' cited by examiner
`
`Relt-rencl.-5 Cited
`l’.n’\'l‘l.iN'l' [)0{.'UM|.iN']'S
`9;"l9‘?7 Yeh .......................... .. 710.5303
`
`Priiriury Exu.-:ir'ner—ArI|1ur G. Evans
`ll. Dunner.
`(74) Arrorrrey, Agem. or
`.'*'r'rm—lr:|Ei
`Wilmer, (fuller, Pickering Hale and Dorr 1.1 _P
`(57)
`ABSTRACT
`
`li5q.;
`
`The purpose of Ihe \-"muzil Copier invention ("\"I‘.'_"') is to
`enzibic a Iypical PC user to add electronic paper processing
`to their exisiing business process. \«"C is an extension of Ihe
`concept we Lmdersland as copying. In its simples: form il
`cxlends lhe nulian of copying from a process 1hE|.I involves
`paper going Ihmugh a convunlinnal uopiur devicI:.
`to a
`process thal involves paper being scanned from a device al
`one localiun and copied In a device at anolher localiun. [I'1iI5
`r11nrI.: mphislicalcd fnrrn, \-"(T can copy paper frnrn a device
`.11 one localion direclly inlo a business applicaliorl residing
`on a network or on Ihc lnlernct, or visa vcrszi. The VC
`invcntiun is _~.-.nl‘|ware ihal manages paper 50 that ii can he
`electronically and seamlessly copied in and out 0]‘ devices
`and |.'3l|Sil'Il:S-5 aipplicalions (such as Micrntasufi
`()IT1<:::.
`MII:msul'l Exchange. Imus NLJICH) wiih an uplinnal single-
`slep Go operation. The \-''C‘ software can reside on a PC,
`LAN.-‘WAN server. digilal device (such as a digital copier),
`air am :1 web server II: he u(::.1:.~a;c(I over the Inlurnel.
`
`15 Claims, 44 Drawing Sheets
`
`W5Ufl
`[0()RBi\NBXi'OD€.I'POWER BUI].DERiDEL.PHI}
`
`WINDOWS MANAGER {MIT}
`
`1
`
`HP 1001
`HP lOOl
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 1 «:44
`
`US 6,771,381 B1
`
`HIGH—LEVEL DEVELOPER (VB, JAVA, DELPHI, ETC.)
`
`4 C
`
`ORE TECHNOLOGY (ENGINES)
`
`5
`
`FIG. 1
`
`2
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 2 «£44
`
`US 6,771,381 B1
`
`COMPONENT INTERFACE
`
`COMPONENT FACTORY 'C'—LEVEL API
`
`FIG. 2
`
`
`
`
`
`COMPONENT INTERFACE
`
`OBJECT MANAGER
`
`3
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 3 «:44
`
`US 6,771,381 B1
`
`
`
`
`LAYER 3 - ENGINE FUNCTIONS
`
`FIG. 4
`
`LAYER 2 - ENGINE CONFIGURATION
`
`LAYER 1 - ENGINE MANAGEMENT
`
`ORGINAL 'C'— LEVEL API
`
`
`
`LAYER 1 - ENGINE MANAGEMENT
`
`LAYER 2 - ENGINE CONFIGURATION
`
`LAYER 3 - ENGINE FUNCTIONS
`
`FIG - 6
`
`4
`
`

`
`US. Patent
`
`Aug. 3, 2004
`
`Sheet 4 of44
`
`US 6,'}"?l,381 B1
`
` IEngineManagement
`
`Interface
`
`ActivateEngine
`
`IsEngineActivated
`
`Arguments
`
`Description
`
`BOOL Activate {activates or deactivates an engine. This
`interface element will cause an engine to
`load itself to or unload itself from memory.
`Determine whether the engine has been
`successfully loaded into memory.
`
`
`FIG. 7
`
`
`
`of arguments In using the alue array.
`
`Setsetting
`
`DWORD Setting
`VARIANT Value
`
`Sets the setting Setting to a yalue of Value.
`the Setting argument IS a unique number
`that represents a specific setting type. The
`Value argument is a union argument type
`that can accept any style argument.
`includin an arm of elements.
`
`GetSetting
`
`'
`
`-
`
`gets the settin Setting and places the value
`in Value. the etting argument is a unique
`number that represents a specific setting
`type. The Value argument is a union
`argument type that can accept anylr style
`argument, including an array of e ements.
`
`FIG. 10
`
`IEngineManagement
`Interface
`
`Arguments
`
`Description
`
`Function
`
`Initiate _the function as represented b
`the Setting argument, usi
`a vanab e number
`
`FIG. 12
`
`5
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 5 of 44
`
`US 6,??1,381 B1
`
`ENGINE MANAGEMENT - LAYER I
`
`LOAD I UNLOAD ENGINE (FILE 1)
`
`
`
`
`
`
`128
`
`DYNAMIC LINKING ENGINE FUNCTION CALLS
`
`
`
`{FILE 2)
`
`INITIALIZE ENGINE SETTINGS
`
`(mus 3)
`
`FIG. 8
`
`6
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 6 of 44
`
`US 6,771,381 B1
`
`ENGINE FUNCTION A
`
`ENGINE DLL A
`
`ENGINE SETTING A
`
`ENGINE FUNCTION B
`
`ENGINE DLL B
`
`ENGINE SETTING B
`
`ENGINE SETTING C
`
`ENGINE FUNCTION C
`
`ENGINE DLL C
`
`FIG. 9
`
`7
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 7 «:44
`
`US 6,771,381 B1
`
`._Z___
`
`24
`W
`
`156
`
`
`
`
`
`
`
`
`
`PROMPT SETTING
`
`FIG. 11
`
`8
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 3 «:44
`
`US 6,771,381 B1
`
`153
`
`160
`
`'52
`
`164
`
`
`
`
`ENGINE FUCTION - LAYER 3
`
`PERFORM FUNCTION
`
`GET FUNCTION RESULTS
`
`CLEAR FUNCTION RESULTS
`
`EVENT FEEDBACK
`
`FIG. 13
`
`9
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 9 «:44
`
`US 6,771,381 B1
`
`
`
`50
`
`52
`
`40
`\
`
`53‘
`CPU
`
`‘-~ KEYBOARD MOUSE «M DISPLAY 4,43
`INTERFACE
`J2
`
`55
`\
`
`64
`
`60
`
`54
`
`62
`
`IN[21‘lE1IR]§f:EE
`
`DISK
`CONTROLLER
`
`-ROM
`
`-AM
`
`COMMUNICATIONS
`PORT
`
`gPfi1§%
`CD ROM
`/’
`FLOPPY
`66
`DRIVE --\
`70
`
`63
`
`INFRARED
`RECEIVER
`(OPTIONAL)
`
`INFRARED
`TRANSMITTER
`(OFFIONAL)
`
`73
`FIG. 15
`
`76
`
`74
`
`10
`10
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 10 of 44
`
`US 6,771,381 B1
`
`
`
`
`RECEIVER
`{OPTIONAL}
`
`T4
`RADIO
`TRANSMITTER
`(OPTIONAL)
`
`
`
`70
`
`32
`
`30
`
`11
`11
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 11 of 44
`
`US 6,771,381 B1
`
`84
`
`FIG. 17
`
`12
`12
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 12 M44
`
`US 6,771,381 B1
`
`VISUAL LNTERFACE
`(CORBANBXFOCXIPOWER BUILDER! DELPHI)
`
`WINDOWS MANAGER (MFCI
`
`122
`LEVEL3
`120
`LEVEL 2
`
`113
`LEVEL 1
`
`:
`-wmnows
`REPRESENTATION;
`-wmnows
`:
`ERROR MANAGER _
`-BRIDGE
`
`-SUPPLEMENTARY :
`
`:
`
`-wmnows
`ERROR MANAGER ’
`-BRIDGE
`
`-wmnows
`REPRESENTATION
`-wmnows
`ERROR MANAGER
`-BRIDGE
`
`-SUPPLEMENTARY -
`DIALOGS
`
`-SUPPLEMENTARY
`DIALOGS
`
`:
`' CONSISTENT
`1 16
`LEVEL3 ORJECIINTERFACE,
`
`' CONSISTENT
`OBJECT INTERFACE
`I BRIDGE
`
`0 CONSISTENT
`0B}EL'I'lNI“ERFACE
`' BRIDGE
`
`C“
`
`LEVEL2
`
`L [N
`
`-PROTECTION
`112
`LEVEL1 -ERROR MANAGER
`-ADMlNl5‘l‘RATl0N ,
`
`'
`
`:
`-PROTECHON
`-ERROR MANAGER ‘
`-ADMINISTRATION I
`
`-PROTECTION
`-ERROR MANAGER
`-ADMINISTRATTON
`
`T1‘-CNN0‘~0GY
`CATEGORLES
`
`SCAN
`
`UNDERLYING
`ENGINES
`
`KoFAx_x1oN1cs,
`sEA1=0Rr, TWAIN
`RIXELTRANSLATIONS
`
`.
`
`'
`
`IMAGE CLEANUP
`
`.
`
`sEQu01A,T1s,
`CLEAR LMAGE,
`SEAPORT
`
`XEROX, cAERE_
`CALERA, NESTOR,
`.RRIME REc0GNm0N,
`LIGATLJRE, MITEK
`
`FIG. 18
`
`13
`13
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 13 M44
`
`US 6,711,381 B1
`
`
`
` OBJECT MANAGER
`
`166
`
`16,135.20
`
`ENGINE OBJECT COMPONENT
`
`FIG. 19
`
`14
`14
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 14 0144
`
`US 6,771,381 B1
`
`SERVERILAN
`
`174
`
`MACPHNEICLJENT
`
`SERVERILAN
`
`170
`
`176
`
`
`
`01315131
`MANAGER
`LAYER
`
`132
`
`MACHINE’
`CLIENT
`
`
`
`186
`
`134
`
`1311
`
`MACHINE I CLIENT
`- OBJECT MANAGER
`' ENGINE OBJECT
`
`- CORE TECHNOLOGY
`
`CORE TECHNOLOGY
`E§gflI§0%}ig§-[CT
`
`FIG. 20
`
`15
`15
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Shea-t150f44
`
`US 6,771,381 B1
`
`
`
`
`ENGINE OBJECT COMPONENT
`
`16,1820
`
`FIG. 21
`
`16
`16
`
`OBJECT MANAGER
`
`LANIINTRANET, INTERNET. WEB
`
`[68
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Shea-t160f44
`
`US 6,771,381 B1
`
`ma
`
`
`
`THIN CLIENT
`
`WEB SERVER
`
`1'12
`
`132a
`
`1?8
`
`BROWSER!
`THIN CLIENT
`
`- CORE TECHNOLOGY
`
`MACHINE I CLIENT
`
`- OBJECT MANAGER
`' ENGINE OBJECT
`
`OBIECT
`MANAGER
`LAYER
`
`CORE TECHNOLOGY
`ENGINE OBJECT
`COMPONENT
`
`FIG. 22
`
`17
`17
`
`

`
`
`
`
`
`
`
`I3I8€‘ILL‘9SfltwoLImansvooz‘Efinv1uamd-S-[1I3I8€‘ILL‘9SfltwoLImansvooz‘Efinv1uamd-S-[1
`
`
`
`
`
`
`
`
`
`1818
`18
`
`

`
`ElE|ElEl|:iDE|C!E]DDE|CfL||_l|_JDL!t_iE!C|
`
`JLJ|:|D|J[|gU
`
`<1
`
`
`7 Ti
`
`E1 1:: D E] 5 £1 :1 :1
`
`||||| [EE
`
`
`
`Juawd'S'£]
`
`pnOn
`5"
`
`E
`
`C:
`- GU’)
`
`L‘
`%
`;
`
`4'
`FIG. 23B
`
`202'
`
`19
`19
`
`

`
`R. Open Document
`' '
`\, Close Document
`\
`\“ Zoom In
`-\
`-\" Zoom Out
`'
`'
`Q.
`Print Document
`-\_ Print Image
`-\ Annotation
`‘\ Tool Bar
`-\ Advanced
`-'
`Function
`n Toc-1Bar
`n Change View
`-\
`—
`
`
`
`EX“
`
`
`
`E1‘
`U:
`
`E
`E’.
`g
`§
`
`E
`1°5*‘
`I‘-I
`§
`g
`E
`5
`2’
`3
`
`c:
`V’Ox
`:3
`E51V-1
`
`‘L:
`
` Yn
`
`pm‘
`
`Image
`
`203'
`
`Text
`Image
`= ,11 __J|
`
`
`FIG_ 23C
`204"
`M"
`
`
`
`212"
`
`20
`20
`
`
`
`214'
`
`210"
`
`200"
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 20 M44
`
`US 6,771,381 B1
`
`183
`
`VIEWER PROCESS
`
`
`
`
`OBJECT MANAGER
`
`166
`
`16,1820
`
`ENGINE OBJECT COMPONENT
`
`FIG. 24
`
`21
`21
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 21 M44
`
`US 6,771,381 B1
`
`SERVERILAN
`
`H4
`
`190
`
`VIEWER
`PROCESS
`
`MACHINE I CLIENT
`
`SERVERJLAN
`
`170
`
`176
`
`173
`
`
`
`OBJECT
`MANAGER
`LAYER
`
`132
`
`MACHINE!
`CLIENT
`
`186
`
`134
`
`180
`
`MACHINE I CLIENT
`- OBJECT MANAGER
`' ENGINE OBJECT
`- CORE TECHNOLOGY
`
`
`
`CORE TECHNOLOGY
`E§g1,§§0%1§Jmm
`
`194
`
`I92
`
`VIEWER
`PROCESS
`
`VIEWER
`PROCESS
`
`FIG. 25
`
`22
`22
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 22 M44
`
`US 6,771,381 B1
`
`
` VIEWER PROCESS
`
`
`
`OBJECT MANAGER
`
`133
`
`
`
`153
`
`
`LANIINTRANET, INTERNET, WEB
`
` ENGINE OBIECT COMPONENT
`
`16,13,320
`
`
`FIG. 26
`
`23
`23
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 23 M44
`
`US 6,771,381 B1
`
`1742:
`
`176a
`
`1903
`
`WEB SERVER
`
`WEWER
`PROCESS
`
`BROWSER!
`THIN CLIENT
`
`
`
`'79“
`
`196a
`
`172
`
`182a
`
`173
`
`VIEWER
`PROCESS
`
`136
`
`
`
`BROWSER}
`THIN CLIENT
`
`M?fi,]EgER
`LAYER
`
`134
`
`I80
`
`MACHINE I CLIENT
`'0B3EC]‘MANAGER
`' ENGINE OBJECT
`
`- CORE TECHNOLOGY
`
`OBJECT
`Mg:¢§RER
`
`CORE TECHNOLOGY!
`Eggggoagggr
`
`VIEWER
`PROCESS
`
`VIEWER
`PROCESS
`
`FIG. 27
`
`24
`24
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 24 M44
`
`US 6,771,381 B1
`
`
`
`_ E._MA|L. LOAL FILES
`
`
`
`
`
`PFHNTEH
`
`DIGITAL COPiEFI
`
`MULTI-FUNCTHDNAL
`
`PER1PHERAL(li.e. FAX)
`
`FIG. 28
`
`25
`25
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 25 01°44
`
`US 6,771,381 Bl
`
`THE ('{'IMF.'\ \'Y IJM I11:-I}
`
`Elmlm
`
`Em
`
`I°=
`
`I=>
`
`Status
`
`Virtual copy Ready
`
`FIG. 29
`
`26
`26
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 25 of 44
`
`US 6,771,381 B1
`
`Power VC
`
`Emmi
`
`Open File
`
`E]
`
`E I:>
`
`Io:
`
`Virtual Copier
`
`FIG. 30
`
`27
`27
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 27 0l'44
`
`US 6,7'.’1,38l Bl
`
`CLIENT
`
`<1 pnWn <=>
`
`gr
`
`1:
`
`<3
`
`PROCESS
`
`PROCESS
`
`PROCESS
`
`FIG. 31
`
`28
`28
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 23 of 44
`
`US 6,Ti'l,38l B1
`
`Virtual Copier
`
`End User Application
`
`3rd party App
`
`FIG. 32
`
`29
`29
`
`

`
`US. Patent
`
`Aug.3,20u4
`
`Sheet 29 «M4
`
`US 6,771,381 B1
`
`3"‘ Party Application
`
`Virtual Copier Server
`Module
`
`FIG. 33
`
`30
`30
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 30 of 44
`
`Us 6,771,381 B1
`
`Start Copy
`
`Initiate Input
`
`Update Client
`
`Initiate Process
`
`Update Cllent
`
`.
`
`Module
`
`
`
`.
`
`
`
`Initiate Output
`
`FIG. 34
`
`31
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 31 of 44
`
`US 6,?71,3s1 B1
`
`
`
`FIG. 35
`
`32
`32
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 32 of 44
`
`US 6,771,381 B1
`
`lnputModu|es
`
`CopierModule
`
`0utpmMDdules
`
`Processhdodules
`
`Configure
`
`Collections of
`Copierlvfodule objects, of
`types InpuIModu1e,
`OuIpulModule, and
`Pr0cessModulI:
`respectively
`
`Load
`
`Unload
`
`IsLoaded (
`
`)
`
`Savesetting~;As
`Default (
`)
`
`Resetsettings (
`
`)
`
`lflbject
`
`I
`
`‘Collection
`
`‘Property
`
`‘
`
`‘Method
`
`‘
`
`
`
`EventI
`
`FIG. 36
`
`33
`33
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 33 of 44
`
`Us 6,771,381 B1
`
`
`
`0utputModuJe
`
`
`
`ProcessM0duIes
`
`PmI:e55Mo-dule
`
`I Object J ‘Collection
`
`34
`34
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 34 of 44
`
`US 6,771,381 B1
`
`.
`W“ A
`3 Pages
`
`File B
`I Page
`
`,
`F"° C
`3 Pages‘.
`
`File D
`1 Page
`
`File
`A
`
`File
`A
`
`File
`A
`
`File
`B
`
`File
`C
`
`File
`C
`
`File
`C
`
`File
`D
`
`Page
`I
`
`Page
`2
`
`Page
`3
`
`Page
`I
`
`Page
`1
`
`Page
`2
`
`Page
`3
`
`Page
`1
`
`File
`
`\/Document
`Page
`
`Page
`1
`
`Page
`2
`
`Page | Page
`3
`4
`
`Page
`5
`
`Page
`6
`
`Page
`7
`
`Page
`3
`
`FIG. 38
`
`35
`35
`
`Disk files of
`actual
`images:
`
`\/Document
`i mom a]
`
`layout
`
`
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 35 of 44
`
`US 6,771,381 B1
`
`
`
`{Collection
`
`Properly
`
`I
`
`’\Method
`
`r
`
`Even!
`
`I
`
`FIG. 39
`
`36
`36
`
`

`
`U.S. Patent
`
`Aug. 3, 21:04
`
`sum 36 0:44
`
`US 6,771,381 B1
`
`
`
`|_.._:___.__.l
`
`SuhModuIeID
`
`
`
`ErrorCade
`
`ErmrText
`
`Severity
`
`Lobjectj
`
`I Collection
`
`
`
` Property
`
`’
`
`}Method
`
`r
`
`Event
`
`‘
`
`FIG. 40
`
`37
`37
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 37 M44
`
`US 6,771,381 B1
`
`rCo[iection
`
`Property
`
`|
`
`'Meth0d
`
`\
`
`[Event
`
`r
`
`FIG. 41
`
`38
`38
`
`

`
`U.S. Patent
`
`Aug. 3. 2004
`
`Sheet 38 M44
`
`US 6,771,381 B1
`
`Sewer Module
`
`Events Generated by Server
`
`vsc Pro - ramslarl
`
`vscMoc|LIleLo:1dStarI
`
`vseModu |eL0adEnd
`
`vseModu}cGoStart
`
`{vscM0duIeCancclcd)
`
`(vsePr0gramCancc|ed)
`vseModuleGoEnd
`
`vse Pro rarnEr1d
`
`End virtual copy operation (Go)
`
`
`
`Unload IOPModules ! vscModuleUnI0adSlart
`
`e vseModu|eUn|oadEnd
`
`39
`39
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 39 of 44
`
`US 6,771,381 Bl
`
`Client Module
`
`Server Module
`
`Initiate Server
`
`Presentavailable I
`
`.
`
`Select modules
`
`Program Object
`
`touse I
`Startavirtualcopy I G00Method
`
`Process Server
`feedback
`
`Status & Error
`Events
`
`FIG. 43
`
`40
`40
`
`

`
`U.S. Patent
`
`Aug. 3, 21:04
`
`Sheet 40 of 44
`
`US 6,771,381 B1
`
`IOP Module
`
`Application Manager Ciass
`
`Event Manager Class
`
`
`
`Panel Manager
`Class
`
`Document
`Navigation Class
`
`Layout Manager
`Class
`
`Server Module
`Methods
`
`'
`
`¥ Propeny
`
`| Method
`
`I
`
`I Event
`
`\
`
`The Client Module has a fixed set of features that it needs to perform:
`
`FIG. 44
`
`41
`41
`
`

`
`US. Patent
`
`Aug. 3, 2004
`
`Sheet 41 of 44
`
`US 6,'}"?l,381 B1
`
`
`
`
`
`Configure( )
`
`GD (VI)ucument Feedback)
`
`ResetSettings(
`
`}
`
`SaveSetIingsAsl)efault (
`
`)
`
`
`
`
`
`FIG. 45
`
`42
`42
`
`

`
`US. Patent
`
`Aug. 3, 2004
`
`Sheet 42 of 44
`
`US 6,'}"?l,381 B1
`
`
`
`
`
`
`
`Conection
`
`Properly
`
`FIG. 46
`
`43
`43
`
`

`
`US. Patent
`
`Aug. 3, 2004
`
`Sheet 43 of 44
`
`US 6,'}"?l,381 B1
`
`SubMuduleID
`
`StatusType
`
`Statushlumber
`
`StalusText
`
`| Object
`
`|:oIIecfion
`
`’Pr0perty
`
`l
`
`[Method
`
`'
`
`
`
`Event
`
`I
`
`FIG. 47
`
`44
`44
`
`

`
`U.S. Patent
`
`Aug. 3, 2004
`
`Sheet 44 M44
`
`US 6,771,381 B1
`
`Server Module
`
`Sewer Module Intedace Io JOP
`
`
`
`Iop Modme
`
`interface mass
`
`
`
`Feedback
`
`Configuration Class
`
`Configure ( 1
`
`FIesetSetlings( 1
`
`Savesetiings...
`
`
`
`
`Go [VDocument Feedback)
`
`Configme { )
`
`F{esetSetlings( ]
`
`SaveSetlingsAsDeiau|t { ){llll
`
`Executive Class
`
`Go {VDocument]u
`
`
`
`|Obje.-ct‘
`
`| Collection
`
`N
`
`l Property I
`
`Method
`
`\
`
`FIG. 48
`
`45
`45
`
`

`
`US 6,771,381 B1
`
`5
`
`ll)
`
`15
`
`3|'l
`
`1
`I)IS'l‘RlBU'l‘ED COM PUTER
`r\RCHIT[-ICTURE AND PROCESS FOR
`\u’IR'l‘l_lr\L COPYING
`
`RELr'fl'l.iD Al’Pi..l(TA'l'I ONS
`
`'lhis application claims priority to US. Provisional Appli-
`cation 6{l.-‘|tl8,T98. filed Nov. I3. 1998, incorporated herein
`by reference.
`This application is related to, a continuation—in—part app|i~
`cation of, and claims priority to,
`the following non-
`provisional applications: Ser. No. Dtlv'9S0,838, filed Oct. 15,
`199?, now U.S. Pat. No. t'J,lS5,59(|;
`Ser. No.08r91l,I'.l83, filed Aug. 14, I991 now abandoned;
`Ser. No. U8.-’95{i.9ll. Iiled Oct. I5, 199?. now abandoned:
`Ser. No. DB.-’9St}.83'l'. filed Oct. 15, 199'.-", now abandoned;
`Ser. No. tJBi’95(l‘,T38. filed Oct. 15, 199?, now abandoned;
`Ser. No. U8i’95{J.?4l. filed Oct. I5, 1997. now abandoned:
`all of which are hereby incorporated try reference.
`This application is related to. and claims priority to. the
`following provisional applications by way the claim of
`priority of the above listed non—provisional applications:
`Oct. 18. 1996, Ser. No. t50,’(|28,l29;
`Oct. 18. I996, Ser. No. fit'J,’(I23.523;
`Oct. 18. 1996, Set. No. fiUi’(|28,l281
`Oct. 18. 1995, Ser. No. 60,"(l28.t597;
`Uct. IS,
`I991’), Scr. No. 6[l,"lJ2S,639;
`Oct. 18, I996. Ser. No. 603198.685; all of which are
`hereby incorporated by reference.
`|"l1iLD 0|‘ THE lNVl:'NTlt)N
`
`The present invention is generally related to a computer
`architecture and process for stand-alone andinr distributed
`cnvirortment. and more particularly to a computer architec-
`ture and process using a substantially uniform management
`in a stand—alone and.-‘or distributed computing environment
`including, for example. client server andfor intranet andfor
`internet operating environments.
`BACKGROUND OF TIIE RELATED ART
`
`2
`Additionally. every r’\i’l manages errors differently further
`complicating the problems described above. Some r\l‘ls
`return a consistent error code for each function. Error
`management in this case is very organized and manageable.
`Other Al’ls return error codes as one of the parameters
`passed to the function. There are i-’-Wis that mix the choice of
`error management and have some functions return an error
`code while other functions pass the error code as a parameter
`of a function. Errors can also be managed by a callback
`function, eliminating the need for passing any error code as
`part of the function. ln some instances of a poorly imple-
`menlcd AP1 the errors are not passed back at all.
`Every engine, such as a text retrieval ur an OCR (Optical
`Character Recognition) engine, has a Unique interface. This
`interface is generally a "C"—level AP! [Application Program
`Interface). Further, an AP] can at any time be synchronous.
`asynchronous, manage one or more callbacks, require input,
`pass hack output. carry a variety of different styles of
`functions, return values or not return values, and implement
`the unpredictable. This unpredictability in 111315 further
`compounds the problem of developing a sane way of inter-
`facing between components and i-'\[’[s.
`"lb date, because of the cornplexitics of “(.T"-level r’\l‘ls
`and components interfacing thereto, the only way to create
`a component out of an existing “C"—level AP] is to have an
`experienced programmer in the held to do the work. Humans
`can intelligently anaiyzc an API, and create :1 component
`based on intelligent decisions and experiences.
`In most
`cases, the learning curve for understanding and integrating
`a new engine can be one man-month to several man-years
`and generally requires highly experienced "EC" program-
`mers. Requiring a human to perform the necessary work is
`costly, and subject to real-life human constraints.
`Since there is no structure or format for implementing
`"C"-level :\Pls,
`the ability to automatically transform a
`unique Al’l
`into a standard component would seem
`impossible, since that would take a nearly—human level of
`intelligence.
`in spite of the continued automation of
`in addition,
`business processes. companies are increasing their paper use
`by 35-30% and spending up to 15% of their total budget on
`managing paper. Companies are often running dual
`pro-ces-res—a computerized process along with the corre-
`sponding paper tiling sysle111——and paying an extraordinary
`price for it. Just a few examples will illustrate the problem:
`1} accounting clerks are maintaining paper invoices with
`information that
`is also being re-keyed into accounting
`systems. 2) administrative assistants are filing incoming
`correspondence in cabinets for customers whose records are
`also being electronically maintained by contact management
`systems, 3) help desk operators are storing complaints sent
`in on paper while also tracking those complaints in a
`computerized system. Additional industry trends include the
`following:
`For every SIOOM in increased revenues, a company will
`use 8.8 million additional pages of paper
`The Document Management market is expected to grow
`at 30% per year
`The digital device market is growing at 30% per year
`Estimates show the web—based document imaging market
`growing at 50% per year
`The digital device manufacturers. especially the copier
`companies, are heavily promoting the ability to connect
`their devices to networks. but have not been able to
`deliver an eliective 9:-ftware solution to date.
`l3usines¢.t:s continue to automate more processes, but
`managing the associated paper is often ignored, resulting in
`inefficiency and higher costs.
`46
`46
`
`45
`
`51.!
`
`A "C" or "C++"- Level Al'l (hereinafter "C" Level),
`which is the native language and interface for a vast reposi-
`tory of core technologies from small software vendors and
`research laboratories, are unique to each designer. The
`designer of a text retrieval "C"—AP[ will generally imple-
`ment an interface that is completely dilferent than a second
`inVet'ltot‘ creating a "C“-level Api fur OCR.
`Every "C"-level r’\l’| is unique. both in its choice of AP!
`syntax as well as its method for implementing the syntax.
`Some r\l‘l's consist of one or two functions that
`take
`parameters ofiering options for different features offered by
`the technology. Other AP[s consist of hundreds of fitnctions 5,
`with few arguments, where each Function is associated with
`a particular feature of the core technology. Other APls
`provide a mixture ofsome features being combined with one
`function with many at'gumcnL-t. while other features are
`separated into individual l‘l.It‘JCllOfJ calls.
`Without any constraints. each designer oi‘ a core technol-
`ogy chooses to implement his or her technology with an
`interfatx that
`is suitable to the subject or simply was the
`most expedient choice of the moment. Since there are no
`constraints, a "IC"-level API has a totally unpredictable
`interface that can often be the hindrance to using the core
`technology.
`
`60
`
`65
`
`

`
`3
`I have dctcnninud that a component factory, if it is to ht:
`truly auton1atctJ or manually ettpcdilcd. must be able to take
`any "(T”-levcl AP! and transfonn it into a component.
`I have also detcnnined an efficient and workable design
`for an architecture to define the migration path for any
`"C“'—|evc| AP] into a component.
`is desirable to develop
`I have also determined that
`it
`software tools for automatically generating reusable soft-
`ware components from core software technologies, thus
`making these software technologies available to a much
`larger user laase.
`is desirable to design a
`I have further determined that it
`distributed computer al‘Ci1iIct.'|l.It‘0 and prtttncss for manually
`andlur automatically generating reusable software compo-
`nents. ’ll1e computer architecture may be implemented using
`a client server andfor intranet antlfor intcrnet operating
`environments.
`I have further dctennined that it is desirable to design a
`computer architecture and process for image viewing in a
`stand—alone and.-“or distributed environment. The computer
`architecture and process optionally uses a substantially
`uniform management layer in a stand—alone andior distrib-
`uted computing environment including, for example, client
`server andfor intranet andior internet operating environ~
`mcnts.
`I have further determined that it
`is desirable to enable a
`typical Pt.‘ user to add clcclronir: papcr processing to their
`existing business prot:es.<;.
`I have further determined that
`it
`is desirable to enable
`software that manages paper so that it can l:-t: electronically
`and seamlessly copied in and out of devices and husincss
`applications (such as Microsoft Office, Microsoft Exchange,
`Lotus Notes} with an optional single-step Go operation.
`SUMMARY OF THE INVENTION
`One would expect the translating a “C"—levcl API from its
`native state into a component would require human—|evcl
`intelligence. This is mainly because "C"'—|eve| APIS have
`virtually no constraints as to how they can be implemented.
`This means that
`there are an infinity variations of APIS,
`which can only be managed by human—level intelligence.
`While this point is true, [ have determined that the appro-
`priate solution starts at the other side of the cquation, which
`is the component itself.
`My solution starts out with a definition of a component
`that can sustain the featuretfunctiun requirementv. of any
`AP[. In other words, the interface of a generic component
`can be defined such that
`the features. and functions. er
`virtually any AP] can he re-implemented within its hounds.
`'|’l1c two known end-points are. for example. the "L"-Ievcl
`AP! that generally starter with each component (although
`other programming languages may also he used and are
`within the scope of the present invention), and the compo-
`nent interface that rcprcscnts any set of features.-‘functions on
`the other side. The component factory migratm the original
`"C"~|evc| Al’! from its original state into the generic inter-
`face defined by the topmost layer. The first feature that can
`be demonstrated is that
`there is a topmost layer that can
`define a component interface that can represent the features.’
`functions of most core technologieit.
`The component factory migrates the "C"-level AP] to the
`topmost
`level. Doing this in one large step would be
`impossible since the “C"—level AP] has a near-infinite vari-
`ety of styles. However, the architecture advantageously has
`enough well-defined and wcll-structured layers for imple-
`mentlng the topmost component interface, for creating the
`component factory.
`
`3|‘!
`
`45
`
`60
`
`65
`
`US 6,771,381 B1
`
`ll)
`
`l5
`
`4
`The computer architecture is designed for managing a
`diverse set of independent corc technologies ("engines")
`using a single consistent framework. The architecture bal-
`ances two seemingly opposing requlrements:
`the need to
`provide a single consistent
`interface to many different
`engines with the ability to access the unique features of each
`engine.
`The benefit of the architecture is that it enables a company
`to rapidly "wrap" a sophisticated technology so that other
`high-level developers can easily learn and implement the
`core technology. The computer architecture is therefore a
`middicwarc or enabling technology.
`it provides a
`Another benefit of the architecture is that
`high-level spccifitralittrt for a consistent interface to any core
`technology. Once a high-level developer learns the interface
`described herein for one engine, that knowledge is easily
`transferable to other engines that are implemented using the
`architecture. For example, once a high-level developer
`learns to use the computer architecture for OCR (Optical
`Character Recognition), using the computer architecture for
`other engines, such as barcode recognition or
`forms
`processing, is trivial.
`The architecture described herein is, at once, a framework
`for rapidly wrapping sophisticated technologies into high-
`level components, as well as a framework for high-level
`developers to communicate with a diverse set of engines.
`The ereatlng of a component factory is based an the fact that
`the architecture defines a clear path for "wrapping" any
`(T-level Al’! into a component using simple structures and
`many rotc steps. This process is currently being done in an
`inefficient manner by a programmer in the field.
`In addition, the method described herein for creating a
`component factory creates a wcll-defined multi-tiered archi-
`tecture for a component and automates, substantially
`automates. or manually cxpcditcs hereinafter automate the
`process of migrating a "(."’-.I'\l’l from iL-i native state through
`the various tiers of the architecture resulting in a standard-
`ized component. Advantagcously.
`the method described
`herein does not base the component factory on making
`human—|evel
`intelligent decisions on how to translate a
`"C"—APl
`into a component. Rather, by creating a well-
`defined architecture described below that is multi~tiered, the
`method is a series of incremental steps that need to be taken
`to migrate the “C"-AP] from one tier within the architecture
`to the next. [n this way each incremental step is not a major
`one, but in sequence the cntire series of steps will result in
`it component.
`the
`Since each step of migration is not a major one,
`chances for automating these steps is significantly higher
`and the likelihood of h-tzlng able to Create the component
`factory becomes feasible. This approach is in fact what
`makes the method cost-cllectivc. sinct:
`the alternative
`approach.
`i.e., computer-generated human-level decision
`making, has many years before becoming sophisticated
`enough to replace humans in any realistic decision-making
`prnocss.
`'l'l1c main features of the architcctun: are twofold:
`1) Defining system architecture that describes in detail
`how to implement a component from a "C""—level API;
`2) Creating a component factory by automating the migra-
`tion ol" at “C"-level API
`from one tier within the
`architecture to the next.
`The latter feature is the key to actually making the compo-
`nent factory feasible. Wlth a fixed architecture that can be
`used to implement a “C”-levcl API as a component (using a
`programmer), that same architecture can be used as the basis
`for the component factory model.
`47
`47
`
`51.!
`
`

`
`US 6,771,381 B1
`
`ll)
`
`l5
`
`..
`
`3|'l
`
`5
`In order to make the component factory. each step of the
`arcl'Iilt:(:lt.trt: needs to he designed In facililate automation or
`manually expedited, In other words. 1 have determined that
`automatingiexpediting the process of taking the original
`"C"-level AP! and migrating it to a Level
`I layer. and then
`a Level 1 to a Level 2. and then a Level 2 to a Level 3 layer,
`and so on. the component has been implemented automati-
`cally or more efliciently. The component factory is therefore
`a sum of the ability to automate migrating the "C"-level API
`from one layer to the next within a well-defined architecture
`for implementing components.
`There are numerous core technologies, such as text-
`retrieval and ICR (Intelligent Cltaractcr Recognition). that
`have already been implemented, and are only available as
`"C"-level r’\|’ls. Many. ifrtot most. core tcchnologic=. arc lirst
`released exclusively as "(."'-lcvcl M’ls. While there are
`integrators and corporations who have the team of technolo-
`gists who can integrate these "C”—leve| APls in—house, most
`companies are looking for component versions that can be
`implemented at a much higher level.
`Therefore, many of the core technologies that are only
`available in a "C"’—1eve1AP! are not being used due to their
`inaccessible interface. The benefit of the component factory
`is that
`it can rapidly make available core technologies
`implemented as "C" .«’\Pls that would otherwise he undt:ruti-
`lined or dormant in research labs by converting them to
`high-level components.
`that can he used by millions of
`power-PC users.
`With the advent of the World Wide Web (WEB) this
`opportunity has increased exponentially. The WEB is now
`home to a vast number of WEB authors with minimal lbnnal
`training who can implement
`l['f'ML pages and build web
`sites. One of the fundamental technologies for extending the
`capability of the WEB from simple page viewing to inter-
`active and sophisticated applicatiom is components.
`Aoornpo nent extenck the capability of I [TML by enabling
`a WEB author to add core technology as a pre-packaged
`technology. Since components are fundamental
`to the
`growth and usability of the WEB. having a component
`factory that can translate “C”-level toolkits. into components
`that are then usable within WEB sites opens a vast and new
`worldwide market to these technologies.
`The purpose of the Virtual Copier ("VC") aspect of the
`present
`invention is to enable a typical PC user to add
`electronic paper processing to their existing business pro-
`cess. VC is an extension of the concept we understand as
`copying. in its simplest fonn it extends the notion of copying
`from a process that involves paper going through a conven-
`tional copier device, to a process that involves paper being
`scanned from a device at one location and copied to a device
`at another location. In its more sophisticated form, VC can
`copy paper from a device at one location directly into a
`business application residing on a network or on the Internet,
`or visa versa. The VC invention is software that manages
`paper so that it can be electronically and iusamlcssly copied
`in and out of devices and business applications (such as
`1\-'licrosolt()ffice. Microsoft Exchange. Lotus Notcs)with an
`optional single—step Go operation. The VC software can
`reside on a PC. l..AN.-‘WAN sewer. digital device (such as a
`digital copier), or on a web sewer to be accessed over the
`lntcrnet.
`Wrtual Copier is designed to solve the corporate paper
`problem by enabling existing web—ba.sed and c|ient—server
`applications to manage paper as part of their solution.
`Virtual Copier links the familiar and universal world of
`paper and digital devices to web~hased and c|ient—server
`applications. The result is that the automated business pro-
`
`6
`t.‘{:tL'-ics become the primary storage of paper in electronic
`form. Information that is typically managed and processed
`in paper fonn is "copicrl" into the system and managed by
`the business processes with which users are accustomed.
`which is made possible by using Virtual Copier. Simple
`extensions of Wrtual Copier support seamless electronic
`outsourcing of paper processing and archival services over
`the web.
`Virtual Copier is a unique combination of an intuitive
`application built on an open component architecture that
`delivers a simple innovation: provide paper pruceiising to
`existing lrtiranet and client-server business processes with-
`out any fuss. Whether it is an oilice clerk that needs to easily
`copy a report from a desktop scanner to the company’s
`Intranet-networkcrl copicr. or an accounting software inte-
`grator that wants to Cmlkid paper proces-ting. Virtual Copier
`offers a simple solution. lb the offict: clerk Virtual Copier is
`a document imaging application packaged in the familiar
`setting of an ollice copier. To the integrator, the underlying
`open architecture of Virtual Copier oflers a simple integra-
`tion path [or embedding paper processing into its client-
`server