Re: Printing MAC bitmaps on GS

[eaiu636@taurus.oac.uci.edu (Leif Strand)]

In article <3hc7la$ckk@gap.cco.caltech.edu>,
Nathan Mates <nathan@cco.caltech.edu> wrote:
>   I have read brochures for Mac clip art collections, and they say
>that they are pretty much 300dpi. Converted to 72dpi for the screen,
>but they are defined at 4x that (288dpi), which is why most older Mac
>drivers had the option of printing at 288dpi for speed, rather than
>stretching 288->300. 

These are probably PostScript clip art collections (they do exist).
If not, they are definitely not MacPaint files.  In either case,
SuperConvert can not convert them to the GS to begin with, so they
don't pertain to the original question:  printing a MacPaint bitmap
from the GS as it would be printed from a Mac.

>   Original MacPaint probably can't handle anything more than a raw
>screen image, true. But, I hate to tell you this: there are programs
>for the mac newer than that. Lots of programs have come out since
>then.

Again, can SuperConvert convert the relevant file formats?

>>In general no paint program stores bitmap files at 300 dpi, and further, 300
>>dpi bitmaps are never chugged over an AppleTalk line to a LaserWriter. 
>
>   Heck yes they do and are. Superpaint 3.x (and probably earlier
>versions) naturally does stuff at 300 dpi. And things are sent at 300
>dpi to a Laserwriter: pictures and non-native fonts. (Fonts that the
>LW has in ROM can be sent as ascii, but everything else is downloaded
>as a 300dpi bitmap). 

Admittedly, I have little experience with Superpaint and it was a long
time ago, but from what I do remember, Superpaint documents have
multiple "layers", one (or more?) of which can be a "draw" layer.  The
draw layer would of course be be converted to Postscript (just like a
MacDraw document, for example), and would be printed at the resolution
of the printer (about 300 dpi for most laser printers).  So Superpaint
isn't purely a "draw" program or a "paint" program.  But you can bet
that things in the "paint" layer will print like a 72 dpi bitmap.

>   Ever print a 300dpi postscript file to any printer? It takes a
>while.  That's because you're shoving 17x the info at the printer, and
>the printer has to deal with 17x the info.

Ever look at a Postscript file?  It isn't a bitmap (300 dpi or
otherwise).  I think this is the source of your misunderstanding.
Postscript files consist of the textual source code of programs
written in a postfix graphical description language.  These
programs are run by an interpreter in the laserwriter.  As they
run they render the document.  The document is always rendered
at 300 dpi or whatever the resolution of the printer might be,
because PostScript commands are "resolution-independent":  the
coordinates used are not dot or pixel coordinates but coordinates
on a device-independent grid which measures everything in "points"
(1 point = 1/72 of an inch).

>   Also, if you take a 72dpi source on a Mac program, and cut its
>size in half twice, and the extra pixels are not thrown away, it'll
>get sent to the LW at 288dpi. Scaling it by 24% in X and Y will up it
>to 300dpi.

This would depend on the program.  A draw program (or the draw
layer in Superpaint) could easily do this; but a paint program
would not.


>   If the Mac host program can only handle 72dpi, it prints to the
>printer driver at 72 dpi. If it's got a 300dpi printout, it feeds
>the driver a 300dpi image, which is then sent to the LW at that
>resolution. If the driver gets a 72 dpi image, then either it or
>the LW (not sure which) converts it to 300dpi before printing.

The Mac host program or the printer driver on the Mac never has
a 300 dpi image.  Resolutions over 72 dpi are achieved by sending
Postscript commands (not pixmaps at all) to the printer, which the
printer renders at the highest resolution possible.  It would be
the LW that scales a 72 dpi for printing at 300 dpi.

>   LWs cannot do 72dpi naturally; they operate at 300dpi internally.
>72dpi stuff is upped to 300dpi before printing, but if you have 300dpi
>source material (fonts, pictures, etc), who the heck would be so stupid
>as to convert it to 72dpi then back again at the printer?

Well, obviously.  If a laserwriter gets a 72 dpi bitmap, it will
scale it so it will be the right size at 300 dpi, not print it as
this microscopic thing.  But the resolution of the resulting
printout is _effectively_ 72 dpi, or more technically, 72 ppi
(pixels per inch) -- it will have a 72 dpi "chunkyness", if you
will.  But you won't magically get more detail.  And my point was,
300 dpi bitmaps are never sent to a laserwriter!!!  If bitmaps are
sent, they are 72 dpi.  Otherwise the stuff sent to a laserwriter
is a program written in Postscript, with commands like:

50 50 moveto
100 100 lineto

A Postscript program does not have a "dpi": it is rendered at the
full resolution of the printer, whatever that might be. 

>>The reason why the print resolution of the GS is so low is because the screen
>>resolution is so low, and any WYSIWYG printout has to display a chunkyness
>>that resembles the screen somewhat.
>
>   The GS's screen resolution is so low that's the problem? Sorry,
>wrong again. Standard Mac/Windoze is 640x480, GS is 640x200. If screen
>resolution was the fault, then the pictures would never be chunky in
>the horizontal dimension, simply vertically. But, this isn't the
>case. Any printout you do from a paint program (even with 'vertical
>condense' off) will be chunky in both directions. This is because
>the source is 72dpi, the computer's screen, but our eyes want more
>on a printout.
>
>
>   "Any WYSIWYG has to display a chunkiness that resembles the
>screen"? Where the heck did you get that load from? The size of things
>and relative positions should be the same, yes, but the resolution should
>not change this. 

What I meant was that WYSIWYG has a chunkyness that resembles the
screen _for a paint program_, because paint programs manipulate
bitmaps/pixmaps with resolutions identical to the screen resolution
of the hardware they run on.  It would not do to print a 320 mode
pixmap at the full resolution of any printer; the output would be
tiny.  Like you said, "the size of things... should be the same",
so, the whole picture has to be scaled at the printer end so that
the output has a size that resembles what is displayed on the screen.
Since we are dealing with pixmaps here, the size of individual
pixels on the printout also must resemble the size of pixels on the
screen -- each pixel may be composed of many printer dots, but
the pixels will be as chunky as they are on the screen.  We can
summarize this as follows:

for pixmaps,

     screen ppi (pixels per inch) = printer ppi

even though

     screen dpi < printer dpi

>   Case in point: if you have a font 2x or 4x larger, the printout is
>much smoother. Why? Because what's on the screen is chunky due to the
>low _screen_ resolution. But, the printer is not connected to the
>screen. It is connected to the computer through a driver. The driver
>figures out that the printer can do things at 4x the resolution, and so
>it sends a larger font, and tells it to draw 4x as many dots in the same
>area on the page.

This won't work for a pixmap, will it?  You can enlarge a pixmap
all you want, but you won't get any more detail.

>   No, you print at 144dpi (what the IWII can do, double screen res),
>and dither within that. But, printing to a LW has absolutely nothing
>to do with the Imagewriter; the drivers determine what is sent and
>how it's printed. The Laserwriter driver does not use 'larger pixels'
>of any sort, it uses grayscales, and does not expand the printed area.

Yes, the Imagewriter II can do 144 dpi vertically, but I don't think
this is used all the time (only when printing "Condensed" in "Best" mode,
I think).  If fact if you want to be really technical about it, the
horizontal resolution is 160 dpi.  But the GS/OS Imagewriter driver
generally uses the Imagewriter in 72 dpi vertical because it's faster
(you don't have to do multiple passes and 1/2 point platen adjustments).
Yes, the printer does use "larger pixels" when printing a pixmap --
you keep confusing "pixel" with "dot".  On the screen these are the
same, but on a printer one pixel may be composed of many dots,
sometimes in very sophisticated ways, as in Apple's PhotoGrade
technology, which combines variable-sized dots in a pinwheel shaped
pixel:

  O
  OOO
 OOO
   O 

As to how many dots per pixel there are when printing a GS pixmap
on an Imagewriter, I refer you to the Print Manager chapter of the
_Apple IIgs Toolbox Reference, Vol. 1_.

And for the record, the IWII can "do" _four_ times screen resolution
in the case of the Mac (about 144 dpi horizontally _and_ vertically
versus 72 each for the Mac screen), and eight times GS 640 mode
resolution (twice as high horizontally and 4 times as high vertically:
2 * 4 = 8).

>   This can be proven by any program that does true graphical objects
>on the GS. (AWGS sure doesn't). If you tell the printer driver that
>you have a line on the page from point A to point B (rather than a
>bunch of 72dpi pixels), the printer driver will do the job of drawing
>the line at whatever dpi the printer does, making it far smoother than
>the screen display.

Oh, so you do know the difference between a draw program and a paint
program?  Why did you bring all this draw program business into the
discussion?  We were speaking of making conversions of Mac B&W bitmaps
on the GS look as good, when printed, as they do on the Mac.  And
AWGS _can_ do true graphical objects, but because of some fluke, it
can only print them right in the Page Layout module (or so I've read).

>>  The trick to printing a MacPaint file nicely is getting a conversion
>>of it that is stretched vertically just like fonts are on-screen, and then
>>print it in condensed mode -- or, alternatively, getting a gigantic 320 mode
>>conversion that isn't stretched and printing it at 50% reduction (but not
>>condensed).
>
>   You've finally gotten back to what I said in the first place: it's
>not the GS's screen which is the problem, it's the source material.
>Get a big source, and shrink it while you print it.

Gee, could it be I know what I'm talking about?  Two things.  First,
Postscript files are not bitmaps, but programs that can render graphical
objects at any desired resolution (so the "source material" has
infinite resolution).  Bitmaps are 72 dpi and are sent to the
laserwriter at 72 dpi; this includes output from paint programs and
fonts in some cases.  Second, pixel resolution is not the same as
dot resolution.  Go to a _paint_ program.  Draw a skewed line.  Print
it with no printer effects (no 50% reduction, no condensed).  Print
it on a Imagewriter or a Laserwriter, I don't care.  Now, doesn't the
line on the printout look as "chunky" as it does on the screen?

--Leif Strand