heikkila97.ps

OPENCV系列的

			/bwidth  exch def
			/bpside  exch def
			/bstring exch def
			/onbits 0 def  /offbits 0 def
			freq sangle landscape {90 add} if 
				{/ypoint exch def
				 /xpoint exch def
				 /xindex xpoint 1 add 2 div bpside mul cvi def
				 /yindex ypoint 1 add 2 div bpside mul cvi def
				 bstring yindex bwidth mul xindex 8 idiv add get
				 1 7 xindex 8 mod sub bitshift and 0 ne fMNegative {not} if
				 {/onbits  onbits  1 add def 1}
				 {/offbits offbits 1 add def 0}
				 ifelse
				}
				setscreen
			offbits offbits onbits add div fMNegative {1.0 exch sub} if
			/FrameCurGray exch def
		} ifelse
	} { % Level 2 version
		pop pop
		dup patCache exch known {
			patCache exch get
		} { % not in cache
			dup
			patDict /bstring 3 -1 roll put
			patDict 
			9 PatFreq screenIndex get div dup matrix scale
%			9 orgfreq 
%				organgle sin abs organgle cos abs add div
%				dup 16 div round dup 0 le {pop 1} if  % Unix pattern size
%			    dup  9 div round dup 0 le {pop 1} if  % Mac larger (WYSIWYG) size
%					div div dup matrix scale % This gives Unix pattern size.
			makepattern
			dup 
			patCache 4 -1 roll 3 -1 roll put
		} ifelse
		/FrameCurGray 0 def
		/FrameCurPat exch def
	} ifelse
	/graymode false def
	combineColor
} bind def

/setGrayScaleMode {
	graymode not {
		/graymode true def
		fMLevel1 {
			setCurrentScreen
		} if
	} if
	/FrameCurGray exch def
	combineColor
} bind def

/normalize {
	transform round exch round exch itransform
	} bind def

/dnormalize {
	dtransform round exch round exch idtransform
	} bind def

/lnormalize { % line widths are always odd so that arrow heads work
	0 dtransform exch cvi 2 idiv 2 mul 1 add exch idtransform pop
	} bind def

/H { % THICK
	lnormalize setlinewidth
	} bind def

/Z {
	setlinecap
	} bind def
	
% This is used to fill or stroke white behind a Level 2 pattern
/PFill {
	graymode fMLevel1 or not {
		gsave 1 setgray eofill grestore
	} if
} bind def
/PStroke {
	graymode fMLevel1 or not {
		gsave 1 setgray stroke grestore
	} if
	stroke
} bind def

/X { % TEXTURE
	fillvals exch get
	dup type /stringtype eq
	{8 1 setPatternMode} % Silly to pass parameters here
	{setGrayScaleMode}
	ifelse
	} bind def

/V { % FILL
	PFill gsave eofill grestore
	} bind def

/Vclip {
	clip
	} bind def

/Vstrk {
	currentlinewidth exch setlinewidth PStroke setlinewidth
	} bind def

/N { % PEN
	PStroke
	} bind def

/Nclip {
	strokepath clip newpath
	} bind def

/Nstrk {
	currentlinewidth exch setlinewidth PStroke setlinewidth
	} bind def

/M {newpath moveto} bind def
/E {lineto} bind def
/D {curveto} bind def
/O {closepath} bind def

/L { % POLYLINE
 	/n exch def
	newpath
	normalize
	moveto 
	2 1 n {pop normalize lineto} for
	} bind def

/Y { % POLYGON !!!
	L % POLYLINE
	closepath
	} bind def

/R { % RECT x1 y1 x2 y2
	/y2 exch def
	/x2 exch def
	/y1 exch def
	/x1 exch def
	x1 y1
	x2 y1
	x2 y2
	x1 y2
	4 Y % POLYGON
	} bind def

/rarc % Leaves all sorts of junk on the operand stack for caller to clear off
	{rad % arcto might fail if we're scaled way down
	 arcto
	} bind def

/RR { % ROUNDRECT x1 y1 x2 y2 r
	/rad exch def
	normalize
	/y2 exch def
	/x2 exch def
	normalize
	/y1 exch def
	/x1 exch def
	mark
	newpath
	{
	x1 y1 rad add moveto
	x1 y2 x2 y2 rarc
	x2 y2 x2 y1 rarc
	x2 y1 x1 y1 rarc
	x1 y1 x1 y2 rarc
	closepath
	} stopped {x1 y1 x2 y2 R} if % in case rarc failed for degenerate arcs
	cleartomark
	} bind def

/RRR { % ROUNDRECT ROTATED xs ys x1 y1 x2 y2 x3 y3 x4 y4 r
	/rad exch def
	normalize /y4 exch def /x4 exch def
	normalize /y3 exch def /x3 exch def
	normalize /y2 exch def /x2 exch def
	normalize /y1 exch def /x1 exch def
	newpath
	normalize moveto % eats xs ys
	mark
	{
	x2 y2 x3 y3 rarc
	x3 y3 x4 y4 rarc
	x4 y4 x1 y1 rarc
	x1 y1 x2 y2 rarc
	closepath
	} stopped
	 {x1 y1 x2 y2 x3 y3 x4 y4 newpath moveto lineto lineto lineto closepath} if
	cleartomark
	} bind def

/C { % CLIP
	grestore
	gsave
	R % RECT
	clip
	setCurrentScreen
} bind def

/CP { % CLIPPOLY p1x p1y p2x p2y ... n 
	grestore
	gsave
	Y % POLYGON
	clip
	setCurrentScreen
} bind def

/F { % FONT
	FMfonts exch get
	FMpointsize scalefont
	setfont
	} bind def

/Q { % POINTSIZE (& font)
	/FMpointsize exch def
	F % could be slightly optimized here
	} bind def

/T { % TEXT <string> <x> <y>
	moveto show
	} bind def

% Callers of RF (rotate/flip) must gsave (or save) first; (g)restore when done
/RF { % <flip> <theta>
	rotate
	0 ne {-1 1 scale} if
	} bind def

/TF { % TEXTFLIPROTATE <string> <flip> <theta> <x> <y>
	gsave
	moveto 
	RF
	show
	grestore
	} bind def

/P { % PADTEXT <pad> <string> <x> <y>
	moveto
	0 32 3 2 roll widthshow
	} bind def

/PF { % PADTEXTFLIPROTATE <pad> <string> <flip> <theta> <x> <y>
	gsave
	moveto 
	RF
	0 32 3 2 roll widthshow
	grestore
	} bind def

/S { % SPREADTEXT <spread> <string> <x> <y>
	moveto
	0 exch ashow
	} bind def

/SF { % SPREADTEXTFLIPROTATE <spread> <string> <flip> <theta> <x> <y>
	gsave
	moveto
	RF
	0 exch ashow
	grestore
	} bind def

/B { % PADSPREADTEXT <pad> <spread> <string> <x> <y>
	moveto
	0 32 4 2 roll 0 exch awidthshow
	} bind def

/BF { % PADSPREADTEXTFLIPROTATE <pad> <spread> <string> <flip> <theta> <x> <y>
	gsave
	moveto
	RF
	0 32 4 2 roll 0 exch awidthshow
	grestore
	} bind def

/G { % ARCFILL theta1 theta2 width height x y
	gsave
	newpath
	normalize translate 0.0 0.0 moveto % eats x y
	dnormalize scale % eats width height
	0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
	closepath 
	PFill fill
	grestore
	} bind def

/Gstrk {
	savematrix
    newpath
    2 index 2 div add exch 3 index 2 div sub exch % theta1 theta2 width height x y
    normalize 2 index 2 div sub exch 3 index 2 div add exch % theta1 theta2 width height x y
    translate
    scale % eats width height
    0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
    restorematrix
    currentlinewidth exch setlinewidth PStroke setlinewidth
    } bind def

/Gclip { % ARCFILL theta1 theta2 width height x y swid
	newpath
	savematrix
	normalize translate 0.0 0.0 moveto % eats x y
	dnormalize scale % eats width height
	0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
	closepath 
	clip newpath
	restorematrix
	} bind def

/GG { % ARCFILL ROTATED theta1 theta2 width height angle x y
	gsave
	newpath
	normalize translate 0.0 0.0 moveto % eats x y
	rotate % eats angle
	dnormalize scale % eats width height
	0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
	closepath
	PFill
	fill
	grestore
	} bind def

/GGclip { % ARCFILL ROTATED theta1 theta2 width height angle x y
	savematrix
	newpath
    normalize translate 0.0 0.0 moveto % eats x y
    rotate % eats angle
    dnormalize scale % eats width height
    0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
    closepath
	clip newpath
	restorematrix
	} bind def

/GGstrk { % ARCFILL ROTATED swid theta1 theta2 width height angle x y
	savematrix
    newpath
    normalize translate 0.0 0.0 moveto % eats x y
    rotate % eats angle
    dnormalize scale % eats width height
    0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
    closepath 
	restorematrix
    currentlinewidth exch setlinewidth PStroke setlinewidth
	} bind def

/A { % ARCPEN theta1 theta2 width height x y
	gsave
	savematrix
	newpath
	2 index 2 div add exch 3 index 2 div sub exch % theta1 theta2 width height x y
	normalize 2 index 2 div sub exch 3 index 2 div add exch % theta1 theta2 width height x y
	translate 
	scale % eats width height
	0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
	restorematrix
	PStroke
	grestore
	} bind def

/Aclip {
	newpath
	savematrix
	normalize translate 0.0 0.0 moveto % eats x y
	dnormalize scale % eats width height
	0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
	closepath 
	strokepath clip newpath
	restorematrix
} bind def

/Astrk {
	Gstrk
} bind def

/AA { % ARCPEN ROTATED theta1 theta2 width height angle x y
	gsave
	savematrix
	newpath
	% theta1 theta2 width height angle x y
	3 index 2 div add exch 4 index 2 div sub exch 
	% theta1 theta2 width height angle x y
	normalize 3 index 2 div sub exch 4 index 2 div add exch
	translate % eats x y
	rotate % eats angle
	scale % eats width height
	0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
	restorematrix
	PStroke
	grestore
	} bind def

/AAclip {
	savematrix
	newpath
    normalize translate 0.0 0.0 moveto % eats x y
    rotate % eats angle
    dnormalize scale % eats width height
    0.0 0.0 1.0 5 3 roll arc % eats theta1 theta2
    closepath
	strokepath clip newpath
	restorematrix
} bind def

/AAstrk {
	GGstrk
} bind def

/BEGINPRINTCODE { % -x -y width height
	/FMdicttop countdictstack 1 add def % high-water mark of dict stack
	/FMoptop count 7 sub def % tricky! 7 params on stack, plus "/FMoptop"
	/FMsaveobject save def
	userdict begin % insulate user from FrameDict; not in /FMdicttop count
	/showpage {} def % this def is in userdict
	FMNORMALIZEGRAPHICS % in case we're in a strange state
	3 index neg 3 index neg translate
	} bind def

/ENDPRINTCODE {
	count -1 FMoptop {pop pop} for % clear user junk from operand stack
	countdictstack -1 FMdicttop {pop end} for % ditto for dict stack
	FMsaveobject restore % this is now safe, unless user very malicious
	} bind def

/gn { % get a number in a funny encoding scheme
	0 % result on stack
	{	46 mul % shift old digits
		cf read pop % get next character
		32 sub % zero is the space character
		dup 46 lt {exit} if % quit if we're the last digit
		46 sub add % add in this digit and loop around for next
		} loop
	add % result on stack
	} bind def

/cfs { % create a string of length "sl" filled with "val"s
	/str sl string def % create string as "str"
	0 1 sl 1 sub {str exch val put} for % fill array
	str def % define real array name, too; name is on stack from caller
	} bind def

/ic [ % "case" stmt list of procedures that the image commands should call
	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0223
	0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0223
	0
	{0 hx} {1 hx} {2 hx} {3 hx} {4 hx} {5 hx} {6 hx} {7 hx} {8 hx} {9 hx}
	{10 hx} {11 hx} {12 hx} {13 hx} {14 hx} {15 hx} {16 hx} {17 hx} {18 hx}
	{19 hx} {gn hx} {0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12}
	{13} {14} {15} {16} {17} {18} {19} {gn} {0 wh} {1 wh} {2 wh} {3 wh}
	{4 wh} {5 wh} {6 wh} {7 wh} {8 wh} {9 wh} {10 wh} {11 wh} {12 wh}