pdf2swf/xpdf/Function.h

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