% Copyright (C) 2002 Aladdin Enterprises. All rights reserved.
%
% This software is provided AS-IS with no warranty, either express or
% implied.
%
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
%
% For more information about licensing, please refer to
% http://www.ghostscript.com/licensing/. For information on
% commercial licensing, go to http://www.artifex.com/licensing/ or
% contact Artifex Software, Inc., 101 Lucas Valley Road #110,
% San Rafael, CA 94903, U.S.A., +1(415)492-9861.
% $Id: gs_cspace.ps,v 1.6 2003/06/26 22:42:33 dan Exp $
% basic colorspace mechanism
%
% This new implementation of color spaces extends the color space
% formalism to all PostScript levels. Level specific features and
% operators continue to be accessible only in the appropriate level,
% but the colorspace concept and associated mechanisms are used
% throughout.
%
% The color space mechanism is built around two dictionaries:
%
% .cspace_util
% A dictionary in global VM that is accessible in userdict only
% during initialization. This dictionary is intended for various
% utility procedures that are used in implementing the individual
% color spaces.
%
% colorspacedict
% A dictionary of methods for each color space type. The keys
% in this dictionary are color space type names (e.g.: /DeviceGray,
% /Separation, etc.), and the values are dictionaries of methods.
% The set of methods is the same for each color space type, and
% provides a complete implementation for the corresponding color
% space type. This dictionary is in global VM.
%
% The information specific to a color space type is created in a file
% for that type or group of types (e.g.: gs_csdev.ps, gs_csindx.ps,
% etc.). These files will generally adhere to the template:
%
% .currentglobal true .setglobal
% <level-specific dictionary> begin
% ...
% .cspace_util begin
% colorspacedict
% /<color space type name>
% mark
% /cs_validate
% {
% ...
% }
% bind
% ...
% .dicttomark
% put
% end % .cspace_util
% end ... % level-specific dictionary
% .setglobal
%
% The methods associated with a color space are listed below (along with
% their stack handling), followed by descriptions.
%
% - cs_potential_indexed_base <bool>
%
% - cs_potential_pattern_base <bool>
%
% - cs_potential_alternate <bool>
%
% - cs_potential_icc_alternate <bool>
%
%
% <name | array> cs_get_ncomps <int>
%
% <name | array> cs_get_range <range_array>
%
% <name | array> cs_get_default_color <c1> ... <cn>
%
%
% <c1> ... <cn> <name | array> cs_get_currentgray <gray>
%
% <c1> ... <cn> <name | array> cs_get_currentrgb <red> <green> <blue>
%
% <c1> ... <cn> <name | array> cs_get_currentcmyk
% <cyan> <magenta> <yellow> <black>
%
%
% <name | array> cs_validate <name | array>
%
% <name1 | array1> cs_substitute <name1 | array1> <array2>
%
% <name1 | array1> <array2> cs_prepare <name1 | array1> <array2>
%
% <name | array> cs_install -
%
%
% <c1> ... <cn> <array> cs_verify_color <c1> ... <cn>
%
% <array> cs_complete_color -
%
%
% cs_potential_indexed_base, cs_potential_pattern_base,
% cs_potential_alternate, cs_potential_icc_alternate
% These are booleans rather than procedures. They indicate if the color
% space can be a base space of an Indexed color space (anything except
% Indexed and Pattern), a Pattern color space (anything except Pattern),
% the alternative color space of a Separation or DeviceN color space, or
% the alternative color space of an ICCBased color space. The two
% parameters are distinct only because of a Ghostscript-specific
% implementation problem; in principle, there is nothing special about
% ICCBased color spaces in this regard.
%
% cs_get_ncomps
% Return the number of color components for the color spaces. For Pattern
% color spaces, the value is -1 if there is no base space, or -(n + 1) if
% the base space has n components.
%
% cs_get_range
% Return the input Range array appropriate for this color space. This is
% defined for all color spaces, though it is of interest primarily for
% CIEBased and ICCBased color spaces. For Indexed color spaces this is
% [ 0 hival ], where hival is the maximum support index value. For all
% other non-CIEBased, non-ICCBased color spaces, the range is an array
% of ncomps elements, all of which are [ 0 1 ], where ncomps is the
% number of color space components.
%
% cs_get_default_color
% Generates the default color for the current color space. Under normal
% circumstances this is done internally. It is provided in PostScript
% only to support an optimization that doesn't change the current color
% space more often than necessary.
%
% cs_get_currentgray, cs_get_currentrgb, cs_get_currentcmyk
% These procedures are used to implement the currentgray, currentrgb,
% and currentcmyk operators (which are pseudo-operators in the current
% implementation).
%
% cs_validate
% Validate the operand color space. Because color spaces are extensively
% manipulated in PostScript in this implementation, error handling can
% become burdensome. To make the code somewhat simpler, it is useful to
% be able to validate a color space prior to manipulation, so as to
% ensure that errors are not discovered in awkward places.
%
% cs_substitute
% Substitute a device-independent color space for device specific color
% space. This applies directly to the device-specific color spaces
% (DeviceGray, DeviceRGB, DeviceCMYK), and indirectly when these color
% spaces are used as base/alternative color spaces. The mechanism for
% color substitution is included in all language levels, though it may
% only be accessed for Language Level 3.
%
% The substituted color space is the topmost of the operands pushed.
% this may or may not be the same as the original color space, which
% is immediately below it on the operand stack. If the two differ,
% the substituted space will always be in local VM (and will be
% writable).
%
% Substitution is applied recursively to the base/alternate color
% space of ICCBased, Indexed, Separation, DeviceN, or Pattern
% color spaces. Because Ghostscript currently requires that any
% base or alternative color space be the current color space when
% the enclosing color space is set, this substitution effectively
% occurs twice: once in the original color space, and once when the
% base/alternative color space is made the current color space.
% We retain the first substitution as we would eventually like to
% remove the restriction on making the base/alternative color space
% the current color space.
%
% cs_prepare
% Perform any operations required on the color space for installation.
% This method exists primarily to allow conversion of PostScript
% procedures to functions for CIEBased color spaces. Two operands are
% provided: the original and the substituted color space. If the two
% differ and the latter is writable, required modifications can
% be made "in place". Otherwise, a new instance of the second color
% space must be built.
%
% Currently, cs_prepare is not explicitly recursive. Because
% Ghostscript requires a base/alternate color space to be installed
% as the current color space prior to installing the enclosing color
% space, the cs_prepare method will implicitly be called recursively.
% The reason for not making this explicit is that color space
% preparation may involve a considerable amount of work, which could
% be avoided if, for example, an alternative color space will not
% be used because the enclosing Separation/DeviceN color space is
% supported in native mode by the process color model. We would
% eventually like to remove the need to prepare color spaces that
% will not be used.
%
% cs_install
% This method actually installs the color space in the graphic state.
% Only the substituted/prepared space (which may be the same as the
% original space) is passed as an operand; the original space is handled
% directly by the .setcolorspace operator.
%
% The provision of a separate method for this tasks reflects the
% historical implementation of color spaces in the Ghostscript
% interpreter. This implementation provides a unique operator for each
% color space type.
%
% cs_prepare_color
% Modify a set of color operands as required by a color space. This
% is used primarily to verify the color operands, as this is most
% conveniently done in PostScript.
%
% cs_complete_setcolor
% This method is invoked immediately after a (successful) invocation
% of setcolor. Ii is provided as a separate method for compatibility
% with Adobe implementations. These implementations invoke the lookup
% (Indexed) or tint procedure each time setcolor is invoked (only if
% the alternative color space is used in the case of the tint
% transform). Because Ghostscript may convert these procedures to
% functions (or pre-sample them), the procedures may not always be
% called when expected. There are applications that depend on this
% behavior (e.g.: Adobe PhotoShop 5+), so this method provides a way
% to emulate it.
%
% In principle, a cs_complete_setcolor procedure for an Indexed color
% space whose base space should invoke cs_complete_setcolor on its
% base space. Currently we don't do this, because it has not been
% shown to be necessary. It would be simple to add if it is every
% needed.
%
% All of these methods are procedures.
%
% For each of these methods, there is a procedure in .cspace_util with
% a dot ('.') prefix that will invoke the appropriate procedure for the
% operand array.
%
.currentglobal true .setglobal
userdict /.cspace_util 80 dict put
.cspace_util begin
%
% Colorspacedict is initially in .cspace_util; it is copied to level2dict
% in the Level 2 initialization code to retain compatibility with
% earlier implementations.
%
/colorspacedict 20 dict def
%
% <obj> make_array1 <array>
%
% procedure for conditionally converting a named color space to a
% 1-element array. Since names are always global, the array will be
% as well.
%
/make_array1
{
dup type /nametype eq
{ currentglobal true setglobal exch 1 array astore exch setglobal }
if
}
bind def
%
% <name|array> .get_cspace_type name
%
% Provide generic routine for retrieving the color space type.
%
/.get_cspace_type
{
dup type dup /arraytype eq exch /packedarraytype eq or
{ 0 get }
if
}
bind def
%
% <name|array> .get_method_dict <dict>
%
% Get the method dictionary for a specific color space. Note that the
% color space is left on the stack.
%
/.get_method_dict
{ //colorspacedict exch //.get_cspace_type exec get }
bind def
%
% <name|array> <proc_name> .get_method <name|array> <proc | bool>
%
% Get the named method for the operand color space.
%
/.get_method
{ exch //.get_method_dict exec exch get }
bind def
%
% <name_array> .cs_potential_indexed_base <bool>
% <name_array> .cs_potential_pattern_base <bool>
% <name_array> .cs_potential_alternate <bool>
% <name_array> .cs_potential_icc_alternate <bool>
% <name | array> .cs_get_ncomps <int>
% <name | array> .cs_get_range <range_array>
% <name | array> .cs_get_default_color <c1> ... <cn>
% <c1> ... <cn> <name | array> .cs_get_currentgray <gray>
% <c1> ... <cn> <name | array> .cs_get_currentrgb <r> <g> <b>
% <c1> ... <cn> <name | array> .cs_get_currentcmyk <c> <m> <y> <k>
% <name | array> .cs_validate <name | array>
% <name1 | array1> .cs_substitute <name1 | array1> <array2>
% <name1 | array1> <array2> .cs_prepare <name1 | array1> <array2>
% <name | array> .cs_install -
% <c1> ... <cn> <array> .cs_prepare_color <c1> ... <cn>
% <array> .cs_complete_setcolor -
%
% These procedures provide access to the corresponding methods of the
% operand color space.
%
/.cs_potential_indexed_base
{ /cs_potential_indexed_base //.get_method exec }
bind def
/.cs_potential_pattern_base
{ /cs_potential_pattern_base //.get_method exec }
bind def
/.cs_potential_alternate
{ /cs_potential_alternate //.get_method exec }
bind def
/.cs_potential_icc_alternate
{ /cs_potential_icc_alternate //.get_method exec }
bind def
/.cs_get_ncomps
{ dup /cs_get_ncomps //.get_method exec exec }
bind def
/.cs_get_range
{ dup /cs_get_range //.get_method exec exec }
bind def
/.cs_get_default_color
{ dup /cs_get_default_color //.get_method exec exec }
bind def
/.cs_get_currentgray
{ dup /cs_get_currentgray //.get_method exec exec }
bind def
/.cs_get_currentrgb
{ dup /cs_get_currentrgb //.get_method exec exec }
bind def
/.cs_get_currentcmyk
{ dup /cs_get_currentcmyk //.get_method exec exec }
bind def
/.cs_validate
{ dup /cs_validate //.get_method exec exec }
bind def
/.cs_substitute
{ dup /cs_substitute //.get_method exec exec }
bind def
/.cs_prepare
{ dup /cs_prepare //.get_method exec exec }
bind def
/.cs_install
{ dup /cs_install //.get_method exec exec }
bind def
/.cs_prepare_color
{ dup /cs_prepare_color //.get_method exec exec }
bind def
/.cs_complete_setcolor
{ dup /cs_complete_setcolor //.get_method exec exec }
bind def
%
% Make sure we have an interpreter color space before redefining
% setcolorspace. The interpreter internal code only sets the effective
% color space; the interpreters color spaces begins as a null object.
%
% NB: This should come prior to the redefinition of setcolorspace, and
% must use an array operand.
%
[ /DeviceGray ] setcolorspace
%
% <c1> ... <cn> setcolor -
%
% As with setcolorspace, setcolor is initially placed in .cspace_util,
% and is copied to level2dict by the Level 2 initialization code. The
% internal definition of setcolor is removed from systemdict as soon
% as this procedure is defined.
%
/setcolor
{
{
currentcolorspace //.cs_prepare_color exec //setcolor
currentcolorspace //.cs_complete_setcolor exec
}
stopped
{ //.cspace_util /setcolor get $error /errorname get signalerror }
if
}
bind odef
systemdict /setcolor .undef
%
% <name|array> <bool> _setcolorspace -
% <name|array> _setcolorspace_nosub -
%
% <name|array> setcolorspace -
% <name|array> forcesetcolorspace -
%
% setcolorspace is initially placed in .cspace_util. It is copied to
% level2dict by the Level 2 initialization code. The internal
% setcolorspace operator is removed from systemdict as soon as this
% procedure is defined.
%
% Because some jobs, in particular PDF jobs, repeatedly set the same
% color space, this procedure will check if the operand and current
% color spaces are the same. The check is absolute for parameterless
% color spaces, conservative for others. For PostScript, this
% optimization can only be employed if color space substitution is
% disabled, as otherwise there is no way to account for possible changes
% in the /Default* instances of the ColorSpace resource category. For PDF
% jobs, resource category instances can only be changed at very specific
% times (typically page boundaries), so the "operand color space is the
% same as current color space" optimization may be used even if color
% space substitution is in effect. The optimization is also highly
% desirable in such cases, as it greatly improves performance.
%
% In certain situations, it is critical that a color space be set,
% even if it is the same as the current color space. This is the case
% when a CIEBased color space is used as a base or alternative color
% space, due to some long-standing problems with the graphics libraries
% handling of sampled information from the procedures in CIE color
% spaces and the color rendering dictionary. The forcesetcolorspace
% operator is provided for those situations.
%
% Note also that, if the current color space is not reset, at least
% the current color must be reset to its default value.
%
% Another problem arises in the case of ICCBased color spaces. These
% color spaces may be used to substitute for a DeviceGray/DeviceRGB/
% DeviceCMYK color space, and may themselves require such a color
% space as an alternate. Obviously, when this is the case the normal
% setcolorspace mechanism would encounter and infinite loop if the
% alternate colro space needed to be used. For this particular case,
% the special _setcolorspace_nosub is provided, which suppresses
% color space substitution. This routine does not bother to check if
% the operand and current color space are the same.
%
/_setcolorspace
{
{
% see if the operand space is the same as the current space
currentcolorspace dup length 1 eq
{
0 get
2 index dup type dup /arraytype eq exch /packedarraytype eq or
{
dup length 1 eq
{ 0 get }
if
}
if
}
{ 2 index }
ifelse
eq and dup
{
%
% If PDFfile is defined on the dictionary stack, this is a
% PDF job. No additional check is required in this case (see
% comment above).
%
/PDFfile where
{ pop }
{ .getuseciecolor not and } % check that UseCIEColor is off
ifelse
}
if
{ //.cs_get_default_color exec setcolor }
{
//.cs_validate exec
//.cs_substitute exec
//.cs_prepare exec
//.cs_install exec
//make_array1 exec //setcolorspace
}
ifelse
}
stopped
{ //.cspace_util /setcolorspace get $error /errorname get signalerror }
if
}
bind def
/_setcolorspace_nosub
{
{
//.cs_validate exec
dup
//.cs_prepare exec
//.cs_install exec
//make_array1 exec //setcolorspace
}
stopped
{ //.cspace_util /setcolorspace get $error /errorname get signalerror }
if
}
bind def
/setcolorspace { //true //_setcolorspace exec } bind odef
/forcesetcolorspace { //false //_setcolorspace exec } bind odef
%
% - initgraphics -
%
% The initgraphics operator must be redefined create a real color space.
% Previously this was unnecessary, as .currentcolorspace could return
% an integer.
%
%
/initgraphics
{ initgraphics { /DeviceGray } cvlit forcesetcolorspace }
.bind systemdict begin odef end
systemdict /setcolorspace .undef
%
% <gray> setgray -
%
% <r> <g> <b> setrgbcolor -
%
% <c> <m> <y> <b> setcmykcolor -
%
% The Level 1 color setting operators. setcmykcolor is created only if
% setcolorscreen is present. These operators are always defined in
% systemdict.
%
/setgray
{
{ { /DeviceGray } cvlit //setcolorspace //setcolor }
stopped
{ /setgray load $error /errorname get signalerror }
if
}
bind systemdict begin odef end
/setrgbcolor
{
{ { /DeviceRGB } cvlit //setcolorspace //setcolor }
stopped
{ /setrgbcolor load $error /errorname get signalerror }
if
}
bind systemdict begin odef end
/setcolorscreen where
{
pop
/setcmykcolor
{
{ { /DeviceCMYK } cvlit //setcolorspace //setcolor }
stopped
{ /setcmykcolor load $error /errorname get signalerror }
if
}
bind systemdict begin odef end
}
if
%
% - currentgray <gray>
%
% - currentrgbcolor <r> <g> <b>
%
% - currentcmykcolor <c> <m> <y> <k>
%
% Return the current color, mapped to a DeviceGray, DeviceRGB, or
% DeviceCMYK color space. The latter is only created if setcolorscreen
% is present.
/currentgray
{ currentcolor currentcolorspace //.cs_get_currentgray exec }
bind systemdict begin odef end
/currentrgbcolor
{ currentcolor currentcolorspace //.cs_get_currentrgb exec }
bind systemdict begin odef end
/setcolorscreen where
{
pop
/currentcmykcolor
{ currentcolor currentcolorspace //.cs_get_currentcmyk exec }
bind systemdict begin odef end
}
if
%
% Add some generically useful structures and procedures to .cspace_util.
%
%
% Some common errors. The command for these errors will normally be
% overwritten by the invoking operator. We cannot "load" the secolorspace
% or setcolor operators, as they are not present in Level 1 systems.
%
/setcspace_typecheck
{ /setcolorspace cvx /typecheck signalerror }
bind def
/setcspace_rangecheck
{ /setcolorspace cvx /rangecheck signalerror }
bind def
/setcspace_invalidaccess
{ /setcolorspace cvx /invalidaccess signalerror }
bind def
/setcspace_undefined
{ /setcolorspace cvx /undefined signalerror }
bind def
/setcolor_typecheck
{ /setcolor cvx /typecheck signalerror }
bind def
/setcolor_invalidaccess
{ /setcolor cvx /invalidaccess signalerror }
bind def
%
% <obj> check_array <obj>
%
% Check that an object is an array. Currently we don't check for
% readability, as a failing get or length operator should generate
% the appropriate invalidaccess error.
/check_array
{
dup type dup /arraytype ne exch /packedarraytype ne and
{ /setcolorspace cvx /typecheck signalerror }
if
}
bind def
% pre-defined procedures for cs_ncomps and cs_get_range
/ncomps_1 { pop 1 } bind def
/ncomps_3 { pop 3 } bind def
/ncomps_4 { pop 4 } bind def
/dflt_range_4 [ 0 1 0 1 0 1 0 1 ] readonly def
/dflt_range_3 dflt_range_4 0 6 getinterval def
/dflt_range_1 dflt_range_4 0 2 getinterval def
% <obj> get_range_[1|3|4] <range>
/get_range_1 { pop //dflt_range_1 } bind def
/get_range_3 { pop //dflt_range_3 } bind def
/get_range_4 { pop //dflt_range_4 } bind def
%
% <c1> ... <cn> <name | array> <n>
% check_num_stack
% <c1> ... <cn> <array | array>
%
% <c1> <array> validate_color_1 <c1>
% <c1> <c2> <c3> <arraY> validate_color_3 <c1> <c2> <c3>
% <c1> <c2> <c3> <c4> <arraY> validate_color_4 <c1> <c2> <c3> <c4>
%
% check_num_stack verifies that the stack consists of a color space array and
% n numbers. This is used by most of the cs_prepare_color procedures. The
% validate_color_[1|3|4] procedures can be used as the cs_prepare_color
% procedure for Device specific, CIEBased, and Indexed color spaces.
%
% Note that the pseudo-operator that (indirectly) invokes this routine will
% handle resetting the stacks.
%
/check_num_stack
{
dup 2 add copy exch pop
{
type dup /integertype ne exch /realtype ne and
//setcolor_typecheck
if
}
repeat
pop % remove the extra op_count
}
bind def
% <c1> <array> validate_1 <c1>
/validate_1 { 1 //check_num_stack exec pop } bind def
% <c1> <c2> <c3> <array> validate_3 <c1> <c2> <c3>
/validate_3 { 3 //check_num_stack exec pop } bind def
% <c1> <c2> <c3> <c4> <array> validate_4 <c1> <c2> <c3> <c4>
/validate_4 { 4 //check_num_stack exec pop } bind def
%
% <obj> pop_1 -
%
% This is a procedure form of pop. It may be used where a procedure is
% expected, but the function of the procedure is the same as the pop
% operator.
/pop_1 { pop } bind def
%
% <obj> dup_1 <obj> <obj>
%
% An analog to pop_1, this one for dup.
%
/dup_1 { dup } bind def
%
% <obj1> ... <objn> <n> clear_n_objs -
%
% Clear n objects from the operand stack.
%
/clear_n_objs { //pop_1 repeat } bind def
%
% <obj1> ... <objn> <array> clear_setcolor_operands -
%
% Clear the setcolor operands for a color space.
%
/clear_setcolor_operands
{ //.cs_get_ncomps exec //clear_n_objs exec }
bind def
%
% Return 1, 3, or 4 zeros. These routines are used primarily for the
% CIEBased color spaces, for which currentgray and currentrgb
% should return 0 for all components, and currentcmyk should return
% 0 0 0 1.0 (this varies from Adobe's documentation but is consistent
% with their impelementations).
%
/no_currentgray { //.cs_get_ncomps exec //clear_n_objs exec 0 } bind def
/no_currentrgb { //.cs_get_ncomps exec //clear_n_objs exec 0 0 0 } bind def
/no_currentcmyk { //.cs_get_ncomps exec //clear_n_objs exec 0 0 0 1.0 } bind def
%
% <num> bound_0_1 <num>
%
% Bound a number to the range [0, 1]
%
/bound_0_1
{
dup 0 lt
{ pop 0 }
{
dup 1 gt
{ pop 1 }
if
}
ifelse
}
bind def
%
% Provide pseudo-operators for sethsbcolor and currenthsbcolor. These are
% alternate versions of the setrgbcolor and currentrgbcolor operators, which
% make use of a hue/staturation/brightness color description.
%
%
% <num_1> ... <num_n> n max_n <num>
% <num_1> ... <num_n> n min_n <num>
%
% Find the maximum and minum of 3 color component intensities.
%
/max_n
{
1 sub
{ 2 copy lt { exch } if pop }
repeat
}
bind def
/min_n
{
1 sub
{ 2 copy gt { exch } if pop }
repeat
}
bind def
%
% <r> <g> <b> .rgb_2_hsb <h> <s> <br>
% <h> <s> <br> .hsb_2_rgb <r> <g> <b>
%
% Convert between RGB and HSB colors, using the hexcone approach (see
% Rogers, David, "Procedureal Elements For Computer Graphics",
% (McGraw-Hill, 1985), pp. 402 - 3).
%
% The rgb ==> hsb calculation is:
%
% br = max(r, g, b)
%
% if (br == 0)
% h = 0, s = 0;
% else {
% v = min(r, g, b)
% diff = br - v;
% sat = diff / br;
% if (r == br)
% h = (g - b) / (6 * diff) + (b > g ? 1 : 0);
% else if (g == br)
% h = 1/3 + (b - r) / (6 * diff);
% else /* b == br */
% h = 2/3 + (r - g) / (6 * diff);
% }
%
% The hsb ==> rgb conversion is:
%
% mn = (1 - s) * br, md = 6 * s * br;
%
% switch ((int)floor(6 * h)) {
% case 0: /* r >= g >= b */
% r = br;
% g = mn + h * md;
% b = mn;
% break;
%
% case 1: /* g >= r >= b */
% r = mn + md * (1/3 - h);
% g = br;
% b = mn;
% break;
%
% case 2: /* g >= b >= r */
% r = mn;
% g = br;
% b = mn + (h - 1/3) * md;
% break;
%
% case 3: /* b >= g >= r */
% r = mn;
% g = mn + (2/3 - h) * md;
% b = br;
% break;
%
% case 4: /* b >= r >= g */
% r = mn + (h - 2/3) * md;
% g = mn;
% b = br;
% break;
%
% case 5: /* r >= b >= g */
% r = br;
% g = mn;
% b = mn + (1 - h) * md;
% break;
%
% case 6: /* We have wrapped around the hexcone. Thus this case is
% the same as case 0 with h = 0 */
% h = 0;
% r = br;
% g = mn + h * md = mn;
% b = mn;
% break;
% }
%
/.rgb_2_hsb
{
% find the largest and smallest components
3 copy 3 //max_n exec dup 5 1 roll
dup 0 eq
{ pop pop pop pop 0 0 }
{
4 copy pop 3 //min_n exec 1 index exch sub
dup 2 index div 7 1 roll
dup 0 eq
{ 5 { pop } repeat 0 3 1 roll }
{
6 mul 5 1 roll
2 copy eq % blue == brightness
{ pop pop sub exch div .666667 add }
{
2 index eq % green == brightness
{ exch pop exch sub exch div .3333333 add }
{
% red == brightness
sub exch pop exch div
dup 0 lt
{ 1 add }
if
}
ifelse
}
ifelse
3 1 roll
}
ifelse
}
ifelse
}
bind def
/.hsb_2_rgb
{
3 { 0 max 1 min 3 1 roll } repeat
1 2 index sub 1 index mul % (1 - s) * br
3 -1 roll 2 index mul 6 mul % 6 * s * br
4 -1 roll % stack: <br> <(1 - s) * br> <6 * s * br> <h>
% array of procedures for the 7 hue cases
{
% 0 ==> r >= g >= b
{ mul 1 index add exch }
% 1 ==> g >= r >= b
{ 0.333333 exch sub mul 1 index add 3 1 roll }
% 2 ==> g >= b >= r
{ 0.333333 sub mul 1 index add 3 1 roll exch 3 -1 roll }
% 3 ==> b >= g >= r
{ 0.666667 exch sub mul 1 index add 3 -1 roll }
% 4 ==> b >= r >= g
{ 0.666667 sub mul 1 index add 3 1 roll exch }
% 5 ==> r >= b >= g
{ 1 exch sub mul 1 index add }
% 6 ==> r = br, g = b = mn
% Case 6 is the same as case 0 with h = 0. This also simplifies
% the calculations.
{ pop pop dup }
}
1 index 6 mul cvi % (int)(6 * h)
get exec
}
bind def
%
% <hue> <saturation> <brightness sethsbcolor -
%
% - currenthsbcolor <hue> <saturation> <brightness>
%
/sethsbcolor
{
{ //.hsb_2_rgb exec setrgbcolor }
stopped
{ /sethsbcolor load $error /errorname get signalerror }
if
}
bind systemdict begin odef end
/currenthsbcolor
{
{ currentrgbcolor //.rgb_2_hsb exec }
stopped
{ /currenthsbcolor load $error /errorname get signalerror }
if
}
bind systemdict begin odef end
end % .cspace_util
.setglobal
|
