Menu
▾
▴
[Qcell-commitlogs] SF.net SVN: qcell: [26] trunk/qcell
|
From: <le...@us...> - 2006-11-29 23:39:27
|
Revision: 26
http://svn.sourceforge.net/qcell/?rev=26&view=rev
Author: lessm
Date: 2006-11-29 15:39:25 -0800 (Wed, 29 Nov 2006)
Log Message:
-----------
- CalculationData class can import/export setings from xml string
Modified Paths:
--------------
trunk/qcell/baseheaders/CalculationData.h
trunk/qcell/baseheaders/Neighbourhood.h
trunk/qcell/basesources/CalculationData.cpp
trunk/qcell/basesources/Neighbourhood.cpp
Modified: trunk/qcell/baseheaders/CalculationData.h
===================================================================
--- trunk/qcell/baseheaders/CalculationData.h 2006-11-29 20:12:56 UTC (rev 25)
+++ trunk/qcell/baseheaders/CalculationData.h 2006-11-29 23:39:25 UTC (rev 26)
@@ -3,7 +3,8 @@
#include <string.h>
#include <QString>
-#include <QByteArray>
+#include <QDomDocument>
+#include <QDomElement>
class CalculationData
{
@@ -22,12 +23,20 @@
private:
DATA_TYPES dataType;
int sizeX, sizeY, sizeZ, sizeT;
+ int backBufferSizeX, backBufferSizeY, backBufferSizeZ, backBufferSizeT;
int dimension, size;
- char *data;
+ char *data, *dataBorderFree;
+ int minX, minY, minZ, minT;
+ int maxX, maxY, maxZ, maxT;
+
+ bool borderExist;
+
protected:
bool resize(const 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);
public:
@@ -54,7 +63,9 @@
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 setDataType(DATA_TYPES type = DATA_TYPES::CHAR);
+ void setDataType(CalculationData::DATA_TYPES type = CalculationData::DATA_TYPES::CHAR);
+ CalculationData::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);
@@ -68,7 +79,32 @@
int getSizeInByte(void);
const char *getDataPointer(void);
+ const char *getBackBufferDataPointer(void);
void fill(const char *dataPointer);
+
+
+ void setCalculationSpace(void);
+ void setCalculationSpace(int startX, int endX);
+ void setCalculationSpace(int startX, int startY, int endX, int endY);
+ void setCalculationSpace(int startX, int startY, int startZ, int endX, int endY, int endZ);
+ void setCalculationSpace(int startX, int startY, int startZ, int startT, int endX, int endY, int endZ, int endT);
+
+ void removeBorder(void);
+ bool haveBorder(void);
+
+ QString createXmlHeader(void);
+ void setFromXmlString(QString *xmlString);
+ void 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);
+
+ 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);
};
-#endif
\ No newline at end of file
+#endif
Modified: trunk/qcell/baseheaders/Neighbourhood.h
===================================================================
--- trunk/qcell/baseheaders/Neighbourhood.h 2006-11-29 20:12:56 UTC (rev 25)
+++ trunk/qcell/baseheaders/Neighbourhood.h 2006-11-29 23:39:25 UTC (rev 26)
@@ -48,10 +48,10 @@
int getInValueOf(int index);
double getDoubleValueOf(int index);
- void calculateOffsets(int sizeX, int sizeY, int sizeZ, int sizeT);
+ void calculateOffsets(int sizeX, int sizeY, int sizeZ, int sizeT, int dataSize);
};
-#endif
\ No newline at end of file
+#endif
Modified: trunk/qcell/basesources/CalculationData.cpp
===================================================================
--- trunk/qcell/basesources/CalculationData.cpp 2006-11-29 20:12:56 UTC (rev 25)
+++ trunk/qcell/basesources/CalculationData.cpp 2006-11-29 23:39:25 UTC (rev 26)
@@ -2,13 +2,20 @@
bool CalculationData::resize(const char *dataPointer)
{
+ borderExist = 0;
if(data)
- delete data;
+ delete[] data;
data = new char[getSizeInByte()];
if(!data)
return 0;
+ if(dataBorderFree)
+ {
+ delete[] dataBorderFree;
+ dataBorderFree = NULL;
+ }
+
if(dataPointer)
fill(dataPointer);
return 1;
@@ -48,6 +55,69 @@
return data + dSize * (x + y * sizeX + z * sizeX * sizeY + t * sizeX * sizeY * sizeZ);
}
+void * CalculationData::getAddressAtBackBuffer(int x, int y, int z, int t)
+{
+ int dSize;
+ if(dataType==CalculationData::DATA_TYPES::NONE)
+ return NULL;
+ switch(dataType)
+ {
+ case CalculationData::DATA_TYPES::BOOL:
+ size = 0;
+ break;
+
+ case CalculationData::DATA_TYPES::CHAR:
+ dSize = 1;
+ break;
+
+ case CalculationData::DATA_TYPES::INT:
+ dSize = sizeof(int);
+ break;
+
+ case CalculationData::DATA_TYPES::SHORT:
+ dSize = sizeof(short);
+ break;
+
+ case CalculationData::DATA_TYPES::DOUBLE:
+ dSize = sizeof(double);
+ break;
+ case CalculationData::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;
+
+ return dataBorderFree + dSize * (x + y * backBufferSizeX + z * backBufferSizeX * backBufferSizeY + t * backBufferSizeX * backBufferSizeY * backBufferSizeZ);
+}
+
+void CalculationData::calculateBackBufferSize(void)
+{
+ switch(dimension)
+ {
+ case 4:
+ backBufferSizeT = maxT - minT;
+ case 3:
+ backBufferSizeZ = maxZ - minZ;
+ case 2:
+ backBufferSizeY = maxY - minY;
+ case 1:
+ backBufferSizeX = maxX - minX;
+ }
+}
+
CalculationData::CalculationData()
{
dataType = CalculationData::DATA_TYPES::NONE;
@@ -55,6 +125,8 @@
dimension = -1;
size = -1;
data = NULL;
+ dataBorderFree = NULL;
+ borderExist = 0;
}
CalculationData::~CalculationData()
@@ -65,9 +137,14 @@
size = -1;
if(data)
{
- delete data;
+ delete[] data;
data = NULL;
}
+ if(dataBorderFree)
+ {
+ delete[] dataBorderFree;
+ dataBorderFree = NULL;
+ }
}
int CalculationData::getValueAt_i(int x)
@@ -378,6 +455,15 @@
}
}
+CalculationData::DATA_TYPES CalculationData::getDataType(void)
+{
+ return dataType;
+}
+int CalculationData::getDataSize(void)
+{
+ return size;
+}
+
bool CalculationData::resize(int x, const char *dataPointer)
{
sizeX = x;
@@ -443,17 +529,7 @@
switch(dataType)
{
case CalculationData::DATA_TYPES::BOOL:
- switch(dimension)
- {
- case 1:
- return sizeX / 8 + ((sizeX % 8)>0);
- case 2:
- return (sizeX * sizeY) / 8 + (((sizeX * sizeY) % 8)>0);
- case 3:
- return (sizeX * sizeY * sizeZ) / 8 + (((sizeX * sizeY * sizeZ) % 8)>0);
- case 4:
- return (sizeX * sizeY * sizeZ * sizeT) / 8 + (((sizeX * sizeY * sizeZ * sizeT) % 8)>0);
- }
+ return (sizeX * sizeY * sizeZ * sizeT)/8;
case CalculationData::DATA_TYPES::CHAR:
switch(dimension)
@@ -528,10 +604,478 @@
return data;
}
+const char *CalculationData::getBackBufferDataPointer(void)
+{
+ return dataBorderFree;
+}
+
void CalculationData::fill(const char *dataPointer)
{
if(data!=NULL)
{
memcpy(data, dataPointer, getSizeInByte());
}
-}
\ No newline at end of file
+}
+
+void CalculationData::setCalculationSpace(void)
+{
+ minX = 0;
+ minY = 0;
+ minZ = 0;
+ minT = 0;
+
+ maxX = sizeX;
+ maxY = sizeY;
+ maxZ = sizeZ;
+ maxT = sizeT;
+
+ borderExist = 0;
+ if(dataBorderFree)
+ {
+ delete[] dataBorderFree;
+ }
+ dataBorderFree = new char[getSizeInByte()];
+ calculateBackBufferSize();
+}
+
+void CalculationData::setCalculationSpace(int startX, int endX)
+{
+ minX = startX;
+ maxX = endX;
+ borderExist = 1;
+ if(dataBorderFree)
+ {
+ delete[] dataBorderFree;
+ }
+ dataBorderFree = new char[(maxX - minX) * size];
+ calculateBackBufferSize();
+}
+
+void CalculationData::setCalculationSpace(int startX, int startY, int endX, int endY)
+{
+ minX = startX;
+ maxX = endX;
+ minY = startY;
+ maxY = endY;
+ borderExist = 1;
+ if(dataBorderFree)
+ {
+ delete[] dataBorderFree;
+ }
+ dataBorderFree = new char[((maxX - minX) * (maxY - minY)) * size];
+ calculateBackBufferSize();
+}
+
+void CalculationData::setCalculationSpace(int startX, int startY, int startZ, int endX, int endY, int endZ)
+{
+ minX = startX;
+ maxX = endX;
+ minY = startY;
+ maxY = endY;
+ minZ = startZ;
+ maxZ = endZ;
+ borderExist = 1;
+ if(dataBorderFree)
+ {
+ delete[] dataBorderFree;
+ }
+ dataBorderFree = new char[((maxX - minX) * (maxY - minY) * (maxZ - minZ)) * size];
+ calculateBackBufferSize();
+}
+
+void CalculationData::setCalculationSpace(int startX, int startY, int startZ, int startT, int endX, int endY, int endZ, int endT)
+{
+ 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) * (maxY - minY) * (maxZ - minZ) * (maxT - minT)) * size];
+ calculateBackBufferSize();
+}
+
+void CalculationData::removeBorder(void)
+{
+ char *temp;
+ int newSize = 1, counter = 0;
+ if(borderExist)
+ {
+ switch(dimension)
+ {
+
+ case 4:
+ newSize *= maxT - minT;
+
+ case 3:
+ newSize *= maxZ - minZ;
+
+ case 2:
+ newSize *= maxY - minY;
+
+ case 1:
+ newSize *= maxX - minX;
+ break;
+
+ default:
+ newSize = 0;
+ }
+
+ temp = new char[newSize * size];
+
+ for(int t=minT;t<maxT;++t)
+ {
+ for(int z=minZ;z<maxZ;++z)
+ {
+ for(int y=minY;y<maxY;++y)
+ {
+ for(int x=minX;x<maxX;++x)
+ {
+ memcpy(temp + counter, getAddressAt(x, y, z, t), size);
+ counter += size;
+ }
+ }
+ }
+ }
+
+ switch(dimension)
+ {
+
+ case 4:
+ sizeT = maxT - minT;
+
+ case 3:
+ sizeZ = maxZ - minZ;
+
+ case 2:
+ sizeY = maxY - minY;
+
+ case 1:
+ sizeX = maxX - minX;
+ }
+
+ delete[] data;
+ data = temp;
+ temp = NULL;
+
+ }
+ borderExist = 0;
+}
+
+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)
+ {
+ 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 CalculationData::DATA_TYPES::BOOL:
+ element.setAttribute("ContentType", "bool");
+ break;
+
+ case CalculationData::DATA_TYPES::CHAR:
+ element.setAttribute("ContentType", "char");
+ break;
+
+ case CalculationData::DATA_TYPES::DOUBLE:
+ element.setAttribute("ContentType", "double");
+ break;
+
+ case CalculationData::DATA_TYPES::FLOAT:
+ element.setAttribute("ContentType", "float");
+ break;
+
+ case CalculationData::DATA_TYPES::INT:
+ element.setAttribute("ContentType", "bool");
+ break;
+
+ case CalculationData::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(CalculationData::DATA_TYPES::BOOL);
+ else
+ if(element.attribute("ContentType")=="char")
+ setDataType(CalculationData::DATA_TYPES::CHAR);
+ else
+ if(element.attribute("ContentType")=="double")
+ setDataType(CalculationData::DATA_TYPES::DOUBLE);
+ else
+ if(element.attribute("ContentType")=="float")
+ setDataType(CalculationData::DATA_TYPES::FLOAT);
+ else
+ if(element.attribute("ContentType")=="int")
+ setDataType(CalculationData::DATA_TYPES::INT);
+ else
+ if(element.attribute("ContentType")=="short")
+ setDataType(CalculationData::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 CalculationData::DATA_TYPES::BOOL:
+ size = 0;
+ break;
+
+ case CalculationData::DATA_TYPES::CHAR:
+ *((char *)getAddressAtBackBuffer(x, 0, 0, 0)) = (char)val;
+ break;
+
+ case CalculationData::DATA_TYPES::INT:
+ *((int *)(getAddressAtBackBuffer(x, 0, 0, 0))) = val;
+ break;
+
+ case CalculationData::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 CalculationData::DATA_TYPES::BOOL:
+ size = 0;
+ break;
+
+ case CalculationData::DATA_TYPES::CHAR:
+ *((char *)getAddressAtBackBuffer(x, y, 0, 0)) = (char)val;
+ break;
+
+ case CalculationData::DATA_TYPES::INT:
+ *((int *)(getAddressAtBackBuffer(x, y, 0, 0))) = val;
+ break;
+
+ case CalculationData::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 CalculationData::DATA_TYPES::BOOL:
+ size = 0;
+ break;
+
+ case CalculationData::DATA_TYPES::CHAR:
+ *((char *)getAddressAtBackBuffer(x, y, z, 0)) = (char)val;
+ break;
+
+ case CalculationData::DATA_TYPES::INT:
+ *((int *)(getAddressAtBackBuffer(x, y, z, 0))) = val;
+ break;
+
+ case CalculationData::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 CalculationData::DATA_TYPES::BOOL:
+ size = 0;
+ break;
+
+ case CalculationData::DATA_TYPES::CHAR:
+ *((char *)getAddressAtBackBuffer(x, y, z, t)) = (char)val;
+ break;
+
+ case CalculationData::DATA_TYPES::INT:
+ *((int *)(getAddressAtBackBuffer(x, y, z, t))) = val;
+ break;
+
+ case CalculationData::DATA_TYPES::SHORT:
+ *((short *)(getAddressAtBackBuffer(x, y, z, t))) = (short)val;
+ break;
+ }
+}
+
+void CalculationData::setValueAt_d_Back(double val, int x)
+{
+ switch(dataType)
+ {
+ case CalculationData::DATA_TYPES::DOUBLE:
+ *((double *)(getAddressAtBackBuffer(x, 0, 0, 0))) = val;
+ break;
+
+ case CalculationData::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 CalculationData::DATA_TYPES::DOUBLE:
+ *((double *)(getAddressAtBackBuffer(x, y, 0, 0))) = val;
+ break;
+
+ case CalculationData::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 CalculationData::DATA_TYPES::DOUBLE:
+ *((double *)(getAddressAtBackBuffer(x, y, z, 0))) = val;
+ break;
+
+ case CalculationData::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 CalculationData::DATA_TYPES::DOUBLE:
+ *((double *)(getAddressAtBackBuffer(x, y, z, t))) = val;
+ break;
+
+ case CalculationData::DATA_TYPES::FLOAT:
+ *((float *)(getAddressAtBackBuffer(x, y, z, t))) = (float)val;
+ break;
+ }
+}
+
Modified: trunk/qcell/basesources/Neighbourhood.cpp
===================================================================
--- trunk/qcell/basesources/Neighbourhood.cpp 2006-11-29 20:12:56 UTC (rev 25)
+++ trunk/qcell/basesources/Neighbourhood.cpp 2006-11-29 23:39:25 UTC (rev 26)
@@ -233,4 +233,4 @@
{
neighbourVector[i].offset = dataSize * (neighbourVector[i].x + neighbourVector[i].y * sizeX + neighbourVector[i].z * sizeX * sizeY + neighbourVector[i].t * sizeX * sizeY * sizeZ);
}
-}
\ No newline at end of file
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
