ValueFunctionPressure Class Reference

#include <valfunc.h>

Inheritance diagram for ValueFunctionPressure:

List of all members.

Public Member Functions
	ValueFunctionPressure ()
	Constructor Pressure functions store a table of recorded pressure values and return curve-interpolated pressure values on demand.
	~ValueFunctionPressure ()
	Destructor.
virtual double	GetValue (double Position)
	To read the value of this function at a given position.
virtual ValueFunction *	Clone (void)
	Clone operator. Creates an exact copy of this object.
virtual BOOL	IsDifferent (ValueFunction *pOther)
	Comparator. Determines if 2 different ValueFunction objects are considered different.
BOOL	AddPressure (float Position, float PressureValue)
	Adds a pressure record to the ValueFunction table.
void	NormalisePositions (void)
	Normalises all positions in the table to lie within a 0.0 to 1.0 range, by dividing them by the last element position value. (i.e. it assumes that the last element in the array will have the largest Position value).
virtual CamelotFileRecord *	WriteFileRecord (INT32 RecordTag, INT32 ExtraBytes, BaseCamelotFilter *pFilter)
	Saves a ValueFunction object to a Xara file. This function will create a new variable-sized record with the given record tag, and will write out whatever data is needed to save this ValueFunction's state to the file.
virtual ValueFunctionID	GetUniqueID (void)
Protected Member Functions
virtual ValueFunction *	CreateAndReadFileRecord (CXaraFileRecord *pInputRecord)
	Loads a ValueFunction object from a record which was saved into a file using the WriteFileRecord call. This is called by the base class loader routine ReadFileRecord, which finds an appropriate instance of a derived class to call to load the data in question.
BOOL	ExpandArray (INT32 NewSize)
	Ensures that the pressure storage array has no fewer than NewSize entries.
virtual ValueFunctionPressure *	CreateInstance (void)
	Creates a new blank object of the same type as this one. Internal function used in ValueFunctionPressure & ValueFunctionPressureS.
Protected Attributes
VFPressureRecord *	pArray
INT32	ArraySize
INT32	NextFree
Private Member Functions
	CC_DECLARE_DYNAMIC (ValueFunctionPressure)

---

Detailed Description

Definition at line 854 of file valfunc.h.

---

Constructor & Destructor Documentation

ValueFunctionPressure::ValueFunctionPressure (   )

Constructor Pressure functions store a table of recorded pressure values and return curve-interpolated pressure values on demand. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Definition at line 2820 of file valfunc.cpp. { pArray = NULL; ArraySize = 0; NextFree = 0; }

ValueFunctionPressure::~ValueFunctionPressure (   )

Destructor. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Definition at line 2840 of file valfunc.cpp. { if (pArray != NULL) CCFree(pArray); }

---

Member Function Documentation

BOOL ValueFunctionPressure::AddPressure (  float  Position, float  PressureValue )

Adds a pressure record to the ValueFunction table. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Parameters: Position  - A number representing distance along the path of this point [INPUTS] (Normally this would be between 0.0 and 1.0, but you can temporarily use positions between 0.0 and any positive value and then call NormalisePositions if this is more convenient while building the table) NOTE: Each added pressure value must be a positive number, and must be greater than the last in order to be recorded. Illegal values will be discarded. PressureValue - The pressure value to record for this position Returns: FALSE if memory was unavailable TRUE if it was happy (even if it discarded the value) Definition at line 3027 of file valfunc.cpp. { ERROR3IF(PressureValue < 0.0 || PressureValue > 1.0, "Illegal pressure value"); ERROR3IF(Position < 0.0, "Illegal (negative) position value"); // Make sure there's plenty of room for new entries if (NextFree >= ArraySize && !ExpandArray(ArraySize + 32)) return(FALSE); // Only record the value if the position has advanced. Error if the position has // gone retrograde, but quietly dismiss equal positions. ERROR3IF(NextFree > 0 && Position < pArray[NextFree-1].Position, "AddPressure - pressure values must be ascending"); if (NextFree > 0 && Position <= pArray[NextFree-1].Position) return(TRUE); // And write this entry pArray[NextFree].Position = Position; pArray[NextFree].Pressure = PressureValue; NextFree++; return(TRUE); }

ValueFunctionPressure::CC_DECLARE_DYNAMIC (  ValueFunctionPressure   )  [private]

ValueFunction * ValueFunctionPressure::Clone (  void   )  [virtual]

Clone operator. Creates an exact copy of this object. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Returns: NULL if it failed, else an exact copy of this object Implements ValueFunction. Definition at line 2932 of file valfunc.cpp. { // Create another object of this type ValueFunctionPressure *pClone = CreateInstance(); if (pClone != NULL) { // If that worked, make it allocate an array large enough to hold a copy of // our data, and memcpy the array across. if (pClone->ExpandArray(NextFree)) { // We only copy the used array entries so the clone will have no wasted space in it memcpy(pClone->pArray, pArray, NextFree * sizeof(VFPressureRecord)); pClone->NextFree = NextFree; pClone->ArraySize = NextFree; } } return(pClone); }

ValueFunction * ValueFunctionPressure::CreateAndReadFileRecord (  CXaraFileRecord *  pInputRecord  )  [protected, virtual]

Loads a ValueFunction object from a record which was saved into a file using the WriteFileRecord call. This is called by the base class loader routine ReadFileRecord, which finds an appropriate instance of a derived class to call to load the data in question. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/97 Parameters: pInputRecord  - The file record to read [INPUTS] Returns: NULL if it failed, else a pointer to new ValueFunction object representing whatever was saved in that record. This method creates a new instance of this particular ValueFunction class and then loads whatever information is necessary from the file to initialise itself properly. The record read-pointer is left pointing at the end of the ValueFunction-saved data so that the caller can continue reading their extra bytes of data after loading the ValueFunction. See also: ValueFunctionPressure::WriteFileRecord Implements ValueFunction. Definition at line 3242 of file valfunc.cpp. { ERROR3IF(pInputRecord == NULL, "Illegal NULL param"); UINT32 NumEntries = 0; pInputRecord->ReadUINT32(&NumEntries); ValueFunctionPressure *pValFunc = CreateInstance(); if (pValFunc != NULL && NumEntries > 0) { // Make the array big enough to hold all the entries, to save reallocing it as we go, // and also to save us having to check for failure on each pressure item we add. if (!pValFunc->ExpandArray(NumEntries)) { delete pValFunc; return(NULL); } UINT16 Position; UINT16 Pressure; for (UINT32 i = 0; i < NumEntries; i++) { pInputRecord->ReadUINT16(&Position); pInputRecord->ReadUINT16(&Pressure); pValFunc->AddPressure( ((float)Position) / (float) 65535.0, ((float)Pressure) / (float) 65535.0); } } return(pValFunc); }

ValueFunctionPressure * ValueFunctionPressure::CreateInstance (  void   )  [protected, virtual]

Creates a new blank object of the same type as this one. Internal function used in ValueFunctionPressure & ValueFunctionPressureS. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/97 Returns: NULL if it failed, else a pointer to new ValueFunctionPressure object of the same type as "this" one. Used to allow derived Pressure classes to use all the base class code, and merely override the GetValue method. Notes: Called by ValueFunctionPressure::Clone and CreateAndReadFileRecord, as this is the only action in those functions that depends on the type of the class that is being used Reimplemented in ValueFunctionPressureS. Definition at line 3298 of file valfunc.cpp. { return(new ValueFunctionPressure); }

BOOL ValueFunctionPressure::ExpandArray (  INT32  NewSize  )  [protected]

Ensures that the pressure storage array has no fewer than NewSize entries. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Parameters: NewSize  - The number of array entries desired. [INPUTS] Returns: FALSE if memory was unavailable Notes: For efficiency, unused array entries are always left uninitialised Definition at line 3103 of file valfunc.cpp. { if (NewSize <= ArraySize) return(TRUE); // That was easy! VFPressureRecord *pNewArray = NULL; if (pArray == NULL) pNewArray = (VFPressureRecord *) CCMalloc(NewSize * sizeof(VFPressureRecord)); else pNewArray = (VFPressureRecord *) CCRealloc(pArray, NewSize * sizeof(VFPressureRecord)); if (pNewArray == NULL) return(FALSE); // We succeeded, so remember the new address & size pArray = pNewArray; ArraySize = NewSize; return(TRUE); }

virtual ValueFunctionID ValueFunctionPressure::GetUniqueID (  void   )  [inline, virtual]

Implements ValueFunction. Reimplemented in ValueFunctionPressureS. Definition at line 879 of file valfunc.h. { return(ValueFunctionID_Pressure); };

double ValueFunctionPressure::GetValue (  double  Position  )  [virtual]

To read the value of this function at a given position. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Parameters: Position  - A value between 0.0 and 1.0 [INPUTS] Returns: A value representing the recorded pressure at the given Position. Notes: This determines the 2 closest position values for which pressure information was recorded, and interpolates the values by "fitting a curve" through the points. The "curve" may be improved in future, but is currently a simple linear interpolation. !!!!TODO: This should cache the last array index it was asked for, and start the search from that index, as we usually ask for values for sequential, close, position values, and this will vastly reduce the searching overhead in most cases. Note that we may step through positions in both positive & negative directions, so it will have to handle this carefully. Implements ValueFunction. Reimplemented in ValueFunctionPressureS. Definition at line 2876 of file valfunc.cpp. { // No entries have been recorded! if (NextFree < 1) return(0.0); // If the position is outside the range in our table, return the closest entry if (Position <= pArray[0].Position) return(pArray[0].Pressure); if (Position >= pArray[NextFree-1].Position) return(pArray[NextFree-1].Pressure); // Search to find the closest 2 array entries to the position // We assume the array fills the 0.0 to 1.0 range, so we search from the closest // "end" of the array to halve the average search time. INT32 i; if (Position >= 0.5) { i = NextFree; while (i > 1 && Position < pArray[i-1].Position) i--; } else { i = 1; while (i < NextFree && Position > pArray[i].Position) i++; } ERROR3IF(i < 1 || i >= NextFree, "I've screwed up the scanning loop code"); // Otherwise, the position lies between array elements [i-1] and [i], so we // interpolate between these positions ERROR3IF((pArray[i].Position - pArray[i-1].Position) <= 0.0, "Pressure array is non-ascending!"); const double MixValue = (Position - pArray[i-1].Position) / (pArray[i].Position - pArray[i-1].Position); return((MixValue * pArray[i].Pressure) + ((1.0 - MixValue) * pArray[i-1].Pressure)); }

BOOL ValueFunctionPressure::IsDifferent (  ValueFunction *  pOther  )  [virtual]

Comparator. Determines if 2 different ValueFunction objects are considered different. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Parameters: pOther  - Another ValueFunction object to compare this one to [INPUTS] Returns: TRUE if the objects are considered different, FALSE if they are considered identical Notes: Calls the base class to see if they are different classes, and then compares identical classes by checking member vars Reimplemented from ValueFunction. Definition at line 2976 of file valfunc.cpp. { if (ValueFunction::IsDifferent(pOther)) return(TRUE); // Both objects are instances of this class, so compare them more carefully ValueFunctionPressure *pPressure = (ValueFunctionPressure *)pOther; if (NextFree != pPressure->NextFree) return(TRUE); // Don't have same number of entries // Now compare the entire array for (INT32 i = 0; i < NextFree; i++) { if (pArray[i].Position != pPressure->pArray[i].Position || pArray[i].Pressure != pPressure->pArray[i].Pressure) { return(TRUE); } } // Cor. They must be the same! return(FALSE); }

void ValueFunctionPressure::NormalisePositions (  void   )

Normalises all positions in the table to lie within a 0.0 to 1.0 range, by dividing them by the last element position value. (i.e. it assumes that the last element in the array will have the largest Position value). Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 20/1/97 Definition at line 3066 of file valfunc.cpp. { // If fewer than 1 entries, or no array, then there's nothing to do if (pArray == NULL || NextFree < 1) return; // Find the maximum value, and baulk if it would cause a divide by zero. if (pArray[NextFree-1].Position <= 0.0) { ERROR3("Max position in table is zero or negative - normalisation failed"); return; } float RMaxPosition = 1.0/pArray[NextFree-1].Position; for (INT32 i = 0; i < NextFree; i++) pArray[i].Position *= RMaxPosition; }

CamelotFileRecord * ValueFunctionPressure::WriteFileRecord (  INT32  RecordTag, INT32  ExtraBytes, BaseCamelotFilter *  pFilter )  [virtual]

Saves a ValueFunction object to a Xara file. This function will create a new variable-sized record with the given record tag, and will write out whatever data is needed to save this ValueFunction's state to the file. Author: Jason_Williams (Xara Group Ltd) <camelotdev@xara.com> Date: 27/1/97 Parameters: RecordTag  - the tag to write this record under [INPUTS] ExtraBytes - The number of extra bytes of information the caller will write into the record after caling this function (Space for this many extra bytes will be reserved by this function when it creates the new file record) This may be 0 or more bytes. pFilter - The filter to write to Returns: NULL if it failed, else a pointer to a record which saves the state of this valueFunction object. Once the caller has written the record, they MUST DELETE it. "ExtraBytes" bytes will be added to the record size to reserve space at the end of the record for the caller to add their own data. This is to allow ValueFunctions to be saved embedded in other object's record structures (e.g. inside different types of attributes). All ValueFunction record data has 3 sections, whiich are recorded as follows: 1. ValueFunction header, identifying which type of VF is being saved INT32 ValueFunctionUniqueID (4 bytes) 2. Derived-class-data (0 or more bytes). This particular class adds: UINT32 NumTableEntries + n entries of the form: UNIT16 Position UINT16 Pressure (4 + (NumTableEntries*4) bytes) 3. Caller data. This is written by the caller to the returned record object. This data must be ExtraBytes (0 or more) bytes in length. The Position & Pressure values are 16-bit unsigned values between 0 & 65535. These represent floating point values between 0.0 & 1.0, i.e. are simply a (UINT16) (Value * 65535.0). I don't bother avoiding rounding errors, as 1/128000th is an insignificant error. See also: ValueFunctionPressure::CreateAndReadFileRecord; ValueFunction::CreateAndWriteFileRecord Implements ValueFunction. Definition at line 3178 of file valfunc.cpp. { ERROR3IF(pFilter == NULL, "Illegal NULL param"); ERROR3IF(ExtraBytes < 0, "Stupid ExtraBytes request in ValueFunction::WriteFileRecord"); // Calculate how many bytes of information this VF will write. We do not include // the header info written by the base class or the ExtraInfo desired by the caller - // the base class adds all that in for us. const INT32 MyRecordSize = 4 + (4 * NextFree); // Create an appropriate record, and write our data to it CamelotFileRecord *pRec = CreateAndWriteFileRecord(RecordTag, MyRecordSize, ExtraBytes, pFilter); if (pRec != NULL) { BOOL ok = TRUE; if (ok) ok = pRec->WriteUINT32((UINT32) NextFree); for (INT32 i = 0; (i < NextFree) && ok; i++) { if (ok) ok = pRec->WriteUINT16((UINT16) (pArray[i].Position * 65535.0)); if (ok) ok = pRec->WriteUINT16((UINT16) (pArray[i].Pressure * 65535.0)); } if (!ok) // If we failed, clean up & return NULL { delete pRec; pRec = NULL; } } return(pRec); }

---

Member Data Documentation

INT32 ValueFunctionPressure::ArraySize [protected]

Definition at line 896 of file valfunc.h.

INT32 ValueFunctionPressure::NextFree [protected]

Definition at line 897 of file valfunc.h.

VFPressureRecord* ValueFunctionPressure::pArray [protected]

Definition at line 895 of file valfunc.h.

---

The documentation for this class was generated from the following files:

• Kernel/valfunc.h (r1785/r1282)
• Kernel/valfunc.cpp (r1785/r1517)

---