#ifndef FUNCTION_H
#define FUNCTION_H
#include <config.h>
#ifdef USE_GCC_PRAGMAS
#pragma interface
#endif
#include "gtypes.h"
#include "Object.h"
class Dict;
class Stream;
struct PSObject;
class PSStack;
#define funcMaxInputs 8
#define funcMaxOutputs 32
class Function {
public:
Function();
virtual ~Function();
static Function *parse(Object *funcObj);
GBool init(Dict *dict);
virtual Function *copy() = 0;
virtual int getType() = 0;
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; }
virtual void transform(double *in, double *out) = 0;
virtual GBool isOk() = 0;
protected:
int m, n; double domain[funcMaxInputs][2];
double range[funcMaxOutputs][2];
GBool hasRange; };
class IdentityFunction: public Function {
public:
IdentityFunction();
virtual ~IdentityFunction();
virtual Function *copy() { return new IdentityFunction(); }
virtual int getType() { return -1; }
virtual void transform(double *in, double *out);
virtual GBool isOk() { return gTrue; }
private:
};
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 sampleSize[funcMaxInputs];
double encode[funcMaxInputs][2];
double decode[funcMaxOutputs][2];
double inputMul[funcMaxInputs];
int idxMul[funcMaxInputs]; double *samples; int nSamples; GBool ok;
};
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;
};
class StitchingFunction: public Function {
public:
StitchingFunction(Object *funcObj, Dict *dict);
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; }
private:
StitchingFunction(StitchingFunction *func);
int k;
Function **funcs;
double *bounds;
double *encode;
GBool ok;
};
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(Stream *str, int *codePtr);
GString *getToken(Stream *str);
void resizeCode(int newSize);
void exec(PSStack *stack, int codePtr);
GString *codeString;
PSObject *code;
int codeSize;
GBool ok;
};
#endif