xpdf-no-select-disableHEADmaster

1 files changed, 240 insertions, 0 deletions

diff --git a/xpdf/Function.h b/xpdf/Function.h
new file mode 100644
index 0000000..bf1f25e
--- /dev/null
+++ b/xpdf/Function.h
@@ -0,0 +1,240 @@
+//========================================================================
+//
+// Function.h
+//
+// Copyright 2001-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef FUNCTION_H
+#define FUNCTION_H
+
+#include <aconf.h>
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#include "gtypes.h"
+#include "Object.h"
+
+class GList;
+class Dict;
+class Stream;
+struct PSCode;
+
+//------------------------------------------------------------------------
+// Function
+//------------------------------------------------------------------------
+
+#define funcMaxInputs        32
+#define funcMaxOutputs       32
+#define sampledFuncMaxInputs 16
+
+class Function {
+public:
+
+  Function();
+
+  virtual ~Function();
+
+  // Construct a function, with [expectedInputs] inputs and
+  // [expectedOutputs] outputs.  [expectedOutputs] can be -1 to
+  // indicate unknown.  Returns NULL if unsuccessful.
+  static Function *parse(Object *funcObj, int expectedInputs,
+			 int expectedOutputs, int recursion = 0);
+
+  // Initialize the entries common to all function types.
+  GBool init(Dict *dict);
+
+  virtual Function *copy() = 0;
+
+  // Return the function type:
+  //   -1 : identity
+  //    0 : sampled
+  //    2 : exponential
+  //    3 : stitching
+  //    4 : PostScript
+  virtual int getType() = 0;
+
+  // Return size of input and output tuples.
+  int getInputSize() { return m; }
+  int getOutputSize() { return n; }
+
+  double getDomainMin(int i) { return domain[i][0]; }
+  double getDomainMax(int i) { return domain[i][1]; }
+  double getRangeMin(int i) { return range[i][0]; }
+  double getRangeMax(int i) { return range[i][1]; }
+  GBool getHasRange() { return hasRange; }
+
+  // Transform an input tuple into an output tuple.
+  virtual void transform(double *in, double *out) = 0;
+
+  virtual GBool isOk() = 0;
+
+protected:
+
+  int m, n;			// size of input and output tuples
+  double			// min and max values for function domain
+    domain[funcMaxInputs][2];
+  double			// min and max values for function range
+    range[funcMaxOutputs][2];
+  GBool hasRange;		// set if range is defined
+};
+
+//------------------------------------------------------------------------
+// IdentityFunction
+//------------------------------------------------------------------------
+
+class IdentityFunction: public Function {
+public:
+
+  IdentityFunction(int nInputs);
+  virtual ~IdentityFunction();
+  virtual Function *copy() { return new IdentityFunction(m); }
+  virtual int getType() { return -1; }
+  virtual void transform(double *in, double *out);
+  virtual GBool isOk() { return gTrue; }
+
+private:
+};
+
+//------------------------------------------------------------------------
+// SampledFunction
+//------------------------------------------------------------------------
+
+class SampledFunction: public Function {
+public:
+
+  SampledFunction(Object *funcObj, Dict *dict);
+  virtual ~SampledFunction();
+  virtual Function *copy() { return new SampledFunction(this); }
+  virtual int getType() { return 0; }
+  virtual void transform(double *in, double *out);
+  virtual GBool isOk() { return ok; }
+
+  int getSampleSize(int i) { return sampleSize[i]; }
+  double getEncodeMin(int i) { return encode[i][0]; }
+  double getEncodeMax(int i) { return encode[i][1]; }
+  double getDecodeMin(int i) { return decode[i][0]; }
+  double getDecodeMax(int i) { return decode[i][1]; }
+  double *getSamples() { return samples; }
+
+private:
+
+  SampledFunction(SampledFunction *func);
+
+  int				// number of samples for each domain element
+    sampleSize[funcMaxInputs];
+  double			// min and max values for domain encoder
+    encode[funcMaxInputs][2];
+  double			// min and max values for range decoder
+    decode[funcMaxOutputs][2];
+  double			// input multipliers
+    inputMul[funcMaxInputs];
+  int *idxOffset;
+  double *samples;		// the samples
+  int nSamples;			// size of the samples array
+  double *sBuf;			// buffer for the transform function
+  double cacheIn[funcMaxInputs];
+  double cacheOut[funcMaxOutputs];
+  GBool ok;
+};
+
+//------------------------------------------------------------------------
+// ExponentialFunction
+//------------------------------------------------------------------------
+
+class ExponentialFunction: public Function {
+public:
+
+  ExponentialFunction(Object *funcObj, Dict *dict);
+  virtual ~ExponentialFunction();
+  virtual Function *copy() { return new ExponentialFunction(this); }
+  virtual int getType() { return 2; }
+  virtual void transform(double *in, double *out);
+  virtual GBool isOk() { return ok; }
+
+  double *getC0() { return c0; }
+  double *getC1() { return c1; }
+  double getE() { return e; }
+
+private:
+
+  ExponentialFunction(ExponentialFunction *func);
+
+  double c0[funcMaxOutputs];
+  double c1[funcMaxOutputs];
+  double e;
+  GBool ok;
+};
+
+//------------------------------------------------------------------------
+// StitchingFunction
+//------------------------------------------------------------------------
+
+class StitchingFunction: public Function {
+public:
+
+  StitchingFunction(Object *funcObj, Dict *dict, int expectedInputs,
+		    int expectedOutputs, int recursion);
+  virtual ~StitchingFunction();
+  virtual Function *copy() { return new StitchingFunction(this); }
+  virtual int getType() { return 3; }
+  virtual void transform(double *in, double *out);
+  virtual GBool isOk() { return ok; }
+
+  int getNumFuncs() { return k; }
+  Function *getFunc(int i) { return funcs[i]; }
+  double *getBounds() { return bounds; }
+  double *getEncode() { return encode; }
+  double *getScale() { return scale; }
+
+private:
+
+  StitchingFunction(StitchingFunction *func);
+
+  int k;
+  Function **funcs;
+  double *bounds;
+  double *encode;
+  double *scale;
+  GBool ok;
+};
+
+//------------------------------------------------------------------------
+// PostScriptFunction
+//------------------------------------------------------------------------
+
+class PostScriptFunction: public Function {
+public:
+
+  PostScriptFunction(Object *funcObj, Dict *dict);
+  virtual ~PostScriptFunction();
+  virtual Function *copy() { return new PostScriptFunction(this); }
+  virtual int getType() { return 4; }
+  virtual void transform(double *in, double *out);
+  virtual GBool isOk() { return ok; }
+
+  GString *getCodeString() { return codeString; }
+
+private:
+
+  PostScriptFunction(PostScriptFunction *func);
+  GBool parseCode(GList *tokens, int *tokPtr, int *codePtr);
+  void addCode(int *codePtr, int op);
+  void addCodeI(int *codePtr, int op, int x);
+  void addCodeD(int *codePtr, int op, double x);
+  GString *getToken(Stream *str);
+  int exec(double *stack, int sp0);
+
+  GString *codeString;
+  PSCode *code;
+  int codeLen;
+  int codeSize;
+  double cacheIn[funcMaxInputs];
+  double cacheOut[funcMaxOutputs];
+  GBool ok;
+};
+
+#endif