public override void Execute(EpsInterpreter interpreter)
{
var currdict = interpreter.CurrentDict;
var dict = new DictionaryOperand(currdict);
interpreter.OperandStack.Push(dict);
}
/// <summary>
/// init
/// </summary>
/// <param name="functionDict"></param>
public void Init(DictionaryOperand functionDict)
{
var domainArray = functionDict.Dictionary.GetArray(EpsKeys.Domain);
var functionsArray = functionDict.Dictionary.GetArray(EpsKeys.Functions);
var encodeArray = functionDict.Dictionary.GetArray(EpsKeys.Encode);
var e0 = OperandHelper.GetRealValue(encodeArray.Values[0].Operand);
var e1 = OperandHelper.GetRealValue(encodeArray.Values[1].Operand);
// It doesn't make sense to revert only one function
// we assume either none or all functions are reverted
reverse = e0 > e1;
var boundsArray = functionDict.Dictionary.GetArray(EpsKeys.Bounds);
bounds = OperandHelper.GetRealValues(boundsArray);
bounds.Insert(0, OperandHelper.GetRealValue(domainArray.Values[0].Operand));
bounds.Add(OperandHelper.GetRealValue(domainArray.Values[1].Operand));
functions = new List <IFunction>();
for (int i = 0; i < functionsArray.Values.Count; i++)
{
var fDict = (DictionaryOperand)functionsArray.Values[i].Operand;
var function = FunctionActivator.CreateFunction(fDict);
functions.Add(function);
}
}
public static IFunction CreateFunction(DictionaryOperand functionDict)
{
IFunction function = null;
var functionType = (IntegerOperand)functionDict.Dictionary.Find(EpsKeys.FunctionType);
switch (functionType.Value)
{
// sampled
case 0:
function = new SampledFunction();
break;
// exponential
case 2:
function = new ExponentialFunction();
break;
// stitching
case 3:
function = new StitchingFunction();
break;
}
function.Init(functionDict);
return(function);
}
/// <summary>
/// Create a copy
/// </summary>
protected override Operand CreateCopy()
{
var copy = new DictionaryOperand();
copy.Dictionary = Dictionary;
return(copy);
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var cap = operandStack.PopInteger();
var dict = new DictionaryOperand();
operandStack.Push(dict);
}
/// <summary>
/// init
/// </summary>
public void Init(EpsInterpreter interpreter, DictionaryOperand patternDict)
{
var shadingDict = patternDict.Dictionary.GetDictionary(EpsKeys.Shading);
shading = ShadingActivator.CreateShading(interpreter, shadingDict);
var matrixArray = patternDict.Dictionary.GetArray(EpsKeys.Matrix);
matrix = OperandHelper.GetMatrix(matrixArray);
}
public override void Execute(EpsInterpreter interpreter)
{
var array = interpreter.OperandStack.PeekArray();
int i = 0;
foreach (var dict in interpreter.DictionaryStack)
{
var dictOp = new DictionaryOperand(dict);
array.Values[i].Operand = dictOp;
i++;
}
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var matrix = operandStack.PopArray();
var pattern = operandStack.PopDictionary();
var newDict = new DictionaryOperand();
newDict.Dictionary.Add(pattern.Dictionary);
newDict.Dictionary.Add(new NameOperand(EpsKeys.Matrix), matrix);
operandStack.Push(newDict);
}
/// <summary>
/// init
/// </summary>
/// <param name="functionDict"></param>
public void Init(DictionaryOperand functionDict)
{
var domainArray = functionDict.Dictionary.GetArray(EpsKeys.Domain);
var c0Array = functionDict.Dictionary.GetArray(EpsKeys.C0);
var c1Array = functionDict.Dictionary.GetArray(EpsKeys.C1);
//var rangeArray = functionDict.Dictionary.GetArray(EpsKeys.Range);
//var n = functionDict.Dictionary.GetInteger(EpsKeys.N);
domain0 = OperandHelper.GetRealValue(domainArray.Values[0].Operand);
domain1 = OperandHelper.GetRealValue(domainArray.Values[1].Operand);
c0 = OperandHelper.GetRealValues(c0Array);
c1 = OperandHelper.GetRealValues(c1Array);
}
/// <summary>
/// Init
/// </summary>
public void Init(EpsInterpreter interpreter, DictionaryOperand shadingDict)
{
var colorSpaceOperand = shadingDict.Dictionary.Find(EpsKeys.ColorSpace);
colorSpace = ColorSpaceActivator.CreateColorSpace(interpreter, colorSpaceOperand);
var functionDict = shadingDict.Dictionary.GetDictionary(EpsKeys.Function);
function = FunctionActivator.CreateFunction(functionDict);
var coordsArray = shadingDict.Dictionary.GetArray(EpsKeys.Coords);
var coords = OperandHelper.GetRealValues(coordsArray);
coords0 = new Point(coords[0], coords[1]);
coords1 = new Point(coords[2], coords[3]);
}
/// <summary>
/// Read one shading
/// </summary>
public static IShading CreateShading(EpsInterpreter interpreter, DictionaryOperand shadingDict)
{
IShading shadingDescriptor = null;
var shadingtype = (IntegerOperand)shadingDict.Dictionary.Find(EpsKeys.ShadingType);
switch (shadingtype.Value)
{
// linear
case 2:
{
shadingDescriptor = new LinearGradientShading();
break;
}
// radial
case 3:
{
shadingDescriptor = new RadialGradientShading();
break;
}
// function based
case 1:
// free-form Gouraud-shaded triangle mesh
case 4:
// Lattice-form Gouraud-shaded triangle mesh
case 5:
// coons path mesh
case 6:
// tensor-product path mesh
case 7:
default:
{
shadingDescriptor = new UnknownShading();
break;
}
}
shadingDescriptor.Init(interpreter, shadingDict);
return(shadingDescriptor);
}
/// <summary>
/// Execute the operand
/// </summary>
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
var dict = new DictionaryOperand();
var value = operandStack.Pop();
while (!(value is MarkOperand))
{
var key = operandStack.Pop();
dict.Dictionary.Add(key, value);
value = operandStack.Pop();
}
operandStack.Push(dict);
}
public override void Execute(EpsInterpreter interpreter)
{
var operandStack = interpreter.OperandStack;
bool ret = false;
var key = operandStack.Pop();
var dict = DictionaryStackHelper.FindDictionary(interpreter.DictionaryStack, key);
if (dict != null)
{
var dictOperand = new DictionaryOperand(dict);
operandStack.Push(dictOperand);
ret = true;
}
var boolean = new BooleanOperand {
Value = ret
};
operandStack.Push(boolean);
}
/// <summary>
/// init
/// </summary>
/// <param name="functionDict"></param>
public void Init(DictionaryOperand functionDict)
{
var domainArray = functionDict.Dictionary.GetArray(EpsKeys.Domain);
//var rangeArray = functionDict.Dictionary.GetArray(EpsKeys.Range);
//var encodeArray = functionDict.Dictionary.GetArray(EpsKeys.Encode);
var decodeArray = functionDict.Dictionary.GetArray(EpsKeys.Decode);
var sizeArray = functionDict.Dictionary.GetArray(EpsKeys.Size);
var dataSource = functionDict.Dictionary.GetString(EpsKeys.DataSource);
var bitsPerSample = functionDict.Dictionary.GetInteger(EpsKeys.BitsPerSample);
domain0 = OperandHelper.GetRealValue(domainArray.Values[0].Operand);
domain1 = OperandHelper.GetRealValue(domainArray.Values[1].Operand);
var decodes = OperandHelper.GetRealValues(decodeArray);
var size = (IntegerOperand)sizeArray.Values[0].Operand;
var data = RelativeSamplesDecoder.Decode(dataSource, bitsPerSample.Value);
int valuesPerSample = data.Count / size.Value;
c0 = GetSample(data, 0, valuesPerSample, decodes);
c1 = GetSample(data, (data.Count - valuesPerSample), valuesPerSample, decodes);
}
/// <summary>
/// Read and create a single pattern
/// </summary>
public static IPattern CreatePattern(EpsInterpreter interpreter, DictionaryOperand patternDict)
{
IPattern pattern = null;
var type = patternDict.Dictionary.GetInteger(EpsKeys.PatternType);
switch (type.Value)
{
case 1:
{
pattern = new TilingPattern();
break;
}
case 2:
{
pattern = new ShadingPattern();
break;
}
}
pattern.Init(interpreter, patternDict);
return(pattern);
}
/// <summary>
/// Init
/// </summary>
public void Init(EpsInterpreter interpreter, DictionaryOperand shadingDict)
{
}
/// <summary>
/// init
/// </summary>
public void Init(EpsInterpreter interpreter, DictionaryOperand patternDict)
{
}
