ray_density_tensor.eps

这是一个TOMO TO GMT的源码

	
	% is this not 1 or 8 bit?
	{
		% Call the original proc if the image is at a weird bit depth. This will display a composite if we're separating, but too bad.
		/_colorimage load null ne
		{
			% call the original (they probably punt if we're separating)
			_colorimage
		}
		{
			% pop off the parameters and return
			Adobe_ColorImage_AI6_Vars /sourcecount get
			7 add { pop } repeat
		} ifelse
	}
	{
		% Call the saved colorimage operator if this an rgb, we're printing a composite or we're separating
		% an image to a custom plate. The last case assumes that the separation procs surrounding us
		% take care of punching out
		dup 3 eq
		TestPlateIndex
		dup -1 eq exch 5 eq or or
		{
			% Call the colorimage emulator if we're printing to a level 1 device
			/_colorimage load null eq
			{
				ColorImageCompositeEmulator
			}
			{
				% call image if this is a grayscale so that Quark doesn't die on custom plates
				dup 1 eq
				{
					pop pop image
				}
				{
					% draw to the null device if we're on a custom plate
					Adobe_ColorImage_AI6_Vars /plateindex get 5 eq
					{
						gsave
						
						% stolen from PhotoShop
						0 _currenttransfer exec
						1 _currenttransfer exec
						eq
						{ 0 _currenttransfer exec 0.5 lt }
						{ 0 _currenttransfer exec 1 _currenttransfer exec gt } ifelse
						
						% push the appropriate transfer proc (first case is negative
						% second case is positive) and call settransfer
						{ { pop 0 } } { { pop 1 } } ifelse
						systemdict /settransfer get exec
					} if
					
					_colorimage
					
					% restore from the null device if necessary
					Adobe_ColorImage_AI6_Vars /plateindex get 5 eq
					{
						grestore
					} if
				} ifelse
			} ifelse
		}
		{
			% Are we separating a grayscale image?
			dup 1 eq
			{
				% let the surrounding separation procset handle the separation
				pop pop
				image
			}
			{
				% pop channelcount and multiplesources since they're not used by the image operator
				pop pop

				% Prepare to call the image operator with a cover proc
				Adobe_ColorImage_AI6_Vars begin
					% save off the source procs for our cover proc
					% width height bitsperpixel matrix firstsource...lastsource
					sourcecount -1 0
					{			
						% width height bitsperpixel matrix firstsource...lastsource index
						exch sourcearray 3 1 roll put
					} for

					/SeparateCMYKImageProc load
				end

				% bypass the separation procset since some applications don't handle chunky and the
				% old separator doesn't handle colorimage
				systemdict /image get exec
			} ifelse
		} ifelse
	} ifelse
} def

% ------------------------------------------------------
% --XI--
% ------------------------------------------------------

/XI
{
	Adobe_ColorImage_AI6_Vars begin
		gsave
		/XIMask exch 0 ne def
		/XIBinary exch 0 ne def
		pop
		pop
		/XIChannelCount exch def
		/XIBitsPerPixel exch def
		/XIImageHeight exch def
		/XIImageWidth exch def
		pop pop pop pop
		/XIImageMatrix exch def
		
		XIBitsPerPixel 1 eq
		{
			XIImageWidth 8 div ceiling cvi
		}
		{
			XIImageWidth XIChannelCount mul
		} ifelse
		/XIBuffer exch string def
		
		XIBinary
		{
			/XIDataProc { currentfile XIBuffer readstring pop } def
			% skip the %BeginBinary comment
			currentfile 128 string readline pop pop
		}
		{
			/XIDataProc { currentfile XIBuffer readhexstring pop } def
		} ifelse
		
		0 0 moveto
		XIImageMatrix concat
		XIImageWidth XIImageHeight scale
		
		XIMask
		{
			XIImageWidth XIImageHeight
			false
			[ XIImageWidth 0 0 XIImageHeight neg 0 0 ]
			/XIDataProc load
			
			% synch the PostScript fill with Illustrator's notion of the current fill
			/_lp /null ddef
			_fc
			/_lp /imagemask ddef
			
			imagemask
		}
		{
			XIImageWidth XIImageHeight
			XIBitsPerPixel
			[ XIImageWidth 0 0 XIImageHeight neg 0 0 ]
			/XIDataProc load
			
			% call image if passed grayscale or bitmap data. Some applications
			% die if colorimage is called with gray data.
			XIChannelCount 1 eq
			{
				% Some applications refuse to separate a grayscale image to the black plate if
				% the currentgray is white. Hack around.
				
				gsave
				0 setgray
				
				image
				
				grestore
			}
			{
				false
				XIChannelCount
				colorimage
			} ifelse
		} ifelse

		grestore
	end
} def
	
end

%%EndProcSet

% ------------------------------------------------------
%%BeginResource: procset Adobe_Illustrator_AI5 1.1 0
%%Title: (Adobe Illustrator (R) Version 5.0 Full Prolog)
%%Version: 1.1 0
%%CreationDate: (3/7/1994) ()
%%Copyright: ((C) 1987-1996 Adobe Systems Incorporated All Rights Reserved)
% ------------------------------------------------------

currentpacking true setpacking

% 71 vars, but leave slack of 10 entries for custom Postscript fragments
userdict /Adobe_Illustrator_AI5_vars 81 dict dup begin
put

% paint operands
/_eo false def
/_lp /none def
/_pf
{
} def	% paint fill
/_ps
{
} def	% paint stroke
/_psf
{
} def	% paint string fill
/_pss
{
} def	% paint string stroke
/_pjsf
{
} def	% paint justified string fill
/_pjss
{
} def	% paint justified string stroke
/_pola 0 def
/_doClip 0 def

% paint operators
/cf currentflat def	% - cf flatness

% typography operands
/_tm matrix def
/_renderStart
[
/e0 /r0 /a0 /o0 /e1 /r1 /a1 /i0
] def
/_renderEnd
[
null null null null /i1 /i1 /i1 /i1
] def
/_render -1 def
/_rise 0 def
/_ax 0 def	% x character spacing	(_ax, _ay, _cx, _cy follows awidthshow naming convention)
/_ay 0 def	% y character spacing
/_cx 0 def	% x word spacing
/_cy 0 def	% y word spacing
/_leading
[
0 0
] def
/_ctm matrix def
/_mtx matrix def
/_sp 16#020 def
/_hyphen (-) def
/_fScl 0 def
/_cnt 0 def
/_hs 1 def
/_nativeEncoding 0 def
/_useNativeEncoding 0 def
/_tempEncode 0 def
/_pntr 0 def
/_tDict 2 dict def
/_wv 0 def

% typography operators
/Tx
{
} def
/Tj
{
} def

% compound path operators
/CRender
{
} def

% printing
/_AI3_savepage
{
} def

% color operands
/_gf null def
/_cf 4 array def
/_if null def
/_of false def
/_fc
{
} def
/_gs null def
/_cs 4 array def
/_is null def
/_os false def
/_sc
{
} def

% pattern operands
/_pd 1 dict def
/_ed 15 dict def
/_pm matrix def
/_fm null def
/_fd null def
/_fdd null def
/_sm null def
/_sd null def
/_sdd null def
/_i null def

% discard variables (12 total)

/discardSave null def	% holds save used in discard loop
/buffer 256 string def	% line buffer string : assume 256 chars/line
/beginString null def	% begin delimiter
/endString null def	% end delimiter
/endStringLength null def	% holds buffer size for reading by byte technique
/layerCnt 1 def	% internal variables for discard loop
/layerCount 1 def
/perCent (%) 0 get def
/perCentSeen? false def
/newBuff null def
/newBuffButFirst null def
/newBuffLast null def

% variable for doing clipping without rendering
/clipForward? false def

% end the vars dictionary
end
% =========================================


userdict /Adobe_Illustrator_AI5 known not {
	userdict /Adobe_Illustrator_AI5 91 dict put
} if

userdict /Adobe_Illustrator_AI5 get begin


% initialization
/initialize	% - initialize -
{
	% pushing main on the stack
	Adobe_Illustrator_AI5 dup begin

	% push the vars dictionary
	Adobe_Illustrator_AI5_vars begin

	% at this point the main and vars dictionaries
	% are in the state we wish them to be
	% on exit from the initialize call

	% bind the procedures in the discard dictionary
	discardDict
	{
		bind pop pop
	} forall

	% begin the nc dictionary
	dup /nc get begin

	% bind the procs in main
	{
		% added a test for type = operatortype so procedures like Ln can be defined as an alias for 'pop
		dup xcheck 1 index type /operatortype ne and
		{
			bind
		} if
		pop pop
	} forall

	% turn off 'nc
	end

	newpath

	% on exit we have main and vars on top of dict stack
} def

/terminate	% - terminate -
{
	end
	end
} def

% definition operators
/_	% - _ null
null def
/ddef	% key value ddef -
{
	Adobe_Illustrator_AI5_vars 3 1 roll put
} def
/xput	% key value literal xput -
{
	dup load dup length exch maxlength eq
	{
		dup dup load dup
		length 2 mul dict copy def
	} if
	load begin
	def
	end
} def
/npop	% integer npop -
{
	{
		pop
	} repeat
} def

% marking operators
/sw	% ax ay string sw x y
{
	dup length exch stringwidth
	exch 5 -1 roll 3 index mul add
	4 1 roll 3 1 roll mul add
} def
/swj	% cx cy fillchar ax ay string swj x y
{
	dup 4 1 roll
	dup length exch stringwidth
	exch 5 -1 roll 3 index mul add
	4 1 roll 3 1 roll mul add
	6 2 roll /_cnt 0 ddef
	{
		1 index eq
		{
			/_cnt _cnt 1 add ddef
		} if
	} forall
	pop
	exch _cnt mul exch _cnt mul 2 index add 4 1 roll 2 index add 4 1 roll pop pop
} def
/ss	% ax ay string matrix ss -
{
	4 1 roll
	{
		% matrix ax ay char 0 0 {proc} -
		2 npop
		(0) exch 2 copy 0 exch put pop
		gsave
		false charpath currentpoint
		4 index setmatrix
		stroke
		grestore
		moveto
		2 copy rmoveto
	} exch cshow
	3 npop
} def
/jss	% cx cy fillchar ax ay string matrix jss -
{
	4 1 roll
	{
		% cx cy fillchar matrix ax ay char 0 0 {proc} -   
		2 npop
		(0) exch 2 copy 0 exch put
		gsave
		_sp eq
		{
			exch 6 index 6 index 6 index 5 -1 roll widthshow
			currentpoint
		}
		{
			false charpath currentpoint
			4 index setmatrix stroke
		} ifelse
		grestore
		moveto
		2 copy rmoveto
	} exch cshow
	6 npop
} def

% path operators
/sp	% ax ay string sp -
{
	{
		2 npop (0) exch
		2 copy 0 exch put pop
		false charpath
		2 copy rmoveto
	} exch cshow
	2 npop
} def
/jsp	% cx cy fillchar ax ay string jsp -
{
	{
		% cx cy fillchar ax ay char 0 0 {proc} -
		2 npop
		(0) exch 2 copy 0 exch put
		_sp eq
		{
			exch 5 index 5 index 5 index 5 -1 roll widthshow
		}
		{
			false charpath
		} ifelse
		2 copy rmoveto
	} exch cshow
	5 npop
} def

% path construction operators
/pl	% x y pl x y
{
	transform
	0.25 sub round 0.25 add exch
	0.25 sub round 0.25 add exch
	itransform
} def

/setstrokeadjust where
{
	pop true setstrokeadjust
	/c	% x1 y1 x2 y2 x3 y3 c -
	{
		curveto
	} def
	/C
	/c load def
	/v	% x2 y2 x3 y3 v -
	{
		currentpoint 6 2 roll curveto
	} def
	/V
	/v load def
	/y	% x1 y1 x2 y2 y -
	{
		2 copy curveto
	} def
	/Y
	/y load def
	/l	% x y l -
	{
		lineto
	} def
	/L
	/l load def
	/m	% x y m -
	{
		moveto
	} def
}
{
	% else
	/c
	{
		pl curveto
	} def
	/C
	/c load def
	/v
	{
		currentpoint 6 2 roll pl curveto
	} def
	/V
	/v load def
	/y
	{
		pl 2 copy curveto
	} def
	/Y
	/y load def
	/l
	{
		pl lineto
	} def
	/L
	/l load def
	/m
	{
		pl moveto
	} def
} ifelse

% graphic state operators
/d	% array phase d -
{
	setdash
} def
/cf
{
} def	% - cf flatness
/i	% flatness i -
{
	dup 0 eq
	{
		pop cf
	} if
	setflat
} def
/j	% linejoin j -
{
	setlinejoin
} def
/J	% linecap J -
{
	setlinecap
} def
/M	% miterlimit M -
{
	setmiterlimit
} def
/w	% linewidth w -
{
	setlinewidth
} def

% path painting operators
/XR	% flag XR -
{
	0 ne
	/_eo exch ddef
} def
/H	% - H -
{
} def
/h	% - h -
{
	closepath
} def
/N	% - N -
{
	_pola 0 eq
	{
		_doClip 1 eq
		{
			_eo {eoclip} {clip} ifelse /_doClip 0 ddef
		} if
		newpath
	}
	{
		/CRender
		{
			N
		} ddef
	} ifelse
} def
/n	% - n -
{
	N
} def
/F	% - F -
{
	_pola 0 eq
	{
		_doClip 1 eq
		{
			gsave _pf grestore _eo {eoclip} {clip} ifelse newpath /_lp /none ddef _fc
			/_doClip 0 ddef
		}
		{
			_pf
		} ifelse
	}
	{
		/CRender
		{