[comp.graphics] routines

klug@mit-amt.MEDIA.MIT.EDU (Michael Klug) (07/26/89)

I'm looking for routines that do graphics. It would be most
helpful to me if these are written in a computer language. Does
anyone out there have anything like this? Thanks in advance. :-)

				Michael Klug

joe@hanauma.stanford.edu (Joe Dellinger) (07/26/89)

In article <354@mit-amt.MEDIA.MIT.EDU> klug@media-lab.media.mit.edu.UUCP (Michael Klug) writes:
>
>I'm looking for routines that do graphics. It would be most
>helpful to me if these are written in a computer language. Does
>anyone out there have anything like this? Thanks in advance. :-)

Every parody needs a serious article to go with it, or it doesn't work!
OK, here's a serious article to go with this one:

I am the primary designer of the "Vplot" graphics driver system. (I hope
people out there have found it useful.) The main advantage of Vplot (and
why we keep using it here) is that it allows you to support lots of
different graphical primitives (like vectors, filled areas, raster, text)
on lots of different kinds of devices (vector, raster, smart, dumb,
color, monochrome, screen, hardcopy, large, small, etc). Starting a few
months from now (got to get a PhD first), I think I would like to make a
"succesor to Vplot" graphics driver system. As much as possible, I would
like to merely ASSEMBLE other code that already exists and not WRITE new
code.

To this purpose, I am interested in collecting useful generic graphical
subroutines. Many of the routines I need I'll be able to steal from
Vplot, but I'd like to be able to support a more postscript-compatible
set of graphical primitives than Vplot currently uses.

Here is a shopping list of routines I already know I'd like:

1) INPUT:
	a set of N RGB triples
	M, the number of color table entries to fill
   OUTPUT:
	a set of M RGB triples which come closest to covering all
		the colors present in the input set of N RGB triples

2) INPUT:
	a set of M RGB triples specifying a color table
	a single RGB triple
   OUTPUT:
	the color table entry which is closest in color to the
	input single RGB triple

3) INPUT:
	a set of bezier curve definitions
	some sort of "resolution required" specification
   OUTPUT:
	a set of points that trace out the bezier curves using straight
	vectors to the required resolution

4) INPUT:
	a clipping window defined by an arbitrary path ("A")
	an arbitrary path ("B")
   OUTPUT:
	a set of paths that result when input path "B" is clipped to
	the clipping path "A"

5) Same as (4), but clip a FILLED PATH to another PATH. (Harder!)

Don't bother sending any routines that can't be redistributed with
another package. All contributors will be acknowledged in the source code
and documentation, if you so wish. If you don't have code to give me but
know a good reference in a book I can get, that would be good to know too.

Thanks!
With a little group effort, we could put together something _very_ useful
for all of us! If I can pull this off, we'll be able to plot postscript
on anything!
\    /\    /\    /\/\/\/\/\/\/\.-.-.-.-.......___________
 \  /  \  /  \  /Dept of Geophysics, Stanford University \/\/\.-.-....___
  \/    \/    \/Joe Dellinger joe@hanauma.stanford.edu  apple!hanauma!joe\/\.-._

rokicki@polya.Stanford.EDU (Tomas G. Rokicki) (07/26/89)

klug@mit-amt.MEDIA.MIT.EDU (Michael Klug) writes:
> I'm looking for routines that do graphics. It would be most
> helpful to me if these are written in a computer language. Does
> anyone out there have anything like this? Thanks in advance. :-)

Thanks, Michael, for the biggest laugh today.  It has been
depressing in this conference of late, completely devoid of any
graphics discussions.  Okay, I'll start the ball rolling.

Dithering seems to be a hot topic, so let's talk.  We've got the
various error diffusion algorithms that seem to be doing real well
for the screens, and the classic clustered dot algorithms for
printers that have troubles with isolated dots.  Has anyone tried
to combine the two, so you get a clustered dot F-S, for instance?
This might be done with hysteresis (bloody word isn't in my 
dictionary; sorry for the spelling); for instance, perhaps something
like an error function of 

         -1 3 1
    1 -1 -3 2 1
   .  .   .  . .

or some such (I have no idea what would be reasonable numbers) but
use a *negative* value for the feedback, so you get clustering.
I'm not even sure if this would work.  This might help reduce some
of the aliasing/big dots problems with clustered dots, while not
depending on isolated pixels printing well . . .

-tom

markc@Solbourne.COM (Mark Connell) (07/27/89)

In article <354@mit-amt.MEDIA.MIT.EDU>, klug@mit-amt.MEDIA.MIT.EDU (Michael Klug) writes:
> 
> I'm looking for routines that do graphics. 

I have a routine that will turn on a single pixel on a memory mapped
8-plane dumb frame buffer.  All you need to supply is the address of the 
pixel and the 8 bit value you want stored in the pixel.  Send $10,000 to me
at the address below and I will send it to you, complete with source code
in C (a computer language).

>    Thanks in advance. :-)

You're welcome. 

:-) :-)  :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-)

                                        Mark A. Connell
                                        Solbourne Computer, Inc.
                                        1900 Pike Road
                                        Longmont, Co	80501
                                        (303) 772-3400
                                        markc@Solbourne.COM
                                         ...!uunet!stan!markc

rwg@Solbourne.COM (Rick Gillespie) (07/28/89)

In article <1796@stan.Solbourne.COM> markc@Solbourne.COM (Mark Connell) writes:
>> I'm looking for routines that do graphics. 
>
>I have a routine that will turn on a single pixel on a memory mapped
>8-plane dumb frame buffer.  All you need to supply is the address of the 
>pixel and the 8 bit value you want stored in the pixel.  Send $10,000 to me
>at the address below and I will send it to you, complete with source code
>in C (a computer language).
>:-) :-)  :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-) :-)

Of course, what Mark has neglected is a routine to initialize the
lookup table. So, if you want a truly useful set of graphics routines
(set a pixel, and set a lookup table entry) then send me your
first born male child. For twins I'll throw in a routine to set
a pixel in a 24-plane system.

:-)

NU113738@NDSUVM1.BITNET (07/28/89)

Any preferable Language, Computer system, graphics system?

It would help to be a little more specific.  Also, what type of routines?
General line, ellipse, fill algorithms or programming routines for
monitor/graphics card autodetect and initialize?

I may be able to help, but please, give me some more info.

Jeff Bakke
NU113738@NDSUVM1.BITNET