PostScript ( PS ) is the page description language in electronic publishing and desktop publishing business. This is a dynamically typed concatenative programming language created in Adobe Systems by John Warnock, Charles Geschke, Doug Brotz, Ed Taft and Bill Paxton from 1982 to 1984.
Video PostScript
Histori
The PostScript concept language was featured in 1976 when John Warnock worked at Evans & amp; Sutherland, the computer graphics company. At that time John Warnock was developing an interpreter for a large three-dimensional graphics database in the port of New York. Warnock understands the System Design language for processing graphics.
At the same time, researchers at Xerox PARC have developed the first laser printers and have recognized the need for standard means for defining page images. In 1975-1976, Bob Sproull and William Newman developed the Press format, which was eventually used in the Xerox Star system to drive laser printers. But Press, data format rather than language, less flexibility, and PARC installed Interpress attempts to make its replacement.
In 1978, Warnock left Evans & amp; Sutherland and joined Xerox PARC to work with Martin Newell. They rewrite the Design System to create an interpretive language, J & amp; M or JaM (for "John and Martin") used for VLSI design and type investigation and graphic printing. This work then evolved and expanded into Interpress language.
Warnock went with Chuck Geschke and founded Adobe Systems in December 1982. They, together with Doug Brotz, Ed Taft, and Bill Paxton created a simpler language, similar to Interpress, called PostScript, which entered the market in 1984. Around that time they were visited by Steve Jobs, who urged them to adapt PostScript to be used as a language to drive laser printers.
In March 1985, Apple LaserWriter was the first printer shipped with PostScript, sparking the desktop publishing revolution (DTP) in the mid-1980s. The combination of extensive technical benefits and availability makes PostScript the preferred language for graphics output for printing applications. For a while an interpreter (sometimes referred to as RIP for Raster Image Processors) for the PostScript language was a common component of laser printers, into the 1990s.
However, the implementation costs are high; the computer outputs the raw PS code that the printer will interpret to be a raster image at the natural resolution of the printer. This requires a high-performance microprocessor and lots of memory. LaserWriter uses Motorola 68000 12MHz, making it faster than any Macintosh computer installed. When the laser printer machine alone costs more than a thousand dollars, the PS surcharges are marginal. But when the printer mechanisms fall in price, the cost of implementing the PS becomes a big part of the overall cost of the printer; In addition, with desktop computers becoming more powerful, it no longer makes sense to disassemble rasterisation jobs into resource-constrained printers. In 2001, some low-end printer models came with support for PostScript, largely due to increased competition from much cheaper non-PostScript inkjet printers, and new software-based methods to render PostScript images on a computer, making them suitable for any printer. ; PDF, PostScript descent, provides one such method, and has replaced PostScript as the de facto standard for electronic document distribution.
In high-end printers, PostScript processors remain common, and their use can dramatically reduce the CPU work involved in printing documents, transferring the PostScript image rendering jobs from computer to printer.
PostScript Level 1
The first version of the PostScript language was released to the market in 1984. The term "Level 1" was added when Level 2 was introduced.
PostScript Level 2
PostScript Level 2 was introduced in 1991, and included some improvements: increased speed and reliability, support for RIP separation, image decompression (eg, JPEG images can be provided by PostScript programs), support for composite fonts, and form mechanisms for caching content which can be reused.
PostScript 3
PostScript 3 (Adobe dropped the terminology "level" that supports the simplified version) came in late 1997, and along with many new dictionary versions of older operators, introduced better color handling and new filters (which allowed compression in the program)/decompression, chunking programs, and advanced error handling).
PostScript 3 is significant in terms of replacing existing proprietary color electronic prepress systems, then widely used for magazine production, through the introduction of fine shading operations with up to 4096 gray colors (instead of 256 available in PostScript Level 2), as well as DeviceN, color space which allows the addition of additional ink colors (called point colors) into the composite color pages.
Maps PostScript
Use in printing
Before PostScript
Prior to the introduction of PostScript, printers were designed to print text output characters that were given text - usually in ASCII - as inputs. There are a number of technologies for this task, but most share properties that the glyphs are physically difficult to change, because they are branded to a typewriter button, a metal band, or an optical plate.
This changes to some degree with the increasing popularity of dot matrix printers. The characters in this system are described as a series of dots, as defined by the font table inside the printer. As they develop in sophistication, dot matrix printers begin to include some built-in fonts from which users can choose, and some models allow users to upload their own glyphs to the printer.
The dot matrix printer also introduces the ability to print raster graphics. The graphic is interpreted by the computer and sent as a series of dots to the printer using a series of runaway sequences. The printer control language varies from printer to printer, requiring program authors to create multiple drivers.
Vector graphics printing is left to special purpose devices, called plotters. Almost all plotters have the same command language, HPGL, but their usage is limited to anything other than graphics printing. In addition, they tend to be expensive and slow, and thus rare.
Print PostScript
The laser printer combines the best features of both the printer and the plotter. Like plotters, laser printers offer high-quality line art, and like dot-matrix printers, they are able to produce raster text and graphics pages. Unlike printers or plotters, laser printers make it possible to place high quality graphics and text on the same page. PostScript makes it possible to fully exploit these characteristics, by offering a single control language that can be used on any printer brand.
PostScript goes beyond the common printer control language and is a complete programming language. Many applications can convert documents into PostScript programs whose implementation will generate original documents. This program can be sent to an interpreter in the printer, which produces a printed document, or to one inside another application, which will display the document on the screen. Since the documents are the same regardless of their purpose, they are called device-independent .
PostScript is very important to implement on-the fly rasterization; everything, even text, is determined in the form of a straight line and a cubic curve of BÃÆ' Â © zier (previously found only in CAD applications), allowing random scaling, rotation and other transformations. When the PostScript program is interpreted, the interpreter changes these instructions into the required points to form the output. For this reason the PostScript interpreter is sometimes called the PostScript raster image processor, or RIP.
Font handling
Almost as complex as PostScript itself is handling its fonts. The font system uses primitive PS graphics to draw glyphs as curves, which can then be displayed at any resolution. A number of typographic problems should be considered with this approach.
One of the problems is that the font does not really scale linearly on a small size; the glyphs feature will become too big or small and they start looking wrong. PostScript avoids this problem with hinting font inclusion, where additional information is provided in horizontal or vertical bands to help identify features in each letter that are important for the rasterizer to maintain. The result is a font that looks significantly better even at low resolutions; it was previously believed that handmade bitmap fonts are required for this task.
At that time, the technology for incorporating these instructions in fonts was carefully preserved, and the fonts implied were compressed and encrypted into what is called Adobe Type 1 Font (also known as PostScript Font Type 1 , PS1 , T1 or Adobe Type 1 ). Type 1 is effectively a simplification of the PS system for storing outline information only, not as a complete language (PDF is similar in this case). Adobe will then sell the license to Type 1 technology for those who want to add clues to their own fonts. Those who do not license the remaining technology with Type 3 Font (also known as PostScript Type 3 Font , PS3 or T3 ). Type 3 fonts are allowed for all PostScript language sophistication, but without a standard approach for hinting.
Type 2 font format is designed for use with the Compact Font Format (CFF) format, and is implemented to reduce the size of the overall font file. The CFF/Type2 format then becomes the basis for handling PostScript's outline in the OpenType font.
The CID-keyed font format is also designed, to solve problems in OCF/Type 0 fonts, to solve complex Asian language encodings (CJK) and huge character set problems. The CID-key font format can be used with a Type 1 font format for fonts with a standard CID key, or Type 2 for fonts with CID-keyed OpenType fonts.
To compete with the Adobe system, Apple designed their own system, TrueType, around 1991. Shortly after TrueType's announcement, Adobe published a specification for the Type 1 font format. Retail tools such as Altsys Fontographer (acquired by Macromedia in January 1995, owned by FontLab 2005) added the ability to create Type 1 fonts. Since then, many free Type 1 fonts have been released; for example, fonts used with TeX typesetting systems are available in this format.
In the early 1990s there were several other systems for storing line-based fonts, developed by Bitstream and METAFONT for example, but none of which included general purpose printing solutions and were therefore not widely used.
In the late 1990s, Adobe joined Microsoft in developing OpenType, which is essentially a functional superset of the Type 1 and TrueType formats. When printed to a PostScript output device, unnecessary parts of the OpenType font are removed, and what is sent to the device by the driver is the same as for the TrueType or Type 1 fonts, depending on the type of line present in the OpenType font.
Other implementations
In the 1980s, Adobe withdrew most of its revenue from license fees for PostScript deployment for printers, known as raster image processors or RIP . As a number of new RISC-based platforms became available in the mid-1980s, some people found that Adobe's support for the new machines was lacking.
This and the cost issues cause PostScript third-party implementations to be common, especially in inexpensive printers (where license fees are a sticking point) or in high-end letters (where speed-seeking support for new platforms is faster than Adobe can provide ). At one point, Microsoft licensed Apple compatible PostScript-compatible translators named TrueImage, and Apple licensed to Microsoft its new font format, TrueType. Apple finally reached an agreement with Adobe and the original PostScript license for the printer, but TrueType became the standard line font technology for Windows and Macintosh.
Currently, third-party PostScript compatible interpreters are widely used in multifunctional printers and peripherals (MFPs). For example, the IPS PS3 CSR plc translator, formerly known as PhoenixPage, is standard on many printers and MFPs, including those developed by Hewlett-Packard and sold under the LaserJet and Color LaserJet lines. Other third-party PostScript solutions used by print manufacturers and MFPs include Jaws and Harlequin RIP, both by Global Graphics. The free software version, with some other apps, is Ghostscript. Some compatible translators are listed on the Wiki Printing Undocumented.
Some cheap basic laser printers do not support PostScript, but come with drivers that merely format the original graphics platform instead of converting them into PostScript first. When PostScript support is required for such printers, Ghostscript can be used. There are also a number of commercial PostScript translators, such as T-Script TeleType Co..
Use as display system
PostScript became commercially successful because of the introduction of a graphical user interface, which allowed designers to directly set up pages for final output on laser printers. However, the GUI graphical system itself is generally much more sophisticated than PostScript; Apple's QuickDraw, for example, supports only basic lines and arcs, not complex B-splines and advanced PostScript filling options. To fully utilize PostScript printing, applications on the computer must re-implement these features using their own host platform graph system. This causes many problems where the on-screen layout will not exactly match the printout, due to differences in the execution of these features.
As computer power grows, it becomes possible to host a PS system on a computer rather than a printer. This leads to the natural evolution of PS from a printing system into a system that can also be used as a host graphic language. There are many advantages to this approach; not only helps eliminate the possibility of different outputs on the screen and the printer, but also provides powerful graphics systems for the computer, and allows the printer to be "stupid" when the cost of the laser machine falls. In production settings, using PostScript as a display system means that the host computer can render low resolution to screen, higher resolution to printer, or simply send PS code to a smart printer to print outside.
However, PostScript is written with printing in mind, and has many features that make it unsuitable for direct use in interactive display systems. Specifically, the PS is based on the idea of ​​collecting the PS command until the showpage command is visible, at which point all the commands read up to that point are interpreted and excluded. In this interactive system is clearly not appropriate. PS also does not have any kind of built interactivity; for example, supporting hit detection for mouse interactivity is clearly not applicable when PS is used on the printer.
When Steve Jobs left Apple and started NeXT, he installed Adobe on the idea of ​​using PS as a display system for his new workstation computer. The result is a PostScript Display, or DPS. DPS adds basic functionality to improve performance by converting many string searches into 32 bit integers, adding support for direct output with each command, and adding functionality to allow the GUI to check the diagram. In addition, a set of "bindings" is provided to allow PS code to be called directly from the C programming language. NeXT uses these bindings in their NeXTStep system to provide object-oriented graphics systems. Although DPS was written in conjunction with NeXT, Adobe sold it commercially and that was a common feature of most Unix workstations in the 1990s.
Sun Microsystems took another approach, creating NeWS. Instead of the DPS concept that allows the PS to interact with the C program, NeWS instead extends the PS into a suitable language for running all computer GUIs. Sun added a number of new commands for timers, mouse controls, interruptions and other systems needed for interactivity, and added data structures and language elements to enable it to be truly object-oriented internally. A complete GUI, three actually, is written in NeWS and is reserved for time on their workstations. However, ongoing efforts to standardize the X11 system led to the introduction and widespread use of the Sun system, and NeWS never became widely used.
Language
PostScript is a Turing-complete programming language, belonging to the concatenative group. Usually, PostScript programs are not produced by humans, but by other programs. However, it is possible to write a computer program in PostScript just like any other programming language.
PostScript is an interpreted, stack-based language similar to Forth but with powerful dynamic typing, data structures inspired by those found in Lisp, scoped memory and, since language level 2, garbage collection. The syntax of the language uses an upturned Polish notation, which makes the sequence of operations unambiguous, but reading the program requires some practice, because one must keep the layout of the pile in mind. Most operators (what other language terms work ) take their arguments from the stack, and put the result into the stack. Literal (for example, numbers) has the effect of placing copies of themselves in the pile. Sophisticated data structures can be built on array and dictionary types, but can not be declared to type systems, which see everything just as arrays and dictionaries, so any further typing is disciplined to applied to the user-specified "type" is passed to the code that implements it.
The "%" character is used to introduce comments in the PostScript program. As a general convention, every PostScript program should start with the character "%! PS" as an interpreter hint so that all devices will interpret it correctly as PostScript.
"Hello world"
The Hello World program, the usual way to show a small sample of a complete program in a particular language, might look like this in PostScript (level 2):
or if the output device has a console
Long unit
PostScript uses dots as the unit of length. However, unlike some other versions of the point, PostScript uses exactly 72 points to an inch. Thereby:
- 1 point = 1 / 72 inch = 25.4 / 72 mm = 127 / 360 mm = 352.777... micrometer
For example, to draw a 4 cm long vertical line, that's enough for typing:
0 0 moved 0 113.385827 linear stroke
Easier to read and idiomatic, one might use the following equation, which shows the definition of simple procedures and the use of mathematical operators mul and div :
Source of the article : Wikipedia
0 Comments