Menu
▾
▴
[Qcell-commitlogs] SF.net SVN: qcell: [68] trunk/qcell
|
From: <le...@us...> - 2006-12-19 15:08:39
|
Revision: 68
http://svn.sourceforge.net/qcell/?rev=68&view=rev
Author: lessm
Date: 2006-12-19 06:58:48 -0800 (Tue, 19 Dec 2006)
Log Message:
-----------
- Calculator and Renderer class add
Modified Paths:
--------------
trunk/qcell/baseheaders/BaseDataTypes.h
trunk/qcell/baseheaders/CalculationData.h
trunk/qcell/baseheaders/LocalFunction.h
trunk/qcell/baseheaders/Neighbourhood.h
trunk/qcell/basesources/CalculationData.cpp
trunk/qcell/basesources/Client.cpp
trunk/qcell/basesources/LocalFunction.cpp
trunk/qcell/basesources/Neighbourhood.cpp
trunk/qcell/bin/ServerConfig.xml
trunk/qcell/client/main.cpp
Added Paths:
-----------
trunk/qcell/baseheaders/Calculator.h
trunk/qcell/baseheaders/Renderer.h
trunk/qcell/basesources/Calculator.cpp
trunk/qcell/basesources/Renderer.cpp
Modified: trunk/qcell/baseheaders/BaseDataTypes.h
===================================================================
--- trunk/qcell/baseheaders/BaseDataTypes.h 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/baseheaders/BaseDataTypes.h 2006-12-19 14:58:48 UTC (rev 68)
@@ -1,18 +1,23 @@
#ifndef _BASE_DATA_TYPES
#define _BASE_DATA_TYPES
-class baseDataTypes
+#include <QObject>
+
+class baseDataTypes : QObject
{
+ Q_OBJECT
+private:
+protected:
public:
enum DATA_TYPES
{
- BOOL,
- CHAR,
- SHORT,
- INT,
- FLOAT,
- DOUBLE,
- NONE
+ BOOL = 0,
+ CHAR = 1,
+ SHORT = 2,
+ INT = 3,
+ FLOAT = 4,
+ DOUBLE = 5,
+ NONE = 6
};
};
Modified: trunk/qcell/baseheaders/CalculationData.h
===================================================================
--- trunk/qcell/baseheaders/CalculationData.h 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/baseheaders/CalculationData.h 2006-12-19 14:58:48 UTC (rev 68)
@@ -1,33 +1,29 @@
#ifndef _CALCULATION_DATA
#define _CALCULATION_DATA
+#include <QObject>
#include <string.h>
#include <QString>
+#include <QVector>
#include <QDomDocument>
#include <QDomElement>
#include "BaseDataTypes.h"
class CalculationData : public baseDataTypes
{
+ Q_OBJECT
private:
+protected:
DATA_TYPES dataType;
int sizeX, sizeY, sizeZ, sizeT;
- int backBufferSizeX, backBufferSizeY, backBufferSizeZ, backBufferSizeT;
- int dimension, size;
- char *data, *dataBorderFree;
+ int dimension, dataSize;
+ char *data;
+ bool haveForeignDataPointer;
- int minX, minY, minZ, minT;
- int maxX, maxY, maxZ, maxT;
-
- bool borderExist;
-
protected:
-//public:
- bool resize(const char *dataPointer=NULL);
+ void clearData(void);
+ bool resize(bool foreignDataPointer=0, char *dataPointer=NULL);
void * getAddressAt(int x, int y, int z, int t);
- void * getAddressAtBackBuffer(int x, int y, int z, int t);
- void calculateBackBufferSize(void);
- void copyData(void);
public:
@@ -38,67 +34,54 @@
int getValueAt_i(int x, int y);
int getValueAt_i(int x, int y, int z);
int getValueAt_i(int x, int y, int z, int t);
+ int getValueAt_i(QVector<int> pos);
- void setValueAt_i(int val, int x);
- void setValueAt_i(int val, int x, int y);
- void setValueAt_i(int val, int x, int y, int z);
- void setValueAt_i(int val, int x, int y, int z, int t);
+ void setValueAt(int val, int x);
+ void setValueAt(int val, int x, int y);
+ void setValueAt(int val, int x, int y, int z);
+ void setValueAt(int val, int x, int y, int z, int t);
+ void setValueAt(int val, QVector<int> pos);
double getValueAt_d(int x);
double getValueAt_d(int x, int y);
double getValueAt_d(int x, int y, int z);
double getValueAt_d(int x, int y, int z, int t);
+ double getValueAt_d(QVector<int> pos);
- void setValueAt_d(double val, int x);
- void setValueAt_d(double val, int x, int y);
- void setValueAt_d(double val, int x, int y, int z);
- void setValueAt_d(double val, int x, int y, int z, int t);
+ void setValueAt(double val, int x);
+ void setValueAt(double val, int x, int y);
+ void setValueAt(double val, int x, int y, int z);
+ void setValueAt(double val, int x, int y, int z, int t);
+ void setValueAt(double val, QVector<int> pos);
- void setDataType(baseDataTypes::DATA_TYPES type = baseDataTypes::DATA_TYPES::CHAR);
+ void setDataType(baseDataTypes::DATA_TYPES type = baseDataTypes::CHAR);
baseDataTypes::DATA_TYPES getDataType(void);
int getDataSize(void);
- bool resize(int x, const char *dataPointer=NULL);
- bool resize(int x, int y, const char *dataPointer=NULL);
- bool resize(int x, int y, int z, const char *dataPointer=NULL);
- bool resize(int x, int y, int z, int t, const char *dataPointer=NULL);
+ bool resize(int x, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(int x, int y, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(int x, int y, int z, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(int x, int y, int z, int t, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(QVector<int> newSize, char *dataPointer=NULL, bool foreignDataPointer=0);
int getSizeX(void);
int getSizeY(void);
int getSizeZ(void);
int getSizeT(void);
int getSizeInByte(void);
+ int getDimension(void);
const char *getDataPointer(void);
- const char *getBackBufferDataPointer(void);
- void fill(const char *dataPointer);
+ void fillData(const char *dataPointer);
+ void setForeignDataPointer(char *dataPointer);
-
- void setCalculationSpace(bool noDataCopy=0);
- void setCalculationSpace(int startX, int endX, bool noDataCopy=0);
- void setCalculationSpace(int startX, int startY, int endX, int endY, bool noDataCopy=0);
- void setCalculationSpace(int startX, int startY, int startZ, int endX, int endY, int endZ, bool noDataCopy=0);
- void setCalculationSpace(int startX, int startY, int startZ, int startT, int endX, int endY, int endZ, int endT, bool noDataCopy=0);
-
- bool haveBorder(void);
-
QString createXmlHeader(void);
- void setFromXmlString(QString *xmlString);
- void parseXmlElement(QDomElement *root);
+ bool setFromXmlString(QString *xmlString);
+ bool parseXmlElement(QDomElement *root);
- void setValueAt_i_Back(int val, int x);
- void setValueAt_i_Back(int val, int x, int y);
- void setValueAt_i_Back(int val, int x, int y, int z);
- void setValueAt_i_Back(int val, int x, int y, int z, int t);
+ CalculationData & operator = (CalculationData &cData);
- void setValueAt_d_Back(double val, int x);
- void setValueAt_d_Back(double val, int x, int y);
- void setValueAt_d_Back(double val, int x, int y, int z);
- void setValueAt_d_Back(double val, int x, int y, int z, int t);
- void fillData_i(int val=0);
- void fillData_d(double val=0.0);
-
};
#endif
Added: trunk/qcell/baseheaders/Calculator.h
===================================================================
--- trunk/qcell/baseheaders/Calculator.h (rev 0)
+++ trunk/qcell/baseheaders/Calculator.h 2006-12-19 14:58:48 UTC (rev 68)
@@ -0,0 +1,41 @@
+#ifndef _CALCULATOR_H
+#define _CALCULATOR_H
+
+#include "CalculationData.h"
+#include "Neighbourhood.h"
+#include "LocalFunction.h"
+#include <QByteArray>
+#include <QVector>
+#include <QObject>
+
+class Calculator : public CalculationData
+{
+ Q_OBJECT
+private:
+protected:
+ char *outData;
+ bool haveForeignOutputDataPointer;
+ QVector<int> outDataSize, calculationSpaceStart, calculationSpaceEnd;
+ Neighbourhood *neighbourhood;
+ LocalFunction *localfunction;
+
+protected:
+ void clearOutputData(void);
+ void copyData(void);
+ bool resizeOutputDataBuffer(bool dataCopy=0, char *dataPointer=NULL);
+
+public:
+ Calculator();
+ ~Calculator();
+
+ void setNeighbourhood(Neighbourhood *n);
+ void setLocalFunction(LocalFunction *f);
+
+ bool setCalculationSpace(QVector<int> start, QVector<int> end, bool dataCopy=0, char *foreignDataPointer=NULL);
+ int getOutputDataSizeInByte(void);
+ const char *getOutputDataPointer(void);
+
+ void calculate(void);
+};
+
+#endif
Modified: trunk/qcell/baseheaders/LocalFunction.h
===================================================================
--- trunk/qcell/baseheaders/LocalFunction.h 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/baseheaders/LocalFunction.h 2006-12-19 14:58:48 UTC (rev 68)
@@ -7,9 +7,10 @@
#include <QDomElement>
#include <QDomText>
#include <QStringList>
-
#include <math.h>
+//#include <Python.h>
+
class LocalFunction
{
@@ -19,16 +20,13 @@
{
SWITCH,
SUM,
- MIXED_SUM_SWITCH,
- PRODUCT,
- MIXED_PRODUCT_SWITCH,
+ SUM_AND_SWITCH,
SCRIPT
};
private:
QVector<int> valueTable;
- QVector<int> sumArguments;
- QVector<int> productArguments;
+ QVector< QVector<int> > sumArguments;
QVector<int> freeArguments;
FUNCTION_TYPE functionMode;
int numArg, maxArgVal, numElements;
@@ -38,15 +36,18 @@
//public:
void resizeValueTable(void);
int mostPopularValue(void);
+ QVector<int> calculateSums(QVector<int> &args);
+ QVector<int> calculateSwitchArguments(QVector<int> &args);
+ int calculateSumsIndex(QVector<int> args);
+ int calculateSwitchIndex(QVector<int> args);
+
QString valueTableToString(void);
QString valueTableToString(int fillValue);
-
QString sumArgumentsToString(void);
- QString productArgumentsToString(void);
void valueTableFromString(QString *string);
void sumArgumentsFromString(QString *string);
- void productArgumentsFromString(QString *string);
+
public:
LocalFunction();
@@ -54,11 +55,12 @@
void init(int numberOfArguments, int alphabetSize);
- // args is vector contein index of arguments to sum
+ // args is vector contein index of arguments to sum
+ void addSumArguments(QVector<int> args);
void setSumArguments(QVector<int> args);
+ void setFreeArguments(QVector<int> args);
+ void setFreeArguments(void);
- void setProductArguments(QVector<int> args);
-
void setSwitchFunction(void);
//
@@ -73,12 +75,13 @@
// fill value table with val
void setDefaultValue(int val);
- // first value is sum or product if function have sum or product arguments
- //
- bool addFunctionValue(int value, QVector<int> args);
+ // first value is sum if function have sum arguments
+ bool setFunctionValue(int value, int sum);
+ bool setFunctionValue(int value, QVector<int> args);
+ bool setFunctionValue(int value, int sum, QVector<int> freeArgs);
+ bool setFunctionValue(int value, QVector<int> sums, QVector<int> freeArgs);
int resolve(QVector<int> arg);
-
double resolve(QVector<double> arg);
QString toXmlString(void);
Modified: trunk/qcell/baseheaders/Neighbourhood.h
===================================================================
--- trunk/qcell/baseheaders/Neighbourhood.h 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/baseheaders/Neighbourhood.h 2006-12-19 14:58:48 UTC (rev 68)
@@ -58,8 +58,8 @@
void calculateOffsets(int sizeX, int sizeY, int sizeZ, int sizeT, baseDataTypes::DATA_TYPES type);
void resolveValues(const char *address);
+ QVector<int> valuesToVector_i(void);
+ QVector<double> valuesToVector_d(void);
};
-
-
#endif
Added: trunk/qcell/baseheaders/Renderer.h
===================================================================
--- trunk/qcell/baseheaders/Renderer.h (rev 0)
+++ trunk/qcell/baseheaders/Renderer.h 2006-12-19 14:58:48 UTC (rev 68)
@@ -0,0 +1,49 @@
+#ifndef _RENDERER_H
+#define _RENDERER_H
+
+#include "CalculationData.h"
+#include <QVector>
+#include <QColor>
+#include <QGLPixelBuffer>
+#include <QGLFramebufferObject>
+#include <QGLWidget>
+#include <QImage>
+#include <QPainter>
+#include <QObject>
+
+class Renderer : public CalculationData, public QGLWidget
+{
+ Q_OBJECT
+private:
+protected:
+ QVector<QColor> ColorMap;
+ QGLPixelBuffer *OGLpBuffer;
+ bool discretValues;
+
+ QImage render1D(void);
+ QImage render2D(void);
+ QImage render3D(void);
+
+public:
+ typedef enum RENDER_MODE
+ {
+ TEXT,
+ GRAPHICS
+ };
+
+ Renderer(QWidget *parent);
+ ~Renderer();
+
+ void setDataType(baseDataTypes::DATA_TYPES type = baseDataTypes::CHAR);
+
+ bool resize(int x, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(int x, int y, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(int x, int y, int z, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(int x, int y, int z, int t, char *dataPointer=NULL, bool foreignDataPointer=0);
+ bool resize(QVector<int> newSize, char *dataPointer=NULL, bool foreignDataPointer=0);
+
+ QImage renderToQImage(void);
+ void setColorInMap(int value, QColor color);
+};
+
+#endif
Modified: trunk/qcell/basesources/CalculationData.cpp
===================================================================
--- trunk/qcell/basesources/CalculationData.cpp 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/basesources/CalculationData.cpp 2006-12-19 14:58:48 UTC (rev 68)
@@ -1,164 +1,51 @@
#include "../baseheaders/CalculationData.h"
-bool CalculationData::resize(const char *dataPointer)
+void CalculationData::clearData(void)
{
- borderExist = 0;
- if(data)
- delete[] data;
+ if(!haveForeignDataPointer && data)
+ delete data;
- data = new char[getSizeInByte()];
- if(!data)
- return 0;
-
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- dataBorderFree = NULL;
- }
-
- if(dataPointer)
- fill(dataPointer);
- return 1;
+ data = NULL;
}
-void * CalculationData::getAddressAt(int x, int y, int z, int t)
+bool CalculationData::resize(bool foreignDataPointer, char *dataPointer)
{
- int dSize;
- if(dataType==baseDataTypes::DATA_TYPES::NONE)
- return NULL;
- switch(dataType)
+ clearData();
+ if(!foreignDataPointer)
{
- case baseDataTypes::DATA_TYPES::BOOL:
- dSize = sizeof(char);
- break;
+ data = new char[getSizeInByte()];
+ if(!data)
+ return 0;
- case baseDataTypes::DATA_TYPES::CHAR:
- dSize = 1;
- break;
+ if(dataPointer)
+ fillData(dataPointer);
- case baseDataTypes::DATA_TYPES::INT:
- dSize = sizeof(int);
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- dSize = sizeof(short);
- break;
-
- case baseDataTypes::DATA_TYPES::DOUBLE:
- dSize = sizeof(double);
- break;
- case baseDataTypes::DATA_TYPES::FLOAT:
- dSize = sizeof(float);
- break;
+ haveForeignDataPointer = 0;
}
-
- return data + dSize * (x + y * sizeX + z * sizeX * sizeY + t * sizeX * sizeY * sizeZ);
+ else
+ {
+ data = dataPointer;
+ haveForeignDataPointer = 1;
+ }
+ return 1;
}
-void * CalculationData::getAddressAtBackBuffer(int x, int y, int z, int t)
+void * CalculationData::getAddressAt(int x, int y, int z, int t)
{
int dSize;
if(dataType==baseDataTypes::DATA_TYPES::NONE)
return NULL;
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
- break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- dSize = sizeof(char);
- break;
-
- case baseDataTypes::DATA_TYPES::INT:
- dSize = sizeof(int);
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- dSize = sizeof(short);
- break;
-
- case baseDataTypes::DATA_TYPES::DOUBLE:
- dSize = sizeof(double);
- break;
- case baseDataTypes::DATA_TYPES::FLOAT:
- dSize = sizeof(float);
- break;
- }
-
- x -= minX;
- y -= minY;
- z -= minZ;
- t -= minT;
-
- if(t<0)
- t=0;
- if(z<0)
- z=0;
- if(y<0)
- y=0;
- if(x<0)
- x=0;
-
- //int index = dSize * (x + y * backBufferSizeX + z * backBufferSizeX * backBufferSizeY + t * backBufferSizeX * backBufferSizeY * backBufferSizeZ);
-
- return dataBorderFree + dSize * (x + y * backBufferSizeX + z * backBufferSizeX * backBufferSizeY + t * backBufferSizeX * backBufferSizeY * backBufferSizeZ);
+ return data + dataSize * (x + y * sizeX + z * sizeX * sizeY + t * sizeX * sizeY * sizeZ);
}
-void CalculationData::calculateBackBufferSize(void)
-{
- switch(dimension)
- {
- case 4:
- backBufferSizeT = (maxT - minT) + 1;
- case 3:
- backBufferSizeZ = (maxZ - minZ) + 1;
- case 2:
- backBufferSizeY = (maxY - minY) + 1;
- case 1:
- backBufferSizeX = (maxX - minX) + 1;
- }
-
- if(maxX<0)
- maxX=0;
-
- if(maxY<0)
- maxY=0;
-
- if(maxZ<0)
- maxZ=0;
-
- if(maxT<0)
- maxT=0;
-}
-
-void CalculationData::copyData(void)
-{
- int counterF=0, counterB=0;
- for(int t=minT;t<=maxT;++t)
- {
- for(int z=minZ;z<=maxZ;++z)
- {
- for(int y=minY;y<=maxY;++y)
- {
- counterF += minX * size;
- memcpy(dataBorderFree + counterB, data + counterF, backBufferSizeX * size);
- counterF += (sizeX - minX) * size;
- counterB += backBufferSizeX * size;
- }
- }
- }
-}
-
CalculationData::CalculationData()
{
dataType = baseDataTypes::DATA_TYPES::NONE;
sizeX = sizeY = sizeZ = sizeT = 0;
dimension = -1;
- size = -1;
+ dataSize = 0;
data = NULL;
- dataBorderFree = NULL;
- borderExist = 0;
+ haveForeignDataPointer = 0;
}
CalculationData::~CalculationData()
@@ -166,17 +53,8 @@
dataType = baseDataTypes::DATA_TYPES::NONE;
sizeX = sizeY = sizeZ = sizeT = 0;
dimension = -1;
- size = -1;
- if(data)
- {
- delete[] data;
- data = NULL;
- }
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- dataBorderFree = NULL;
- }
+ dataSize = 0;
+ clearData();
}
int CalculationData::getValueAt_i(int x)
@@ -184,19 +62,24 @@
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
- case baseDataTypes::DATA_TYPES::CHAR:
+ case baseDataTypes::CHAR:
return *((char *)getAddressAt(x, 0, 0, 0));
- case baseDataTypes::DATA_TYPES::INT:
+ case baseDataTypes::INT:
return *((int *)(getAddressAt(x, 0, 0, 0)));
- case baseDataTypes::DATA_TYPES::SHORT:
+ case baseDataTypes::SHORT:
return *((short *)(getAddressAt(x, 0, 0, 0)));
+
+ case baseDataTypes::FLOAT:
+ return (int)(*((float *)(getAddressAt(x, 0, 0, 0))));
+
+ case baseDataTypes::DOUBLE:
+ return (int)(*((double *)(getAddressAt(x, 0, 0, 0))));
}
- return -1;
+ return 0;
}
int CalculationData::getValueAt_i(int x, int y)
@@ -204,7 +87,6 @@
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -215,8 +97,13 @@
case baseDataTypes::DATA_TYPES::SHORT:
return *((short *)(getAddressAt(x, y, 0, 0)));
+ case baseDataTypes::FLOAT:
+ return (int)(*((float *)(getAddressAt(x, y, 0, 0))));
+
+ case baseDataTypes::DOUBLE:
+ return (int)(*((double *)(getAddressAt(x, y, 0, 0))));
}
- return -1;
+ return 0;
}
int CalculationData::getValueAt_i(int x, int y, int z)
@@ -224,7 +111,6 @@
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -235,8 +121,14 @@
case baseDataTypes::DATA_TYPES::SHORT:
return *((short *)(getAddressAt(x, y, z, 0)));
+
+ case baseDataTypes::FLOAT:
+ return (int)(*((float *)(getAddressAt(x, y, z, 0))));
+
+ case baseDataTypes::DOUBLE:
+ return (int)(*((double *)(getAddressAt(x, y, z, 0))));
}
- return -1;
+ return 0;
}
int CalculationData::getValueAt_i(int x, int y, int z, int t)
@@ -244,7 +136,6 @@
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -255,16 +146,38 @@
case baseDataTypes::DATA_TYPES::SHORT:
return *((short *)(getAddressAt(x, y, z, t)));
+
+ case baseDataTypes::FLOAT:
+ return (int)(*((float *)(getAddressAt(x, y, z, t))));
+
+ case baseDataTypes::DOUBLE:
+ return (int)(*((double *)(getAddressAt(x, y, z, t))));
+
}
- return -1;
+ return 0;
}
-void CalculationData::setValueAt_i(int val, int x)
+int CalculationData::getValueAt_i(QVector<int> pos)
{
+ switch(pos.size())
+ {
+ case 1:
+ return getValueAt_i(pos[0]);
+ case 2:
+ return getValueAt_i(pos[0], pos[1]);
+ case 3:
+ return getValueAt_i(pos[0], pos[1], pos[2]);
+ case 4:
+ return getValueAt_i(pos[0], pos[1], pos[2], pos[3]);
+ }
+ return 0;
+}
+
+void CalculationData::setValueAt(int val, int x)
+{
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -281,12 +194,11 @@
}
}
-void CalculationData::setValueAt_i(int val, int x, int y)
+void CalculationData::setValueAt(int val, int x, int y)
{
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -303,12 +215,11 @@
}
}
-void CalculationData::setValueAt_i(int val, int x, int y, int z)
+void CalculationData::setValueAt(int val, int x, int y, int z)
{
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -325,12 +236,11 @@
}
}
-void CalculationData::setValueAt_i(int val, int x, int y, int z, int t)
+void CalculationData::setValueAt(int val, int x, int y, int z, int t)
{
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
break;
case baseDataTypes::DATA_TYPES::CHAR:
@@ -351,56 +261,120 @@
{
switch(dataType)
{
+ case baseDataTypes::DATA_TYPES::BOOL:
+ break;
+
+ case baseDataTypes::DATA_TYPES::CHAR:
+ return (double)*((char *)getAddressAt(x, 0, 0, 0));
+
+ case baseDataTypes::DATA_TYPES::INT:
+ return (double)*((int *)(getAddressAt(x, 0, 0, 0)));
+
+ case baseDataTypes::DATA_TYPES::SHORT:
+ return (double)*((short *)(getAddressAt(x, 0, 0, 0)));
+
case baseDataTypes::DATA_TYPES::DOUBLE:
return *((double *)(getAddressAt(x, 0, 0, 0)));
case baseDataTypes::DATA_TYPES::FLOAT:
return *((float *)(getAddressAt(x, 0, 0, 0)));
}
- return -1;
+ return 0.0;
}
double CalculationData::getValueAt_d(int x, int y)
{
switch(dataType)
{
+ case baseDataTypes::DATA_TYPES::BOOL:
+ break;
+
+ case baseDataTypes::DATA_TYPES::CHAR:
+ return (double)*((char *)getAddressAt(x, y, 0, 0));
+
+ case baseDataTypes::DATA_TYPES::INT:
+ return (double)*((int *)(getAddressAt(x, y, 0, 0)));
+
+ case baseDataTypes::DATA_TYPES::SHORT:
+ return (double)*((short *)(getAddressAt(x, y, 0, 0)));
+
case baseDataTypes::DATA_TYPES::DOUBLE:
return *((double *)(getAddressAt(x, y, 0, 0)));
case baseDataTypes::DATA_TYPES::FLOAT:
return *((float *)(getAddressAt(x, y, 0, 0)));
}
- return -1;
+ return 0.0;
}
double CalculationData::getValueAt_d(int x, int y, int z)
{
switch(dataType)
{
+ case baseDataTypes::DATA_TYPES::BOOL:
+ break;
+
+ case baseDataTypes::DATA_TYPES::CHAR:
+ return (double)*((char *)getAddressAt(x, y, z, 0));
+
+ case baseDataTypes::DATA_TYPES::INT:
+ return (double)*((int *)(getAddressAt(x, y, z, 0)));
+
+ case baseDataTypes::DATA_TYPES::SHORT:
+ return (double)*((short *)(getAddressAt(x, y, z, 0)));
+
case baseDataTypes::DATA_TYPES::DOUBLE:
return *((double *)(getAddressAt(x, y, z, 0)));
case baseDataTypes::DATA_TYPES::FLOAT:
return *((float *)(getAddressAt(x, y, z, 0)));
}
- return -1;
+ return 0.0;
}
double CalculationData::getValueAt_d(int x, int y, int z, int t)
{
switch(dataType)
{
+ case baseDataTypes::DATA_TYPES::BOOL:
+ break;
+
+ case baseDataTypes::DATA_TYPES::CHAR:
+ return (double)*((char *)getAddressAt(x, y, z, t));
+
+ case baseDataTypes::DATA_TYPES::INT:
+ return (double)*((int *)(getAddressAt(x, y, z, t)));
+
+ case baseDataTypes::DATA_TYPES::SHORT:
+ return (double)*((short *)(getAddressAt(x, y, z, t)));
+
case baseDataTypes::DATA_TYPES::DOUBLE:
return *((double *)(getAddressAt(x, y, z, t)));
case baseDataTypes::DATA_TYPES::FLOAT:
return *((float *)(getAddressAt(x, y, z, t)));
}
- return -1;
+ return 0.0;
}
-void CalculationData::setValueAt_d(double val, int x)
+double CalculationData::getValueAt_d(QVector<int> pos)
{
+ switch(pos.size())
+ {
+ case 1:
+ return getValueAt_d(pos[0]);
+ case 2:
+ return getValueAt_d(pos[0], pos[1]);
+ case 3:
+ return getValueAt_d(pos[0], pos[1], pos[2]);
+ case 4:
+ return getValueAt_d(pos[0], pos[1], pos[2], pos[3]);
+ }
+ return 0.0;
+}
+
+void CalculationData::setValueAt(double val, int x)
+{
switch(dataType)
{
case baseDataTypes::DATA_TYPES::DOUBLE:
@@ -413,7 +387,7 @@
}
}
-void CalculationData::setValueAt_d(double val, int x, int y)
+void CalculationData::setValueAt(double val, int x, int y)
{
switch(dataType)
{
@@ -427,7 +401,7 @@
}
}
-void CalculationData::setValueAt_d(double val, int x, int y, int z)
+void CalculationData::setValueAt(double val, int x, int y, int z)
{
switch(dataType)
{
@@ -441,7 +415,7 @@
}
}
-void CalculationData::setValueAt_d(double val, int x, int y, int z, int t)
+void CalculationData::setValueAt(double val, int x, int y, int z, int t)
{
switch(dataType)
{
@@ -458,31 +432,31 @@
void CalculationData::setDataType(DATA_TYPES type)
{
dataType = type;
- size = -1;
+ dataSize = 0;
switch(dataType)
{
- case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
+ case baseDataTypes::BOOL:
+ dataSize = 0;
break;
- case baseDataTypes::DATA_TYPES::CHAR:
- size = 1;
+ case baseDataTypes::CHAR:
+ dataSize = sizeof(char);
break;
- case baseDataTypes::DATA_TYPES::DOUBLE:
- size = sizeof(double);
+ case baseDataTypes::DOUBLE:
+ dataSize = sizeof(double);
break;
- case baseDataTypes::DATA_TYPES::FLOAT:
- size = sizeof(float);
+ case baseDataTypes::FLOAT:
+ dataSize = sizeof(float);
break;
- case baseDataTypes::DATA_TYPES::INT:
- size = sizeof(int);
+ case baseDataTypes::INT:
+ dataSize = sizeof(int);
break;
- case baseDataTypes::DATA_TYPES::SHORT:
- size = sizeof(short);
+ case baseDataTypes::SHORT:
+ dataSize = sizeof(short);
break;
}
}
@@ -493,49 +467,65 @@
}
int CalculationData::getDataSize(void)
{
- return size;
+ return dataSize;
}
-bool CalculationData::resize(int x, const char *dataPointer)
+bool CalculationData::resize(int x, char *dataPointer, bool foreignDataPointer)
{
sizeX = x;
sizeY = 0;
sizeZ = 0;
sizeT = 0;
dimension = 1;
- return resize(dataPointer);
+ return resize(foreignDataPointer, dataPointer);
}
-bool CalculationData::resize(int x, int y, const char *dataPointer)
+bool CalculationData::resize(int x, int y, char *dataPointer, bool foreignDataPointer)
{
sizeX = x;
sizeY = y;
sizeZ = 0;
sizeT = 0;
dimension = 2;
- return resize(dataPointer);
+ return resize(foreignDataPointer, dataPointer);;
}
-bool CalculationData::resize(int x, int y, int z, const char *dataPointer)
+bool CalculationData::resize(int x, int y, int z, char *dataPointer, bool foreignDataPointer)
{
sizeX = x;
sizeY = y;
sizeZ = z;
sizeT = 0;
dimension = 3;
- return resize(dataPointer);
+ return resize(foreignDataPointer, dataPointer);;
}
-bool CalculationData::resize(int x, int y, int z, int t, const char *dataPointer)
+bool CalculationData::resize(int x, int y, int z, int t, char *dataPointer, bool foreignDataPointer)
{
sizeX = x;
sizeY = y;
sizeZ = z;
sizeT = t;
dimension = 4;
- return resize(dataPointer);
+ return resize(foreignDataPointer, dataPointer);;
}
+bool CalculationData::resize(QVector<int> newSize, char *dataPointer, bool foreignDataPointer)
+{
+ switch(newSize.size())
+ {
+ case 1:
+ return resize(newSize[0], dataPointer, foreignDataPointer);
+ case 2:
+ return resize(newSize[1], newSize[2], dataPointer, foreignDataPointer);
+ case 3:
+ return resize(newSize[1], newSize[2], newSize[3], dataPointer, foreignDataPointer);
+ case 4:
+ return resize(newSize[1], newSize[2], newSize[3], newSize[4], dataPointer, foreignDataPointer);
+ }
+ return 0;
+}
+
int CalculationData::getSizeX(void)
{
return sizeX;
@@ -561,19 +551,19 @@
switch(dataType)
{
case baseDataTypes::DATA_TYPES::BOOL:
- return (sizeX * sizeY * sizeZ * sizeT)/8;
+ return (sizeX * sizeY * sizeZ * sizeT)/8 + 1;
case baseDataTypes::DATA_TYPES::CHAR:
switch(dimension)
{
case 1:
- return sizeX;
+ return sizeX * sizeof(char);
case 2:
- return sizeX * sizeY;
+ return sizeX * sizeY * sizeof(char);
case 3:
- return sizeX * sizeY * sizeZ;
+ return sizeX * sizeY * sizeZ * sizeof(char);
case 4:
- return sizeX * sizeY * sizeZ * sizeT;
+ return sizeX * sizeY * sizeZ * sizeT * sizeof(char);
}
case baseDataTypes::DATA_TYPES::DOUBLE:
@@ -631,493 +621,64 @@
return 0;
}
-const char *CalculationData::getDataPointer(void)
+int CalculationData::getDimension(void)
{
- return data;
+ return dimension;
}
-const char *CalculationData::getBackBufferDataPointer(void)
+const char *CalculationData::getDataPointer(void)
{
- return dataBorderFree;
+ return data;
}
-void CalculationData::fill(const char *dataPointer)
+void CalculationData::fillData(const char *dataPointer)
{
if(data!=NULL)
- {
memcpy(data, dataPointer, getSizeInByte());
- }
}
-void CalculationData::setCalculationSpace(bool noDataCopy)
+void CalculationData::setForeignDataPointer(char *dataPointer)
{
- minX = 0;
- minY = 0;
- minZ = 0;
- minT = 0;
-
- maxX = sizeX - 1;
- maxY = sizeY - 1;
- maxZ = sizeZ - 1;
- maxT = sizeT - 1;
-
- borderExist = 0;
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- }
- dataBorderFree = new char[getSizeInByte()];
- calculateBackBufferSize();
- if(!noDataCopy)
- copyData();
+ clearData();
+ data = dataPointer;
}
-void CalculationData::setCalculationSpace(int startX, int endX, bool noDataCopy)
+QString CalculationData::createXmlHeader(void)
{
- minX = startX;
- maxX = endX;
- minY = 0;
- maxY = 0;
- minZ = 0;
- maxZ = 0;
- minT = 0;
- maxT = 0;
- borderExist = 1;
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- }
- dataBorderFree = new char[((maxX - minX) + 1) * size];
- calculateBackBufferSize();
- if(!noDataCopy)
- copyData();
+ return QString();
}
-void CalculationData::setCalculationSpace(int startX, int startY, int endX, int endY, bool noDataCopy)
+bool CalculationData::setFromXmlString(QString *xmlString)
{
- minX = startX;
- maxX = endX;
- minY = startY;
- maxY = endY;
- minZ = 0;
- maxZ = 0;
- minT = 0;
- maxT = 0;
- borderExist = 1;
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- }
- dataBorderFree = new char[(((maxX - minX) + 1) * ((maxY - minY) + 1)) * size];
- calculateBackBufferSize();
- if(!noDataCopy)
- copyData();
+ return 1;
}
-void CalculationData::setCalculationSpace(int startX, int startY, int startZ, int endX, int endY, int endZ, bool noDataCopy)
+bool CalculationData::parseXmlElement(QDomElement *root)
{
- minX = startX;
- maxX = endX;
- minY = startY;
- maxY = endY;
- minZ = startZ;
- maxZ = endZ;
- minT = 0;
- maxT = 0;
- borderExist = 1;
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- }
- dataBorderFree = new char[(((maxX - minX) + 1) * ((maxY - minY) + 1) * ((maxZ - minZ) + 1)) * size];
- calculateBackBufferSize();
- if(!noDataCopy)
- copyData();
+ return 1;
}
-void CalculationData::setCalculationSpace(int startX, int startY, int startZ, int startT, int endX, int endY, int endZ, int endT, bool noDataCopy)
+CalculationData & CalculationData::operator = (CalculationData &cData)
{
- minX = startX;
- maxX = endX;
- minY = startY;
- maxY = endY;
- minZ = startZ;
- maxZ = endZ;
- minT = startT;
- maxT = endT;
- borderExist = 1;
- if(dataBorderFree)
- {
- delete[] dataBorderFree;
- }
- dataBorderFree = new char[(((maxX - minX) + 1) * ((maxY - minY) + 1) * ((maxZ - minZ) + 1) * ((maxT - minT) + 1)) * size];
- calculateBackBufferSize();
- if(!noDataCopy)
- copyData();
-}
+ clearData();
+ setDataType(cData.getDataType());
-bool CalculationData::haveBorder(void)
-{
- return borderExist;
-}
-
-QString CalculationData::createXmlHeader(void)
-{
- QDomDocument doc;
- QDomElement root, element, subElementMin, subElementMax;
- root = doc.createElement("CalculationData");
- doc.appendChild(root);
- element = doc.createElement("Data");
- switch(dimension)
+ switch(cData.getDimension())
{
- case 4:
- element.setAttribute("t", sizeT);
- case 3:
- element.setAttribute("z", sizeZ);
- case 2:
- element.setAttribute("y", sizeY);
case 1:
- element.setAttribute("x", sizeX);
- }
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- element.setAttribute("ContentType", "bool");
+ resize(cData.getSizeX());
break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- element.setAttribute("ContentType", "char");
+ case 2:
+ resize(cData.getSizeX(), cData.getSizeY());
break;
-
- case baseDataTypes::DATA_TYPES::DOUBLE:
- element.setAttribute("ContentType", "double");
+ case 3:
+ resize(cData.getSizeX(), cData.getSizeY(), cData.getSizeZ());
break;
-
- case baseDataTypes::DATA_TYPES::FLOAT:
- element.setAttribute("ContentType", "float");
+ case 4:
+ resize(cData.getSizeX(), cData.getSizeY(), cData.getSizeZ(), cData.getSizeT());
break;
-
- case baseDataTypes::DATA_TYPES::INT:
- element.setAttribute("ContentType", "bool");
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- element.setAttribute("ContentType", "short");
- break;
}
- root.appendChild(element);
- if(haveBorder())
- {
- element = doc.createElement("Border");
- subElementMin = doc.createElement("Min");
- subElementMax = doc.createElement("Max");
- switch(dimension)
- {
- case 4:
- subElementMin.setAttribute("t", minT);
- subElementMax.setAttribute("t", maxT);
- case 3:
- subElementMin.setAttribute("z", minZ);
- subElementMax.setAttribute("z", maxZ);
- case 2:
- subElementMin.setAttribute("y", minY);
- subElementMax.setAttribute("y", maxY);
- case 1:
- subElementMin.setAttribute("x", minX);
- subElementMax.setAttribute("x", maxX);
- }
- element.appendChild(subElementMin);
- element.appendChild(subElementMax);
- root.appendChild(element);
- }
- return doc.toString();
-}
-
-void CalculationData::setFromXmlString(QString *xmlString)
-{
- QDomDocument doc;
- QDomElement element;
- doc.setContent(*xmlString);
- element = doc.documentElement();
- parseXmlElement(&element);
-}
-
-void CalculationData::parseXmlElement(QDomElement *root)
-{
- QDomElement element, minElement, maxElement;
- QDomNode node, subNode;
-
- if(root->tagName()=="CalculationData")
- {
- node = root->firstChild();
- while(!node.isNull())
- {
- element = node.toElement();
- if(element.tagName()=="Data")
- {
- if(element.attribute("ContentType")=="bool")
- setDataType(baseDataTypes::DATA_TYPES::BOOL);
- else
- if(element.attribute("ContentType")=="char")
- setDataType(baseDataTypes::DATA_TYPES::CHAR);
- else
- if(element.attribute("ContentType")=="double")
- setDataType(baseDataTypes::DATA_TYPES::DOUBLE);
- else
- if(element.attribute("ContentType")=="float")
- setDataType(baseDataTypes::DATA_TYPES::FLOAT);
- else
- if(element.attribute("ContentType")=="int")
- setDataType(baseDataTypes::DATA_TYPES::INT);
- else
- if(element.attribute("ContentType")=="short")
- setDataType(baseDataTypes::DATA_TYPES::SHORT);
-
- if(element.hasAttribute("t"))
- resize(element.attribute("t").toInt(), element.attribute("z").toInt(), element.attribute("y").toInt(), element.attribute("x").toInt());
- else
- if(element.hasAttribute("z"))
- resize(element.attribute("z").toInt(), element.attribute("y").toInt(), element.attribute("x").toInt());
- else
- if(element.hasAttribute("y"))
- resize(element.attribute("y").toInt(), element.attribute("x").toInt());
- else
- resize(element.attribute("x").toInt());
-
- }
- if(element.tagName()=="Border")
- {
- subNode = element.firstChild();
- while(!subNode.isNull())
- {
- element = subNode.toElement();
- if(element.tagName()=="Min")
- minElement = subNode.toElement();
- else
- if(element.tagName()=="Max")
- maxElement = subNode.toElement();
- subNode = subNode.nextSibling();
- }
- switch(dimension)
- {
- case 1:
- setCalculationSpace(minElement.attribute("x").toInt(), maxElement.attribute("x").toInt());
- break;
- case 2:
- setCalculationSpace(minElement.attribute("x").toInt(), minElement.attribute("y").toInt(), maxElement.attribute("x").toInt(), maxElement.attribute("y").toInt());
- break;
- case 3:
- setCalculationSpace(minElement.attribute("x").toInt(), minElement.attribute("y").toInt(), minElement.attribute("z").toInt(), maxElement.attribute("x").toInt(), maxElement.attribute("y").toInt(), maxElement.attribute("z").toInt());
- break;
- case 4:
- setCalculationSpace(minElement.attribute("x").toInt(), minElement.attribute("y").toInt(), minElement.attribute("z").toInt(), minElement.attribute("t").toInt(), maxElement.attribute("x").toInt(), maxElement.attribute("y").toInt(), maxElement.attribute("z").toInt(), maxElement.attribute("t").toInt());
- break;
- }
- }
- node = node.nextSibling();
- }
- if(!haveBorder())
- setCalculationSpace();
- }
-}
-
-void CalculationData::setValueAt_i_Back(int val, int x)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
- break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- *((char *)getAddressAtBackBuffer(x, 0, 0, 0)) = (char)val;
- break;
-
- case baseDataTypes::DATA_TYPES::INT:
- *((int *)(getAddressAtBackBuffer(x, 0, 0, 0))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- *((short *)(getAddressAtBackBuffer(x, 0, 0, 0))) = (short)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_i_Back(int val, int x, int y)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
- break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- *((char *)getAddressAtBackBuffer(x, y, 0, 0)) = (char)val;
- break;
-
- case baseDataTypes::DATA_TYPES::INT:
- *((int *)(getAddressAtBackBuffer(x, y, 0, 0))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- *((short *)(getAddressAtBackBuffer(x, y, 0, 0))) = (short)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_i_Back(int val, int x, int y, int z)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
- break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- *((char *)getAddressAtBackBuffer(x, y, z, 0)) = (char)val;
- break;
-
- case baseDataTypes::DATA_TYPES::INT:
- *((int *)(getAddressAtBackBuffer(x, y, z, 0))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- *((short *)(getAddressAtBackBuffer(x, y, z, 0))) = (short)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_i_Back(int val, int x, int y, int z, int t)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- size = 0;
- break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- *((char *)getAddressAtBackBuffer(x, y, z, t)) = (char)val;
- break;
-
- case baseDataTypes::DATA_TYPES::INT:
- *((int *)(getAddressAtBackBuffer(x, y, z, t))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- *((short *)(getAddressAtBackBuffer(x, y, z, t))) = (short)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_d_Back(double val, int x)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::DOUBLE:
- *((double *)(getAddressAtBackBuffer(x, 0, 0, 0))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::FLOAT:
- *((float *)(getAddressAtBackBuffer(x, 0, 0, 0))) = (float)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_d_Back(double val, int x, int y)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::DOUBLE:
- *((double *)(getAddressAtBackBuffer(x, y, 0, 0))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::FLOAT:
- *((float *)(getAddressAtBackBuffer(x, y, 0, 0))) = (float)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_d_Back(double val, int x, int y, int z)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::DOUBLE:
- *((double *)(getAddressAtBackBuffer(x, y, z, 0))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::FLOAT:
- *((float *)(getAddressAtBackBuffer(x, y, z, 0))) = (float)val;
- break;
- }
-}
-
-void CalculationData::setValueAt_d_Back(double val, int x, int y, int z, int t)
-{
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::DOUBLE:
- *((double *)(getAddressAtBackBuffer(x, y, z, t))) = val;
- break;
-
- case baseDataTypes::DATA_TYPES::FLOAT:
- *((float *)(getAddressAtBackBuffer(x, y, z, t))) = (float)val;
- break;
- }
-}
-
-void CalculationData::fillData_i(int val)
-{
- int dSize;
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::BOOL:
- break;
-
- case baseDataTypes::DATA_TYPES::CHAR:
- dSize = sizeof(char);
- for(int i=0;i<getSizeInByte();i+=dSize)
- {
- *((char *)(data + i)) = (char)val;
- }
- break;
-
- case baseDataTypes::DATA_TYPES::INT:
- dSize = sizeof(int);
- for(int i=0;i<getSizeInByte();i+=dSize)
- {
- *((int *)(data + i)) = val;
- }
- break;
-
- case baseDataTypes::DATA_TYPES::SHORT:
- dSize = sizeof(short);
- for(int i=0;i<getSizeInByte();i+=dSize)
- {
- *((short *)(data + i)) = (short)val;
- }
- break;
- }
-}
-
-void CalculationData::fillData_d(double val)
-{
- int dSize;
- switch(dataType)
- {
- case baseDataTypes::DATA_TYPES::DOUBLE:
- dSize = sizeof(double);
- for(int i=0;i<getSizeInByte();i+=dSize)
- {
- *((double *)(data + i)) = val;
- }
- break;
- case baseDataTypes::DATA_TYPES::FLOAT:
- dSize = sizeof(float);
- for(int i=0;i<getSizeInByte();i+=dSize)
- {
- *((float *)(data + i)) = (float)val;
- }
- break;
- }
-}
+ fillData(cData.getDataPointer());
+ return *this;
+}
\ No newline at end of file
Added: trunk/qcell/basesources/Calculator.cpp
===================================================================
--- trunk/qcell/basesources/Calculator.cpp (rev 0)
+++ trunk/qcell/basesources/Calculator.cpp 2006-12-19 14:58:48 UTC (rev 68)
@@ -0,0 +1,219 @@
+#include "../baseheaders/Calculator.h"
+
+void Calculator::clearOutputData(void)
+{
+ if(!haveForeignOutputDataPointer && outData)
+ delete outData;
+
+ outData = NULL;
+}
+
+void Calculator::copyData(void)
+{
+ int counter = 0;
+ for(int t=calculationSpaceStart[3];t<=calculationSpaceEnd[3];++t)
+ {
+ for(int z=calculationSpaceStart[2];z<=calculationSpaceEnd[2];++z)
+ {
+ for(int y=calculationSpaceStart[1];y<=calculationSpaceEnd[1];++y)
+ {
+ memcpy(outData + counter, getAddressAt(calculationSpaceStart[0], y, z, t), outDataSize[0]);
+ counter += outDataSize[0];
+ }
+ }
+ }
+}
+
+bool Calculator::resizeOutputDataBuffer(bool dataCopy, char *dataPointer)
+{
+ clearOutputData();
+ if(dataPointer==NULL)
+ {
+ haveForeignOutputDataPointer = 1;
+ outData = new char[getOutputDataSizeInByte()];
+ if(!outData)
+ return 0;
+
+ }
+ else
+ {
+ haveForeignOutputDataPointer = 0;
+ outData = dataPointer;
+ }
+ if(dataCopy)
+ copyData();
+
+ return 1;
+}
+
+Calculator::Calculator()
+{
+ outData = NULL;
+ haveForeignOutputDataPointer = 0;
+ outDataSize.resize(4);
+ calculationSpaceStart.resize(4);
+ calculationSpaceEnd.resize(4);
+ neighbourhood = NULL;
+ localfunction = NULL;
+}
+
+Calculator::~Calculator()
+{
+ clearOutputData();
+ haveForeignOutputDataPointer = 0;
+ neighbourhood = NULL;
+ localfunction = NULL;
+}
+
+void Calculator::setNeighbourhood(Neighbourhood *n)
+{
+ neighbourhood = n;
+ neighbourhood->calculateOffsets(sizeX, sizeY, sizeZ, sizeT, getDataType());
+}
+
+void Calculator::setLocalFunction(LocalFunction *f)
+{
+ localfunction = f;
+}
+
+bool Calculator::setCalculationSpace(QVector<int> start, QVector<int> end, bool dataCopy, char *foreignDataPointer)
+{
+ if( start.size() == end.size() && start.size()==dimension)
+ {
+ for(int i=0;i<4;++i)
+ {
+ if(i<dimension)
+ {
+ calculationSpaceStart[i] = start[i];
+ calculationSpaceEnd[i] = end[i];
+ outDataSize[i] = calculationSpaceEnd[i] - calculationSpaceStart[i] + 1;
+ }
+ else
+ {
+ calculationSpaceStart[i] = 0;
+ calculationSpaceEnd[i] = 0;
+ outDataSize[i] = 0;
+ }
+ }
+
+ return resizeOutputDataBuffer(dataCopy, foreignDataPointer);
+ }
+ return 0;
+}
+
+
+int Calculator::getOutputDataSizeInByte(void)
+{
+ switch(dataType)
+ {
+ case baseDataTypes::DATA_TYPES::BOOL:
+ return (outDataSize[0] * outDataSize[1] * outDataSize[2] * outDataSize[3])/8 + 1;
+
+ case baseDataTypes::DATA_TYPES::CHAR:
+ switch(dimension)
+ {
+ case 1:
+ return outDataSize[0] * sizeof(char);
+ case 2:
+ return outDataSize[0] * outDataSize[1] * sizeof(char);
+ case 3:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * sizeof(char);
+ case 4:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * outDataSize[3] * sizeof(char);
+ }
+
+ case baseDataTypes::DATA_TYPES::DOUBLE:
+ switch(dimension)
+ {
+ case 1:
+ return outDataSize[0] * sizeof(double);
+ case 2:
+ return outDataSize[0] * outDataSize[1] * sizeof(double);
+ case 3:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * sizeof(double);
+ case 4:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * outDataSize[3] * sizeof(double);
+ }
+
+ case baseDataTypes::DATA_TYPES::FLOAT:
+ switch(dimension)
+ {
+ case 1:
+ return outDataSize[0] * sizeof(float);
+ case 2:
+ return outDataSize[0] * outDataSize[1] * sizeof(float);
+ case 3:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * sizeof(float);
+ case 4:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * outDataSize[3] * sizeof(float);
+ }
+
+ case baseDataTypes::DATA_TYPES::INT:
+ switch(dimension)
+ {
+ case 1:
+ return outDataSize[0] * sizeof(int);
+ case 2:
+ return outDataSize[0] * outDataSize[1] * sizeof(int);
+ case 3:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * sizeof(int);
+ case 4:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * outDataSize[3] * sizeof(int);
+ }
+
+ case baseDataTypes::DATA_TYPES::SHORT:
+ switch(dimension)
+ {
+ case 1:
+ return outDataSize[0] * sizeof(short);
+ case 2:
+ return outDataSize[0] * outDataSize[1] * sizeof(short);
+ case 3:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * sizeof(short);
+ case 4:
+ return outDataSize[0] * outDataSize[1] * outDataSize[2] * outDataSize[3] * sizeof(short);
+ }
+ }
+ return 0;
+}
+
+const char *Calculator::getOutputDataPointer(void)
+{
+ return outData;
+}
+
+void Calculator::calculate(void)
+{
+ int counter = 0;
+ char temp[8];
+ for(int t=calculationSpaceStart[3];t<=calculationSpaceEnd[3];++t)
+ {
+ for(int z=calculationSpaceStart[2];z<=calculationSpaceEnd[2];++z)
+ {
+ for(int y=calculationSpaceStart[1];y<=calculationSpaceEnd[1];++y)
+ {
+ for(int x=calculationSpaceStart[0];x<=calculationSpaceEnd[0];++x)
+ {
+ neighbourhood->resolveValues((const char *)getAddressAt(x, y, z, t));
+ switch(dataType)
+ {
+ case baseDataTypes::BOOL:
+ case baseDataTypes::CHAR:
+ case baseDataTypes::SHORT:
+ case baseDataTypes::INT:
+ *((int *)temp) = localfunction->resolve(neighbourhood->valuesToVector_i());
+ break;
+ case baseDataTypes::FLOAT:
+ *((float *)temp) = (float)localfunction->resolve(neighbourhood->valuesToVector_d());
+ break;
+ case baseDataTypes::DOUBLE:
+ *((double *)temp) = localfunction->resolve(neighbourhood->valuesToVector_d());
+ break;
+ }
+ memcpy(outData + counter, temp, dataSize);
+ counter += dataSize;
+ }
+ }
+ }
+ }
+}
Modified: trunk/qcell/basesources/Client.cpp
===================================================================
--- trunk/qcell/basesources/Client.cpp 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/basesources/Client.cpp 2006-12-19 14:58:48 UTC (rev 68)
@@ -392,5 +392,4 @@
}
else
++pingTry;
-
}
Modified: trunk/qcell/basesources/LocalFunction.cpp
===================================================================
--- trunk/qcell/basesources/LocalFunction.cpp 2006-12-15 09:57:50 UTC (rev 67)
+++ trunk/qcell/basesources/LocalFunction.cpp 2006-12-19 14:58:48 UTC (rev 68)
@@ -5,22 +5,19 @@
switch(functionMode)
{
- case LocalFunction::FUNCTION_TYPE::PRODUCT:
- numElements = pow(maxArgVal - 1, productArguments.size()) + 1;
- break;
-
case LocalFunction::FUNCTION_TYPE::SUM:
- numElements = sumArguments.size() * (maxArgVal - 1) + 1;
+ numElements = 1;
+ for(int i=0;i<sumArguments.size();++i)
+ numElements *= sumArguments[i].size() * (maxArgVal - 1) + 1;
break;
- case LocalFunction::FUNCTION_TYPE::MIXED_SUM_SWITCH:
- numElements = freeArguments.size() * maxArgVal * (sumArguments.size() * (maxArgVal - 1) + 1);
+ case LocalFunction::FUNCTION_TYPE::SUM_AND_SWITCH:
+ numElements = 1;
+ for(int i=0;i<sumArguments.size();++i)
+ numElements *= sumArguments[i].size() * (maxArgVal - 1) + 1;
+ numElements *= freeArguments.size() * maxArgVal;
break;
- case LocalFunction::FUNCTION_TYPE::MIXED_PRODUCT_SWITCH:
- numElements = freeArguments.size() * maxArgVal * (pow(maxArgVal - 1, productArguments.size()) + 1);
- break;
-
case LocalFunction::FUNCTION_TYPE::SWITCH:
numElements = numArg * maxArgVal;
break;
@@ -61,97 +58,76 @@
return out;
}
-QString LocalFunction::valueTableToString(void)
+QVector<int> LocalFunction::calculateSums(QVector<int> &args)
{
- int fillValue;
- QString data, index, value;
- fillValue = mostPopularValue();
- for(int i=0;i<numElements;i++)
+ int i, j;
+ QVector<int> out;
+ out.resize(sumArguments.size());
+ for(i=0;i<sumArguments.size();++i)
{
- if(valueTable[i]!=fillValue)
- {
- index.setNum(i);
- value.setNum(valueTable[i]);
- data = index + ":" + value + ";";
- }
+ out[i] = 0;
+ foreach(j, sumArguments[i])
+ out[i] += args[j];
}
- return data;
+ return out;
}
-QString LocalFunction::valueTableToString(int fillValue)
+QVector<int> LocalFunction::calculateSwitchArguments(QVector<int> &args)
{
- QString data, index, value;
- for(int i=0;i<numElements;i++)
- {
- if(valueTable[i]!=fillValue)
- {
- index.setNum(i);
- value.setNum(valueTable[i]);
- data += index + ":" + value + ";";
- }
- }
- return data;
+ int index;
+ QVector<int> out;
+ foreach(index, freeArguments)
+ out<<args[index];
+ return out;
}
-QString LocalFunction::sumArgumentsToString(void)
+int LocalFunction::calculateSumsIndex(QVector<int> args)
{
- int i;
- QString out, temp;
- foreach(i, sumArguments)
+ int mult, index = 0;
+ int switchFunctionSize = pow(maxArgVal, freeArguments.size());
+ for(int i=0;i<sumArguments.size();++i)
{
- temp.setNum(i);
- out += temp + ";";
+ mult = 1;
+ for(int j=i;j<sumArguments.size() - 1;++j)
+ mult *= sumArguments[j].size() * (maxArgVal - 1) + 1;
+ index += args[i] * mult * switchFunctionSize;
}
- return out;
+ return index;
}
-QString LocalFunction::productArgumentsToString(void)
+int LocalFunction::calculateSwitchIndex(QVector<int> args)
{
- int i;
- QString out, temp;
- foreach(i, productArguments)
- {
- temp.setNum(i);
- out += temp + ";";
- }
- return out;
+ int index = 0;
+ for(int i=0;i<freeArguments.size();++i)
+ index += args[i] * pow(maxArgVal, i);
+ return index;
}
-void LocalFunction::valueTableFromString(QString *string)
+QString LocalFunction::valueTableToString(void)
{
- QStringList splitList, element;
- QString temp;
- splitList = string->split(";", QString::SplitBehavior::SkipEmptyParts);
- foreach(temp, splitList)
- {
- element = temp.split(":");
- valueTable[element.at(0).toInt()] = element.at(1).toInt();
- }
+ return QString();
}
+QString LocalFunction::valueTableToString(int fillValue)
+{
+ return QString();
+}
-void LocalFunction::sumArgumentsFromString(QString *string)
+QString LocalFunction::sumArgumentsToString(void)
{
- QStringList splitList;
- QString temp;
- QVector<int> v;
- splitList = string->split(";", QString::SplitBehavior::SkipEmptyParts);
- foreach(temp, splitList)
- v.append(temp.toInt());
- setSumArguments(v);
+ return QString();
}
-void LocalFunction::productArgumentsFromString(QString *string)
+void LocalFunction::valueTableFromString(QString *string)
{
- QStringList splitList;
- QString temp;
- QVector<int> v;
- splitList = string->split(";", QString::SplitBehavior::SkipEmptyParts);
- foreach(temp, splitList)
- v.append(temp.toInt());
- setProductArguments(v);
}
+
+void LocalFunction::sumArgumentsFromString(QString *string)
+{
+}
+
+
LocalFunction::LocalFunction()
{
functionMode = LocalFunction::FUNCTION_TYPE::SWITCH;
@@ -168,21 +144,22 @@
maxArgVal = alphabetSize;
valueTable.clear();
sumArguments.clear();
- productArguments.clear();
freeArguments.clear();
functionMode = LocalFunction::FUNCTION_TYPE::SWITCH;
}
-void LocalFunction::setSumArguments(QVector<int> arg)
+void LocalFunction::addSumArguments(QVector<int> args)
{
- if(arg.size()<=numArg)
+ int index;
+ if(args.size()>0)
{
- sumArguments = arg;
- freeArguments.clear();
- valueTable.clear();
- for(int i=0;i<numArg;++i)
- if(!sumArguments.contains(i))
- freeArguments<<i;
+ sumArguments.append(args);
+ for(int i=0;i<args.size();++i)
+ {
+ index = freeArguments.indexOf(args[i]);
+ if(index>-1)
+ freeArguments.remove(index);
+ }
if(freeArguments.size()==0)
functionMode = LocalFunction::FUNCTION_TYPE::SUM;
@@ -190,34 +167,35 @@
if(freeArguments.size()==numArg)
functionMode = LocalFunction::FUNCTION_TYPE::SWITCH;
else
- functionMode = LocalFunction::FUNCTION_TYPE::MIXED_SUM_SWITCH;
+ functionMode = LocalFunction::FUNCTION_TYPE::SUM_AND_SWITCH;
}
}
-void LocalFunction::setProductArguments(QVector<int> arg)
+void LocalFunction::setSumArguments(QVector<int> arg)
{
if(arg.size()<=numArg)
{
- productArguments = arg;
+ sumArguments.clear();
+ sumArguments.append(arg);
freeArguments.clear();
valueTable.clear();
for(int i=0;i<numArg;++i)
- if(!productArguments.contains(i))
+ if(!sumArguments[0].contains(i))
freeArguments<<i;
+
if(freeArguments.size()==0)
- functionMode = LocalFunction::FUNCTION_TYPE::PRODUCT;
+ functionMode = LocalFunction::FUNCTION_TYPE::SUM;
else
if(freeArguments.size()==numArg)
functionMode = LocalFunction::FUNCTION_TYPE::SWITCH;
else
- functionMode = LocalFunction::FUNCTION_TYPE::MIXED_PRODUCT_SWITCH;
+ functionMode = LocalFunction::FUNCTION_TYPE::SUM_AND_SWITCH;
}
}
void LocalFunction::setSwitchFunction(void)
{
sumArguments.clear();
- productArguments.clear();
freeArguments.clear();
valueTable.clear();
functionMode = LocalFunction::FUNCTION_TYPE::SWITCH;
@@ -244,11 +222,9 @@
switch(functionMode)
{
case LocalFunction::FUNCTION_TYPE::SUM:
- case LocalFunction::FUNCTION_TYPE::PRODUCT:
return 1;
- case LocalFunction::FUNCTION_TYPE::MIXED_SUM_SWITCH:
- case LocalFunction::FUNCTION_TYPE::MIXED_PRODUCT_SWITCH:
+ case LocalFunction::FUNCTION_TYPE::SUM_AND_SWITCH:
return freeArguments.size() + 1;
case LocalFunction::FUNCTION_TYPE::SWITCH:
@@ -271,36 +247,84 @@
}
+bool LocalFunction::setFunctionValue(int value, int sum)
+{
+ int offset;
+ if(sumArguments.size()==0 || sumArguments.size()>1)
+ return 0;
+ if(valueTable.empty())
+ resizeValueTable();
+ switch(functionMode)
+ {
+ case LocalFunction::FUNCTION_TYPE::SUM:
+ valueTable[sum] = value;
+ break;
-bool LocalFunction::addFunctionValue(int value, QVector<int> args)
+ case LocalFunction::FUNCTION_TYPE::SUM_AND_SWITCH:
+ offset = sum * freeArguments.size() * maxArgVal;
+ for(int i=offset;i<freeArguments.size() * maxArgVal + offset;++i)
+ valueTable[i] = value;
+ break;
+
+ default:
+ return 0;
+ }
+ return 1;
+}
+
+
+bool LocalFunction::setFunctionValue(int value, QVector<int> args)
{
- int i, index = 0, t;
if(valueTable.empty())
resizeValueTable();
switch(functionMode)
{
- case LocalFunction::FUNCTION_TYPE::SUM:
- case LocalFunction::FUNCTION_TYPE::PRODUCT:
- index = args[0];
+ case LocalFunction::SWITCH:
+ valueTable[calculateSwitchIndex(args)];
break;
- case LocalFunction::FUNCTION_TYPE::MIXED_SUM_SWITCH:
-
- t = freeArguments.size();
- for(i=0;i<freeArguments.size();++i)
- index += args[i+1] * pow(maxArgVal, i);
- index += args[0] * pow(maxArgVal, freeArguments.size());
- break;
+ default:
+ return 0;
+ }
+ return 1;
+}
- case LocalFunction::FUNCTION_TYPE::MIXED_PRODUCT_SWITCH:
+bool LocalFunction::setFunctionValue(int value, int sum, QVector<int> freeArgs)
+{
+ int index;
+ if(sumArguments.size()==0 || sumArguments.size()>1)
+ return 0;
+ if(valueTable.empty())
+ resizeValueTable();
+ switch(functionMode)
+ {
+ case LocalFunction::SUM_AND_SWITCH:
+ index = calculateSwitchIndex(freeArgs);
+ index = sum * pow(maxArgVal, freeArguments.size()) + index;
+ valueTable[index] = value;
break;
+ default:
+ return 0;
+ }
+ return 1;
+}
- case LocalFunction::FUNCTION_TYPE::SWITCH:
- for(i=0;i<numArg;++i)
- index += args[i] * pow(maxArgVal, i);
- break;
+bool LocalFunction::setFunctionValue(int value, QVector<int> sums, QVector<int> freeArgs)
+{
+ int index;
+ if(sumArguments.size()==0 || freeArguments.size()==0)
+ return 0;
+ if(valueTable.empty())
+ resizeValueTable();
+ switch(functionMode)
+ {
+ case LocalFunction::SUM_AND_SWITCH:
+ index = calculateSumsIndex(sums) + calculateSwitchIndex(freeArgs);
+ valueTable[index] = value;
+ break;
+ default:
+ return 0;
}
- valueTable[index] = value;
return 1;
}
@@ -312,33 +336,17 @@
if(functionMode==LocalFunction::FUNCTION_TYPE::SCRIPT)
return -1;
+ QVector<int> sums, freeArgs;
+ sums = calculateSums(args);
+ freeArgs = calculateSwitchArguments(args);
+
switch(functionMode)
{
- case LocalFunction::FUNCTION_TYPE::SUM:
- case LocalFunction::FUNCTION_TYPE::PRODUCT:
- index = args[0];
- break;
-
- case LocalFunction::FUNCTION_TYPE::MIXED_SUM_SWITCH:
- for(i=0;i<freeArguments.size();++i)
- index += args[freeArguments[i]] * pow(maxArgVal, i);
-
- temp = 0;
- for(i=0;i<sumArguments.size();++i)
- temp += args[sumArguments[i]];
-
- index += temp * pow(maxArgVal, freeArguments.size());
- break;
-
- case LocalFunction::FUNCTION_TYPE::MIXED_PRODUCT_SWITCH:
- break;
-
- case LocalFunction::FUNCTION_TYPE::SWITCH:
- for(i=0;i<numArg;++i)
- index += args[i] * pow(maxArgVal, i);
- break;
case LocalFunction::FUNCTION_TYPE::SCRIPT:
break;
+ default:
+ index = calculateSumsIndex(sums) + calculateSwitchIndex(freeArgs);
+ break;
}
return valueTable[index];
}
@@ -353,11 +361,6 @@
for (i=0;i<args.size();++i)
out += args[i];
break;
- case LocalFunction::FUNCTION_TYPE::PRODUCT:
- out = args[0];
- for (i=1;i<args.size();++i)
- out *= args[i];
- break;
case LocalFunction::FUNCTION_TYPE::SCRIPT:
break;
@@ -369,162 +372,16 @@
QString LocalFunction::toXmlString(void)
{
- int i, fillValue;
- QString data, index;
- QDomDocument dom;
- QDomElement root, element, subElement;
- QDomText textData = dom.createTextNode("");
- root = dom.createElement("LocalFunction");
- root.setAttribute("ArgumentsNumber", numArg);
- root.setAttribute("AlphabetSize", maxArgVal);
- fillValue = mostPopularValue();
- switch(functionMode)
- {
- case LocalFunction::FUNCTION_TYPE::SUM:
- element = dom.createElement("Sum");
- element.setAttribute("Fill", fillValue);
- data = valueTableToString(fillValue);
- textData.setData(data);
- element.appendChild(textData);
- root.appendChild(element);
- break;
-
- case LocalFunction::FUNCTION_TYPE::PRODUCT:
- element = dom.createElement("Product");
- element.setAttribute("Fill", fillValue);
- data = valueTableToString(fillValue);
- textData.setData(data);
- element.appendChild(textData);
- root.appendChild(element);
- break;
-
- case LocalFunction::FUNCTION_TYPE::MIXED_SUM_SWITCH:
- element = dom.createElement("Mixed");
- element.setAttribute("Fill", fillValue);
- data = sumArgumentsToString();
- element.setAttribute("SumArguments", data);
- data = valueTableToString(fillValue);
- textData.setData(data);
- element.appendChild(textData);
- root.appendChild(element);
- break;
- case LocalFunction::FUNCTION_TYPE::MIXED_PRODUCT_SWITCH:
- element = dom.createElement("Mixed");
- element.setAttribute("Fill", fillValue);
- data = productArgumentsToString();
- element.setAttribute("ProductArguments", data);
- data = valueTableToString(fillValue);
- textData.setData(data);
- element.appendChild(textData);
- root.appendChild(element);
-
- break;
-
- case LocalFunction::FUNCTION_TYPE::SWITCH:
- element = dom.createElement("Switch");
- element.setAttribute("Fill", fillValue);
- data = valueTableToString(fillValue);
- textData.setData(data);
- element.appendChild(textData);
- root.appendChild(element);
- break;
-
- case LocalFunction::FUNCTION_TYPE::SCRIPT:
- element = dom.createElement("Script");
- textData.setData(script);
- element.appendChild(textData);
- root.appendChild(element);
- break;
- }
-
- dom.appendChild(root);
- return dom.toString();
+ return QString();
}
bool LocalFunction::fromXmlString(QString *xmlString)
{
- QDomDocument doc;
- QDomElement element;
- doc.setContent(*xmlString);
- element = doc.documentElement();
- return fromDomElement(&element);
+ return 1;
}
bool LocalFunction::fromDomElement(QDomElement *xmlElement)
{
- QDomElement element;
- QDomText domText;
- QString text;
- if(xmlElement->tagName()=="LocalFunction")
- {
- init(xmlElement->attribute("ArgumentsNumber").toInt(), xmlElement->attribute("AlphabetSize").toInt());
- element = xmlElement->firstChildElement();
- if(element.tagName()=="Sum")
- {
...
[truncated message content] |
