source: trunk/poppler/mypoppler/poppler/Function.h @ 250

Last change on this file since 250 was 250, checked in by Eugene Romanenko, 13 years ago

PDF plugin: poppler library updated to version 0.8.3

File size: 6.1 KB
Line 
1//========================================================================
2//
3// Function.h
4//
5// Copyright 2001-2003 Glyph & Cog, LLC
6//
7//========================================================================
8
9#ifndef FUNCTION_H
10#define FUNCTION_H
11
12#ifdef USE_GCC_PRAGMAS
13#pragma interface
14#endif
15
16#include "goo/gtypes.h"
17#include "Object.h"
18
19class Dict;
20class Stream;
21struct PSObject;
22class PSStack;
23
24//------------------------------------------------------------------------
25// Function
26//------------------------------------------------------------------------
27
28#define funcMaxInputs        32
29#define funcMaxOutputs       32
30#define sampledFuncMaxInputs 16
31
32class Function {
33public:
34
35  Function();
36
37  virtual ~Function();
38
39  // Construct a function.  Returns NULL if unsuccessful.
40  static Function *parse(Object *funcObj);
41
42  // Initialize the entries common to all function types.
43  GBool init(Dict *dict);
44
45  virtual Function *copy() = 0;
46
47  // Return the function type:
48  //   -1 : identity
49  //    0 : sampled
50  //    2 : exponential
51  //    3 : stitching
52  //    4 : PostScript
53  virtual int getType() = 0;
54
55  // Return size of input and output tuples.
56  int getInputSize() { return m; }
57  int getOutputSize() { return n; }
58
59  double getDomainMin(int i) { return domain[i][0]; }
60  double getDomainMax(int i) { return domain[i][1]; }
61  double getRangeMin(int i) { return range[i][0]; }
62  double getRangeMax(int i) { return range[i][1]; }
63  GBool getHasRange() { return hasRange; }
64
65  // Transform an input tuple into an output tuple.
66  virtual void transform(double *in, double *out) = 0;
67
68  virtual GBool isOk() = 0;
69
70protected:
71
72  int m, n;                     // size of input and output tuples
73  double                        // min and max values for function domain
74    domain[funcMaxInputs][2];
75  double                        // min and max values for function range
76    range[funcMaxOutputs][2];
77  GBool hasRange;               // set if range is defined
78};
79
80//------------------------------------------------------------------------
81// IdentityFunction
82//------------------------------------------------------------------------
83
84class IdentityFunction: public Function {
85public:
86
87  IdentityFunction();
88  virtual ~IdentityFunction();
89  virtual Function *copy() { return new IdentityFunction(); }
90  virtual int getType() { return -1; }
91  virtual void transform(double *in, double *out);
92  virtual GBool isOk() { return gTrue; }
93
94private:
95};
96
97//------------------------------------------------------------------------
98// SampledFunction
99//------------------------------------------------------------------------
100
101class SampledFunction: public Function {
102public:
103
104  SampledFunction(Object *funcObj, Dict *dict);
105  virtual ~SampledFunction();
106  virtual Function *copy() { return new SampledFunction(this); }
107  virtual int getType() { return 0; }
108  virtual void transform(double *in, double *out);
109  virtual GBool isOk() { return ok; }
110
111  int getSampleSize(int i) { return sampleSize[i]; }
112  double getEncodeMin(int i) { return encode[i][0]; }
113  double getEncodeMax(int i) { return encode[i][1]; }
114  double getDecodeMin(int i) { return decode[i][0]; }
115  double getDecodeMax(int i) { return decode[i][1]; }
116  double *getSamples() { return samples; }
117
118private:
119
120  SampledFunction(SampledFunction *func);
121
122  int                           // number of samples for each domain element
123    sampleSize[funcMaxInputs];
124  double                        // min and max values for domain encoder
125    encode[funcMaxInputs][2];
126  double                        // min and max values for range decoder
127    decode[funcMaxOutputs][2];
128  double                        // input multipliers
129    inputMul[funcMaxInputs];
130  int idxMul[funcMaxInputs];    // sample array index multipliers
131  double *samples;              // the samples
132  int nSamples;                 // size of the samples array
133  double *sBuf;                 // buffer for the transform function
134  GBool ok;
135};
136
137//------------------------------------------------------------------------
138// ExponentialFunction
139//------------------------------------------------------------------------
140
141class ExponentialFunction: public Function {
142public:
143
144  ExponentialFunction(Object *funcObj, Dict *dict);
145  virtual ~ExponentialFunction();
146  virtual Function *copy() { return new ExponentialFunction(this); }
147  virtual int getType() { return 2; }
148  virtual void transform(double *in, double *out);
149  virtual GBool isOk() { return ok; }
150
151  double *getC0() { return c0; }
152  double *getC1() { return c1; }
153  double getE() { return e; }
154
155private:
156
157  ExponentialFunction(ExponentialFunction *func);
158
159  double c0[funcMaxOutputs];
160  double c1[funcMaxOutputs];
161  double e;
162  GBool ok;
163};
164
165//------------------------------------------------------------------------
166// StitchingFunction
167//------------------------------------------------------------------------
168
169class StitchingFunction: public Function {
170public:
171
172  StitchingFunction(Object *funcObj, Dict *dict);
173  virtual ~StitchingFunction();
174  virtual Function *copy() { return new StitchingFunction(this); }
175  virtual int getType() { return 3; }
176  virtual void transform(double *in, double *out);
177  virtual GBool isOk() { return ok; }
178
179  int getNumFuncs() { return k; }
180  Function *getFunc(int i) { return funcs[i]; }
181  double *getBounds() { return bounds; }
182  double *getEncode() { return encode; }
183  double *getScale() { return scale; }
184
185private:
186
187  StitchingFunction(StitchingFunction *func);
188
189  int k;
190  Function **funcs;
191  double *bounds;
192  double *encode;
193  double *scale;
194  GBool ok;
195};
196
197//------------------------------------------------------------------------
198// PostScriptFunction
199//------------------------------------------------------------------------
200
201class PostScriptFunction: public Function {
202public:
203
204  PostScriptFunction(Object *funcObj, Dict *dict);
205  virtual ~PostScriptFunction();
206  virtual Function *copy() { return new PostScriptFunction(this); }
207  virtual int getType() { return 4; }
208  virtual void transform(double *in, double *out);
209  virtual GBool isOk() { return ok; }
210
211  GooString *getCodeString() { return codeString; }
212
213private:
214
215  PostScriptFunction(PostScriptFunction *func);
216  GBool parseCode(Stream *str, int *codePtr);
217  GooString *getToken(Stream *str);
218  void resizeCode(int newSize);
219  void exec(PSStack *stack, int codePtr);
220
221  GooString *codeString;
222  PSObject *code;
223  int codeSize;
224  GBool ok;
225};
226
227#endif
Note: See TracBrowser for help on using the repository browser.