ray_density_tensor.eps

这是一个TOMO TO GMT的源码

		_renderEnd _render get dup null ne
		{
			load exec
		}
		{
			pop
		} ifelse
	} ifelse
	/_render -1 ddef
} def


% Attributes
/Ta	% set alignment					% alignment Ta -
{
	pop
} def

/Tf	% set font name and size		% fontname size Tf -
{
	dup 1000 div /_fScl exch ddef
% was  (bh 11/23/93)
% 	exch findfont exch scalefont setfont
%
	selectfont
} def

/Tl	% set leading					% leading paragraphLeading Tl -
{
	pop
	0 exch _leading astore pop
} def

/Tt	% set user tracking				% userTracking Tt -
{
	pop
} def

/TW	% set word spacing				% minSpace optSpace maxSpace TW -
{
	3 npop
} def

/Tw	% set computed word spacing		% wordSpace Tw
{
	/_cx exch ddef
} def

/TC	% set character spacing			% minSpace optSpace maxSpace TC -
{
	3 npop
} def

/Tc	% set computed char spacing 	% charSpace Tc -
{
	/_ax exch ddef
} def

/Ts	% set super/subscripting (rise)	% rise Ts -
{
	/_rise exch ddef
	currentpoint
	iTm
	moveto
} def

/Ti	% set indentation				% firstStartIndent otherStartIndent stopIndent Ti -
{
	3 npop
} def

/Tz	% set horizontal scaling		% scalePercent Tz -
{
	100 div /_hs exch ddef
	iTm
} def

/TA	% set pairwise kerning			% autoKern TA -
%	autoKern = 0 -> no pair kerning
%			 = 1 -> automatic pair kerning
{
	pop
} def

/Tq	% set hanging quotes			% hangingQuotes Tq -
%	hangingQuotes 	= 0 -> no hanging quotes
%			 		= 1 -> hanging quotes
{
	pop
} def

/Th	% set hyphenation				% hyphenate? limitLines? minLead minTail maxLines Th -
% 	hyphenate?	= 0 -> don't hyphenate
%				= 1 -> do hyphenate
% 	limitLines? = 0 -> no limit
%				= 1 -> limit consecutive hyphenated lines
%	minLead		Closest hyphen to beginning of word (0..n)
% 	minTail		Closest hyphen to end of word (0..n)
% 	maxLines	Maximum number of consecutive hyphenated lines (1..n)
{
	pop pop pop pop pop
} def


% Text Bodies
/TX
{
	pop
} def

% /Tx	% non-justified text			% textString Tx -
% /Tj	% justified text				% textString Tj -

/Tk	% kern							% autoKern kernValue Tk -
%  	autoKern = 0 -> manual kern, = 1 -> auto kern
%	kernValue = kern value in em/1000 space
{
	exch pop _fScl mul neg 0 rmoveto
} def
/TK	% non-printing kern				% autoKern kernValue TK -
{
	2 npop
} def

/T*	% carriage return & line feed	% - T* -
{
	_leading aload pop neg Td
} def

/T*-	% carriage return & negative line feed	% - T*- -
{
	_leading aload pop Td
} def

/T-	% print a discretionary hyphen	% - T- -
{
	% backup the pen position by the letterspacing so that
	% full-justified, auto-hyphenated lines display properly
	% [John Farmer 11/18/95]
	_ax neg 0 rmoveto
	_hyphen Tx
} def

/T+	% discretionary hyphen hyphen	% - T+ -
{
} def

/TR	% reset pattern matrix 			% a b c d tx ty TR -
{
	_ctm currentmatrix pop
	_tm astore pop
	iTm 0 0 moveto
} def

/TS	% special chars					% textString justified TS -
{
	currentfont 3 1 roll
	/_Symbol_ _fScl 1000 mul selectfont
	
	0 eq
	{
		Tx
	}
	{
		Tj
	} ifelse
	setfont
} def

% Tab extensions for 5.5 (Glenn Reid 1/26/94)

/Xb % begin tab definitions			% <unused> tabCount Xb -
{
	pop pop
} def
/Tb /Xb load def

/Xe % one tab stop					% leader(char) decimal(char) type(int) distance Xe -
{
	pop pop pop pop
} def
/Te /Xe load def

/XB % end tab definitions			% - XB -
{
} def
/TB /XB load def

currentdict readonly pop
end
setpacking

%%EndResource

% ------------------------------------------------------
%%BeginProcSet: Adobe_ColorImage_AI6 1.0 0
% ColorImage Emulation and Separation Code for Grayscale, RGB and CMYK images
% Version 1.0 12/25/95
% Copyright (C) 1995-96
% Adobe Systems Incorporated
% All Rights Reserved
% ------------------------------------------------------

userdict /Adobe_ColorImage_AI6 known not
{
	userdict /Adobe_ColorImage_AI6 17 dict put 
} if
userdict /Adobe_ColorImage_AI6 get begin

% ------------------------------------------------------
% Routine Overview
% 
%	String Iterators
%		WalkRGBString (given a single source string, convert each pixel to cmyk and call a proc)
%		WalkCMYKString (given a single source string, get the components and call a proc)
% 
%	Level1 Emulator Routines
%		StuffRGBIntoGrayString
%		RGBToGrayImageProc
%		StuffCMYKIntoGrayString 
%		CMYKToGrayImageProc 
%		ColorImageCompositeEmulator 
% 
%	ColorImage CMYK Separation Hacks (For [Applications] that only support planar images)
%		CMYKToSeparatedCMYKImageProc
% 
%	ColorImage and Utility Routines.
%		FourEqual
%		TestPlateIndex
%		colorimage
% 
% ------------------------------------------------------	

/initialize
{ 
	Adobe_ColorImage_AI6 begin
	Adobe_ColorImage_AI6
	{
		dup type /arraytype eq
		{
			dup xcheck
			{
				bind
			} if
		} if
		pop pop
	} forall
} def

/terminate { end } def

currentdict /Adobe_ColorImage_AI6_Vars known not
{
	/Adobe_ColorImage_AI6_Vars 14 dict def
} if

Adobe_ColorImage_AI6_Vars begin
	/channelcount 0 def
	/sourcecount 0 def
	/sourcearray 4 array def
	/plateindex -1 def
	/XIMask 0 def
	/XIBinary 0 def
	/XIChannelCount 0 def
	/XIBitsPerPixel 0 def
	/XIImageHeight 0 def
	/XIImageWidth 0 def
	/XIImageMatrix null def
	/XIBuffer null def
	/XIDataProc null def
end

/WalkRGBString null def
/WalkCMYKString null def

/StuffRGBIntoGrayString null def
/RGBToGrayImageProc null def
/StuffCMYKIntoGrayString null def
/CMYKToGrayImageProc null def
/ColorImageCompositeEmulator null def

/SeparateCMYKImageProc null def

/FourEqual null def
/TestPlateIndex null def

% define _colorimage if it doesn't already exist
currentdict /_colorimage known not
{
	/colorimage where
	{
		% sourcedictionary (systemdict or a separation proc redefinition)
		/colorimage get /_colorimage exch def
	}
	{
		/_colorimage null def
	} ifelse
} if

/_currenttransfer systemdict /currenttransfer get def

/colorimage null def
/XI null def

% ------------------------------------------------------
% rgb proc out --WalkRGBString--
% ------------------------------------------------------

/WalkRGBString
{
	% rgb proc out
	0 3 index

	% rgb proc out outindex rgb
	dup length 1 sub 0 3 3 -1 roll
	{
		% rgb proc out outindex rgb index
		3 getinterval { } forall

		% call the stuff proc
		% rgb proc out outindex r g b
		5 index exec

		% push rgb for the next loop iteration
		% rgb proc out outindex
		3 index
		% rgb proc out outindex rgb
	} for
	
	% clean up the stack
	% rgb proc out outindex rgb
	 5 { pop } repeat

} def

% ------------------------------------------------------
% cmyk proc gray --WalkCMYKString--
% ------------------------------------------------------

/WalkCMYKString
{
	% cmyk proc gray
	0 3 index

	% cmyk proc gray grayindex cmyk
	dup length 1 sub 0 4 3 -1 roll
	{
		% cmyk proc gray grayindex cmyk index
		4 getinterval { } forall
		
		% cmyk proc gray grayindex c m y k
		6 index exec
		
		% cmyk proc gray grayindex
		3 index
		
		% cmyk proc gray grayindex cmyk
	} for
	
	% clean up the stack
	% cmyk proc gray grayindex cmyk
	5 { pop } repeat
	
} def

% ------------------------------------------------------
% gray grayindex r g b --StuffRGBIntoGrayString-- gray grayindex
% ------------------------------------------------------

/StuffRGBIntoGrayString
{
	% gray grayindex r g b
	.11 mul exch
	
	% gray grayindex r bk g
	.59 mul add exch
	
	% gray grayindex bkgk r
	.3 mul add
	
	% gray grayindex k
	cvi 3 copy put
	
	% gray grayindex k
	pop 1 add
} def

% ------------------------------------------------------
% --RGBToGrayImageProc-- string
% ------------------------------------------------------

/RGBToGrayImageProc
{	
	Adobe_ColorImage_AI6_Vars begin	
		% call the source proc to get the chunky rgb string
		sourcearray 0 get exec

		% make a grayscale string of the same pixel count (ouch, pull me out of this loop)
		% rgb
		dup length 3 idiv string

		% roll off a copy of the gray string
		% rgb gray
		dup 3 1 roll 
		
		% push the stuff proc that we want called by WalkRGBString
		% gray rgb gray
		/StuffRGBIntoGrayString load exch

		% call the rgb conversion iterator
		% gray rgb proc gray
		WalkRGBString

		% return the gray string
		% gray	
	end
} def

% ------------------------------------------------------
% gray grayindex c m y k --StuffCMYKIntoGrayString-- gray grayindex
% ------------------------------------------------------

/StuffCMYKIntoGrayString
{
	% gray grayindex c m y k
	exch .11 mul add
	
	% gray grayindex c m yk
	exch .59 mul add
	
	% gray grayindex c mkyk
	exch .3 mul add
	
	% pin k to 255
	% gray gray index k
	dup 255 gt { pop 255 } if
	
	% gray grayindex k
	255 exch sub cvi 3 copy put
	
	% gray grayindex k
	pop 1 add
} def

% ------------------------------------------------------
% --CMYKToGrayImageProc-- string
% ------------------------------------------------------

/CMYKToGrayImageProc
{	
	Adobe_ColorImage_AI6_Vars begin
		% call the source proc to get the chunky cmyk string
		sourcearray 0 get exec

		% make a grayscale string of the same pixel count (ouch, pull me out of this loop)
		% cmyk
		dup length 4 idiv string

		% roll off a copy of the gray string
		% cmyk gray
		dup 3 1 roll 
		
		% push the stuff proc that we want called by WalkCMYKString
		% gray cmyk gray
		/StuffCMYKIntoGrayString load exch

		% call the cmyk iterator
		% gray cmyk proc gray
		WalkCMYKString

		% return the gray string
		% gray
	end
} def

% ------------------------------------------------------
% width height bitsperpixel matrix firstsource...lastsource multiplesources channelcount --ColorImageCompositeEmulator--
% ------------------------------------------------------

/ColorImageCompositeEmulator
{
	% Channelcount is already saved in Adobe_ColorImage_AI6_Vars. Our data is always in chunky form so punt if someone
	% calls colorimage on a level 1 device with planar data.
	% channelcount and multiplesources are already saved in Adobe_ColorImage_AI6_Vars. The image operator isn't going to use them.
	pop true eq
	{
		% pop off the parameters and return
		Adobe_ColorImage_AI6_Vars /sourcecount get 5 add { pop } repeat
	}
	{
		Adobe_ColorImage_AI6_Vars /channelcount get 1 ne
		{
			Adobe_ColorImage_AI6_Vars begin
				% save off the original chunky source function
				sourcearray 0 3 -1 roll put
			
				% push the appropriate cover proc
				channelcount 3 eq 
				{ 
					/RGBToGrayImageProc 
				}
				{ 
					/CMYKToGrayImageProc
				} ifelse
				load
			end
		} if
		image
	} ifelse
} def

% ------------------------------------------------------
% --SeparateCMYKImageProc-- string
% ------------------------------------------------------

/SeparateCMYKImageProc
{	
	Adobe_ColorImage_AI6_Vars begin

		sourcecount 0 ne
		{
			% planar case: call the source proc for the current plate and return its result
			sourcearray plateindex get exec
		}
		{			
			% call the source proc to get the chunky cmyk string
			sourcearray 0 get exec
			
			% make a grayscale string of the same pixel count (ouch, pull me out of this loop)
			% cmyk
			dup length 4 idiv string
			
			% cmyk
			0 2 index
			
			% cmyk gray grayindex cmyk
			plateindex 4 2 index length 1 sub
			{
				% cmyk gray grayindex cmyk channelindex
				get 255 exch sub
				
				% cmyk gray grayindex grayvalue
				3 copy put pop 1 add
				
				% cmyk gray grayindex
				2 index
			} for

			% return the gray string
			% cmyk gray grayindex cmyk
			pop pop exch pop
		} ifelse
	end
} def
	
% ------------------------------------------------------
% s1 s2 s3 s4 c1 c2 c3 c4 --FourEqual--
% ------------------------------------------------------

/FourEqual
{
	% s1 s2 s3 s4 c1 c2 c3 c4
	4 index ne
	{
		pop pop pop false
	}
	{
		% s1 s2 s3 s4 c1 c2 c3
		4 index ne
		{
			pop pop false
		}
		{
			% s1 s2 s3 s4 c1 c2
			4 index ne
			{
				pop false
			}
			{
				% s1 s2 s3 s4 c1
				4 index eq
			} ifelse
		} ifelse
	} ifelse
} def

% ------------------------------------------------------
%  --TestPlateIndex-- plateindex
% ------------------------------------------------------

/TestPlateIndex
{
	Adobe_ColorImage_AI6_Vars begin
		% assume we're not separating
		/plateindex -1 def

		/setcmykcolor where
		{
			pop
			gsave
			1 0 0 0 setcmykcolor systemdict /currentgray get exec 1 exch sub
			0 1 0 0 setcmykcolor systemdict /currentgray get exec 1 exch sub
			0 0 1 0 setcmykcolor systemdict /currentgray get exec 1 exch sub
			0 0 0 1 setcmykcolor systemdict /currentgray get exec 1 exch sub
			grestore

			% cyan plate?
			1 0 0 0 FourEqual 
			{ 
				/plateindex 0 def
			}
			{
				% magenta plate?
				0 1 0 0 FourEqual
				{ 
					/plateindex 1 def
				}
				{
					% yellow plate?
					0 0 1 0 FourEqual
					{
						/plateindex 2 def
					}
					{
						% black plate
						0 0 0 1 FourEqual
						{ 
							/plateindex 3 def
						}
						{
							0 0 0 0 FourEqual
							{
								/plateindex 5 def
							} if
						} ifelse
					} ifelse
				} ifelse
			} ifelse
			pop pop pop pop
		} if
		plateindex
	end
} def

% ------------------------------------------------------
% width height bitsperpixel matrix firstsource...lastsource multiplesources channelcount --colorimage--
% ------------------------------------------------------

/colorimage
{
	Adobe_ColorImage_AI6_Vars begin
		/channelcount 1 index def
		/sourcecount 2 index 1 eq { channelcount 1 sub } { 0 } ifelse def

		% setup for following if statement
		4 sourcecount add index dup 
		8 eq exch 1 eq or not
	end