00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef FUNCTION_H
00010 #define FUNCTION_H
00011
00012 #include <aconf.h>
00013
00014 #ifdef USE_GCC_PRAGMAS
00015 #pragma interface
00016 #endif
00017
00018 #include "gtypes.h"
00019 #include "Object.h"
00020
00021 class Dict;
00022 class Stream;
00023 struct PSObject;
00024 class PSStack;
00025
00026
00027
00028
00029
00030 #define funcMaxInputs 8
00031 #define funcMaxOutputs 32
00032
00033 class Function {
00034 public:
00035
00036 Function();
00037
00038 virtual ~Function();
00039
00040
00041 static Function *parse(Object *funcObj);
00042
00043
00044 GBool init(Dict *dict);
00045
00046 virtual Function *copy() = 0;
00047
00048
00049 int getInputSize() { return m; }
00050 int getOutputSize() { return n; }
00051
00052
00053 virtual void transform(double *in, double *out) = 0;
00054
00055 virtual GBool isOk() = 0;
00056
00057 protected:
00058
00059 int m, n;
00060 double
00061 domain[funcMaxInputs][2];
00062 double
00063 range[funcMaxOutputs][2];
00064 GBool hasRange;
00065 };
00066
00067
00068
00069
00070
00071 class IdentityFunction: public Function {
00072 public:
00073
00074 IdentityFunction();
00075 virtual ~IdentityFunction();
00076 virtual Function *copy() { return new IdentityFunction(); }
00077 virtual void transform(double *in, double *out);
00078 virtual GBool isOk() { return gTrue; }
00079
00080 private:
00081 };
00082
00083
00084
00085
00086
00087 class SampledFunction: public Function {
00088 public:
00089
00090 SampledFunction(Object *funcObj, Dict *dict);
00091 virtual ~SampledFunction();
00092 virtual Function *copy() { return new SampledFunction(this); }
00093 virtual void transform(double *in, double *out);
00094 virtual GBool isOk() { return ok; }
00095
00096 private:
00097
00098 SampledFunction(SampledFunction *func);
00099
00100 int
00101 sampleSize[funcMaxInputs];
00102 double
00103 encode[funcMaxInputs][2];
00104 double
00105 decode[funcMaxOutputs][2];
00106 double *samples;
00107 GBool ok;
00108 };
00109
00110
00111
00112
00113
00114 class ExponentialFunction: public Function {
00115 public:
00116
00117 ExponentialFunction(Object *funcObj, Dict *dict);
00118 virtual ~ExponentialFunction();
00119 virtual Function *copy() { return new ExponentialFunction(this); }
00120 virtual void transform(double *in, double *out);
00121 virtual GBool isOk() { return ok; }
00122
00123 private:
00124
00125 ExponentialFunction(ExponentialFunction *func);
00126
00127 double c0[funcMaxOutputs];
00128 double c1[funcMaxOutputs];
00129 double e;
00130 GBool ok;
00131 };
00132
00133
00134
00135
00136
00137 class StitchingFunction: public Function {
00138 public:
00139
00140 StitchingFunction(Object *funcObj, Dict *dict);
00141 virtual ~StitchingFunction();
00142 virtual Function *copy() { return new StitchingFunction(this); }
00143 virtual void transform(double *in, double *out);
00144 virtual GBool isOk() { return ok; }
00145
00146 private:
00147
00148 StitchingFunction(StitchingFunction *func);
00149
00150 int k;
00151 Function **funcs;
00152 double *bounds;
00153 double *encode;
00154 GBool ok;
00155 };
00156
00157
00158
00159
00160
00161 class PostScriptFunction: public Function {
00162 public:
00163
00164 PostScriptFunction(Object *funcObj, Dict *dict);
00165 virtual ~PostScriptFunction();
00166 virtual Function *copy() { return new PostScriptFunction(this); }
00167 virtual void transform(double *in, double *out);
00168 virtual GBool isOk() { return ok; }
00169
00170 private:
00171
00172 PostScriptFunction(PostScriptFunction *func);
00173 GBool parseCode(Stream *str, int *codePtr);
00174 GString *getToken(Stream *str);
00175 void resizeCode(int newSize);
00176 void exec(PSStack *stack, int codePtr);
00177
00178 PSObject *code;
00179 int codeSize;
00180 GBool ok;
00181 };
00182
00183 #endif