removed automatically generated files.
[swftools.git] / pdf2swf / xpdf / Function.h
1 //========================================================================
2 //
3 // Function.h
4 //
5 // Copyright 2001-2002 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #ifndef FUNCTION_H
10 #define FUNCTION_H
11
12 #ifdef __GNUC__
13 #pragma interface
14 #endif
15
16 #include "gtypes.h"
17 #include "Object.h"
18
19 class Dict;
20 class Stream;
21 struct PSObject;
22 class PSStack;
23
24 //------------------------------------------------------------------------
25 // Function
26 //------------------------------------------------------------------------
27
28 #define funcMaxInputs  8
29 #define funcMaxOutputs 8
30
31 class Function {
32 public:
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 size of input and output tuples.
47   int getInputSize() { return m; }
48   int getOutputSize() { return n; }
49
50   // Transform an input tuple into an output tuple.
51   virtual void transform(double *in, double *out) = 0;
52
53   virtual GBool isOk() = 0;
54
55 protected:
56
57   int m, n;                     // size of input and output tuples
58   double                        // min and max values for function domain
59     domain[funcMaxInputs][2];
60   double                        // min and max values for function range
61     range[funcMaxOutputs][2];
62   GBool hasRange;               // set if range is defined
63 };
64
65 //------------------------------------------------------------------------
66 // IdentityFunction
67 //------------------------------------------------------------------------
68
69 class IdentityFunction: public Function {
70 public:
71
72   IdentityFunction();
73   virtual ~IdentityFunction();
74   virtual Function *copy() { return new IdentityFunction(); }
75   virtual void transform(double *in, double *out);
76   virtual GBool isOk() { return gTrue; }
77
78 private:
79 };
80
81 //------------------------------------------------------------------------
82 // SampledFunction
83 //------------------------------------------------------------------------
84
85 class SampledFunction: public Function {
86 public:
87
88   SampledFunction(Object *funcObj, Dict *dict);
89   virtual ~SampledFunction();
90   virtual Function *copy() { return new SampledFunction(this); }
91   virtual void transform(double *in, double *out);
92   virtual GBool isOk() { return ok; }
93
94 private:
95
96   SampledFunction(SampledFunction *func);
97
98   int                           // number of samples for each domain element
99     sampleSize[funcMaxInputs];
100   double                        // min and max values for domain encoder
101     encode[funcMaxInputs][2];
102   double                        // min and max values for range decoder
103     decode[funcMaxOutputs][2];
104   double *samples;              // the samples
105   GBool ok;
106 };
107
108 //------------------------------------------------------------------------
109 // ExponentialFunction
110 //------------------------------------------------------------------------
111
112 class ExponentialFunction: public Function {
113 public:
114
115   ExponentialFunction(Object *funcObj, Dict *dict);
116   virtual ~ExponentialFunction();
117   virtual Function *copy() { return new ExponentialFunction(this); }
118   virtual void transform(double *in, double *out);
119   virtual GBool isOk() { return ok; }
120
121 private:
122
123   ExponentialFunction(ExponentialFunction *func);
124
125   double c0[funcMaxOutputs];
126   double c1[funcMaxOutputs];
127   double e;
128   GBool ok;
129 };
130
131 //------------------------------------------------------------------------
132 // StitchingFunction
133 //------------------------------------------------------------------------
134
135 class StitchingFunction: public Function {
136 public:
137
138   StitchingFunction(Object *funcObj, Dict *dict);
139   virtual ~StitchingFunction();
140   virtual Function *copy() { return new StitchingFunction(this); }
141   virtual void transform(double *in, double *out);
142   virtual GBool isOk() { return ok; }
143
144 private:
145
146   StitchingFunction(StitchingFunction *func);
147
148   int k;
149   Function **funcs;
150   double *bounds;
151   double *encode;
152   GBool ok;
153 };
154
155 //------------------------------------------------------------------------
156 // PostScriptFunction
157 //------------------------------------------------------------------------
158
159 class PostScriptFunction: public Function {
160 public:
161
162   PostScriptFunction(Object *funcObj, Dict *dict);
163   virtual ~PostScriptFunction();
164   virtual Function *copy() { return new PostScriptFunction(this); }
165   virtual void transform(double *in, double *out);
166   virtual GBool isOk() { return ok; }
167
168 private:
169
170   PostScriptFunction(PostScriptFunction *func);
171   GBool parseCode(Stream *str, int *codePtr);
172   GString *getToken(Stream *str);
173   void resizeCode(int newSize);
174   void exec(PSStack *stack, int codePtr);
175
176   PSObject *code;
177   int codeSize;
178   GBool ok;
179 };
180
181 #endif