[Qcell-commitlogs] SF.net SVN: qcell: [68] trunk/qcell

[<le...@us...>]

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]