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

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 16 years ago

First import

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