///////////////////////////////////////////////////////////////////////////////
// Safe recursive delete of an XLOper
void XLOper::xLLFree(XLOPER &p) {
if (p.xltype & xlbitDLLFree){
switch (p.xltype ^ xlbitDLLFree) {
case xltypeStr:
deleteArray(p.val.str);
break;
case xltypeMulti:
{
unsigned short i, j, k = p.val.array.columns;
for (i=0; i<p.val.array.rows; ++i) {
for (j=0; j<p.val.array.columns; ++j) {
xLLFree(p.val.array.lparray[i*k + j]);
}
}
deleteArray(p.val.array.lparray);
}
break;
default:
break;
}
// The following statement is a safety precaution.
p.xltype = xltypeNil;
}
return;
}
inline void edge_detector::edge_detect(int **a, int kernel, qreal *gradient, qreal *gangle)
{
// Scharr kernel
int SCx[3][3] = {{-3, 0, 3}, {-10, 0, 10}, {-3, 0, 3}};
int SCy[3][3] = {{-3,-10,-3}, { 0, 0, 0}, { 3, 10, 3}};
// Sobel kernel
int Sx[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
int Sy[3][3] = {{-1,-2,-1}, { 0, 0, 0}, { 1, 2, 1}};
// Prewitt kernel
int Px[3][3] = {{-1, 0, 1}, {-1, 0, 1}, {-1, 0, 1}};
int Py[3][3] = {{-1,-1,-1}, { 0, 0, 0}, { 1, 1, 1}};
// Roberts Cross
int Rx[3][3] = {{1, 0, 0}, {0, -1, 0}, {0, 0, 0}};
int Ry[3][3] = {{0, 1, 0}, {-1, 0, 0}, {0, 0, 0}};
int **Kx, **Ky;
int k, gx, gy;
if (kernel == 0) // Scharr kernel
{
k = 16;
Kx = copy(SCx);
Ky = copy(SCy);
}
else if (kernel == 1) // Sobel kernel
{
k = 4;
Kx = copy(Sx);
Ky = copy(Sy);
}
else if (kernel == 2) // Prewitt kernel
{
k = 3;
Kx = copy(Px);
Ky = copy(Py);
}
else if (kernel == 3) // Roberts Cross
{
k = 2;
Kx = copy(Rx);
Ky = copy(Ry);
}
gx = convolve(a, Kx, 3);
gy = convolve(a, Ky, 3);
deleteArray(Kx, 3);
deleteArray(Ky, 3);
*gradient = sqrt(gx*gx + gy*gy)/k;
*gangle = 180/M_PI * atan2(gy, gx);
}
void deleteResponseRecord(ResponseRecord *rec) {
reset_response_record(rec);
deleteString(rec->statusCode);
deleteString(rec->statusMessage);
deleteArray(rec->headerNames);
deleteArray(rec->headerValues);
free(rec);
}
QImage edge_detector::smoothImage(const QImage image)
{
QImage destImage = QImage( image);
QColor qc;
int Gauss[5][5] = {{2, 4, 5, 4, 2}, {4, 9, 12, 9, 4}, {5, 12, 15, 12, 5},
{4, 9, 12, 9, 4}, {2, 4, 5, 4, 2}};
int **G = new int*[5];
for (int i=0; i<5; i++)
{
G[i] = new int[5];
for(int j=0; j<5; j++)
G[i][j] = Gauss[i][j];
}
int H = image.height();
int W = image.width();
int* destData= (int *)destImage.bits();
int **a, smooth;
for (int y=2; y<H-2; y++)
{
for (int x=2; x<W-2; x++)
{
a = get_neighbor_pixels(image, x, y, 2);
smooth = convolve(a, G, 5) / 159.f;
deleteArray(a, 5); //2*2+1
qc.setRgb(smooth, smooth, smooth);
destData[x + y*W] = qc.rgba();
}
}
return destImage;
}
void ProcessEnv::resetEnv(const char* envName)
{
if (!envName)
return;
Int32 i;
size_t nameLen=strlen(envName);
CollHeap *stmtHeap = CmpCommon::statementHeap();
NAList<Int32> deleteArray(stmtHeap, 16); // 16 should be more than enough
// find the env in existing env array
for (i=0; i < envs_.getSize(); i++)
{
if (envs_.used(i))
{
char* pTemp = strchr(envs_[i], '=');
if (pTemp) // found '='
{
Int32 envLen = (Int32)(pTemp - envs_[i]);
if (envLen == nameLen && strncmp(envName, envs_[i], nameLen) == 0 )
{ // found matching env var name
*(pTemp) = '\0';
PUTENV(envs_[i]);
NADELETEBASIC(envs_[i], heap_);
deleteArray.insert(i);
}
}
}
}
// remove from the env array
for (Int32 j = 0; j < deleteArray.entries(); j++) {
envs_.remove(deleteArray[j]);
}
}
QImage edge_detector::detectEdgeImage(const QImage image, int kernel)
{
QImage destImage = QImage( image);
QRect rect = image.rect();
QColor qc;
int H = rect.height();
int W = rect.width();
int **a;
qreal gradient, gangle;
int r, g, b;
int maxg(0);
for (int y=0; y<H; y++) // y=1; y<H-1;
{
for (int x=0; x<W; x++) // x=1; x<W-1;
{
a = get_neighbor_pixels(image, x, y, 1, true);
edge_detect(a, kernel, &gradient, &gangle);
deleteArray(a, 3); //size of array allocated by get_neighbor_pixels is 3x3, 3 = (range=1)*2+1
if ((gangle >= -22.5 && gangle < 22.5) || (gangle >= 157.5 || gangle < -157.5))
{
r = 0;
g = 0;
b = 255;
}
else if ((gangle >= 22.5 && gangle < 67.5) || (gangle <= -112.5 && gangle > -157.5))
{
r = 0;
g = 255;
b = 0;
}
else if ((gangle >= 67.5 && gangle < 112.5) || (gangle <= -67.5 && gangle > -112.5))
{
r = 255;
g = 255;
b = 0;
}
else if ((gangle >= 112.5 && gangle < 157.5) || (gangle <= -22.5 && gangle > -67.5))
{
r = 255;
g = 0;
b = 0;
}
if (gradient > maxg)
maxg = gradient;
qc.setRgb((int)gradient & r, (int)gradient & g, (int)gradient & b);
destImage.setPixel( x, y, qc.rgba());
}
}
//printf("gangle = %f, maxg = %d\n", gangle, maxg);
return destImage;
}
void deleteRequestRecord(RequestRecord *rec) {
reset_request_record(rec);
deleteString(rec->host);
deleteString(rec->port);
deleteString(rec->method);
deleteString(rec->protocol);
deleteString(rec->path);
deleteString(rec->queryString);
deleteArray(rec->headerNames);
deleteArray(rec->headerValues);
deleteArray(rec->parameterNames);
deleteArray(rec->parameterValues);
free(rec);
}
int ExternalApplication::run( const uni_char *argument, int fd, const char* encoding )
{
uni_char **argv = parseCmdLine( m_cmdline, argument );
if (!argv || !argv[0] || !argv[0][0] )
{
errno = ENOENT;
return -1;
}
int result = run(argv, fd, spawn, encoding );
deleteArray(argv);
return result;
}
void Image::setDataBuffer(const GLubyte *buffer)
{
if (!buffer || !width || !height || !components)
return;
deleteArray(dataBuffer);
int size = (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) ?
((width + 3) / 4) * ((height + 3) / 4) * 8 :
((internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) || (internalFormat == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)) ?
((width + 3) / 4) * ((height + 3) / 4) * 16 : width * height * components;
dataBuffer = new GLubyte[size];
memcpy(dataBuffer, buffer, size);
}
void Image::flipVertically()
{
if (depth)
return;
GLubyte *newDataBuffer = new GLubyte[width*height*components];
int counterDown = 0,
counterUp = 0;
if (components == 3)
{
for (int y = 0, y1 = height - 1; y < height; y++, y1--)
for (int x = 0; x < width; x++)
{
counterUp = (x + y1 * width) * 3;
counterDown = (x + y * width) * 3;
newDataBuffer[counterUp + 0] = dataBuffer[counterDown + 0];
newDataBuffer[counterUp + 1] = dataBuffer[counterDown + 1];
newDataBuffer[counterUp + 2] = dataBuffer[counterDown + 2];
}
}
if (components == 4)
{
for (int y = 0, y1 = height - 1; y < height; y++, y1--)
for (int x = 0; x < width; x++)
{
counterUp = (x + y1 * width) * components;
counterDown = (x + y * width) * components;
newDataBuffer[counterUp + 0] = dataBuffer[counterDown + 0];
newDataBuffer[counterUp + 1] = dataBuffer[counterDown + 1];
newDataBuffer[counterUp + 2] = dataBuffer[counterDown + 2];
newDataBuffer[counterUp + 3] = dataBuffer[counterDown + 3];
}
}
if (components == 1)
{
for (int y = 0, y1 = height - 1; y < height; y++, y1--)
for (int x = 0; x < width; x++)
{
counterUp = x + y1 * width;
counterDown = x + y * width;
newDataBuffer[counterUp + 0] = dataBuffer[counterDown + 0];
}
}
setDataBuffer(newDataBuffer);
deleteArray(newDataBuffer);
}
void RawData::destroy()
{
if(data && !skipDelete)
{
deleteArray(data);
byteCount = 0;
}
}
int main(int argc, char** argv) {
time_t startTime, finishTime, totalTime = 0;
parseArgs(argc, argv);
createArray();
BTree* tree;
medrank solution;
generate();
printf("generated!\n");
char fileName[50];
int ans[queryNum];
startTime = clock();
for (int i = 0; i < randomSize; ++i) {
solution.generateFileName(i, fileName);
tree = new BTree;
tree->init(fileName, BLOCKLENGTH);
tree->bulkload(Litems[i], nSize);
delete tree;
}
finishTime = clock();
printf("bulkload finished!\n");
printf("Indexing Time: %.4fs\n", (float)(finishTime - startTime) / CLOCKS_PER_SEC);
FILE* absFileRead = fopen("./data/nearest.txt", "r");
float resultRatio = 0, result[queryNum];
for (int i = 0; i < queryNum; ++i) {
// printf("run start:%d\n", i);
result[i] = 0;
startTime = clock();
ans[i] = solution.runAlgorithm(q[i]);
finishTime = clock();
totalTime += finishTime - startTime;
for (int j = 0; j < dSize; ++j) {
result[i] += pow((queries[i][j] - a[ans[i]][j]),2);
}
result[i] = sqrt(result[i]);
float tmp = 0;
fscanf(absFileRead, "%f", &tmp);
// printf("Medrank Result: %f, cloest: %f\n", result[i], tmp);
resultRatio += (result[i] / tmp);
}
printf("Average Running Time: %.4fs\n", (float)totalTime / queryNum / CLOCKS_PER_SEC);
resultRatio /= queryNum;
printf("------Overall Ratio: %f------\n", resultRatio);
deleteArray();
return 0;
}
void ProcessEnv::removeEnv(char **newenvs, Lng32 nEnvs)
{
Lng32 i,j;
CollHeap *stmtHeap = CmpCommon::statementHeap();
NAList<Lng32> deleteArray(stmtHeap, 16);
#pragma warning (disable : 4018) //warning elimination
for (j=0; j < envs_.getSize(); j++)
#pragma warning (default : 4018) //warning elimination
{
if (envs_.used(j))
{
for (i=0; i < nEnvs; i++)
if (strcmp(newenvs[i], envs_[j]) ==0 )
break;
if ( i >= nEnvs )
{
// can't find it in newenvs, envs_[j] must have been deleted
char* pTemp = strchr(envs_[j], '=');
if (pTemp)
{
*(pTemp+1) = '\0';
PUTENV(envs_[j]);
NADELETEBASIC(envs_[j], heap_);
deleteArray.insert(j);
}
}
}
}
#pragma warning (disable : 4018) //warning elimination
for (j=0; j < deleteArray.entries(); j++) {
#pragma warning (default : 4018) //warning elimination
envs_.remove(deleteArray[j]);
}
}
//tworzy wszystkich graczy
bool Players::createPlayers(int numplayers, int sizex, int sizey)
{
if( numplayers > 0 && numplayers <= 4 )
{
m_numplayers = numplayers;
//kasowanie starej tablicy jesli istnieje
deleteArray();
string name;
for( int i = 0; i < m_numplayers; i++ )
{
name = "Gracz ";
name += char(i + 49);
switch( i )
{
case 0:
//key map: up - arrow up down - arrow down left - arrow left right - arrow right bomb - lshift
m_playersArray.push_back(new Player(1, 1, name, 0x26, 0x28, 0x25, 0x27, 0xA1));
break;
case 1:
//key map: up - w down - s left - a right - d bomb - q
m_playersArray.push_back(new Player(sizex - 2, sizey - 2, name, 0x57, 0x53, 0x41, 0x44, 0x51));
break;
case 2:
//key map: up - u down - j left - h right - k bomb - y
m_playersArray.push_back(new Player(1, sizey - 2, name, 0x55, 0x4A, 0x48, 0x4B, 0x59));
break;
case 3:
//key map: up - NUM 8 down - NUM 5 left - NUM 4 right - NUM 6 bomb - NUM 7
m_playersArray.push_back(new Player(sizex - 2, 1, name, 0x68, 0x65, 0x64, 0x66, 0x67));
break;
};
}
return true;
}
return false;
}
WLDFragmentTable::~WLDFragmentTable()
{
for(int i = 0; i < MAX_FRAGMENT_KINDS; i++)
deleteArray(i);
}
QImage edge_detector::blob_extract(const QImage image)
{
QImage destImage = QImage( image);
merge_find mf;
int H = destImage.height();
int W = destImage.width();
int* srcData = (int *)image.bits();
int* destData = (int *)destImage.bits();
// target image initialized with numbers
for (int row=0; row<H; row++)
{
for (int column=0; column<W; column++)
{
QColor qc = QColor(srcData[row*W+column]);
#ifdef Canny_Edge_Detection
// this initiation is used as step 5, edge tracking, of Canny Edge Detection
// assign the pixel as black:0, white:1, yellow:2, red:3, green:4, blue:5
int color = 0;
if (qc.red() == 255 && qc.green() == 255 && qc.blue() == 255) color = 1;
else if (qc.red() == 255 && qc.green() == 255) color = 2;
else if (qc.red() == 255) color = 3;
else if (qc.green() == 255) color = 4;
else if (qc.blue() == 255) color = 5;
destData[row*W+column] = color;
#else
// this initiation is used for blobs categorizing
// to be white if not background.
destData[row*W+column] = (srcData[row*W+column] & 0x0000ff) > 200 ? 1 : 0;
#endif // Canny_Edge_Detection
}
}
vector<Node> linked;
vector<int> n_labels;
int nextLabel(1);
// First pass
for (int row=0; row<H; row++)
{
for (int column=0; column<W; column++)
{
if (int color = destData[row*W+column] & 0x000007) // is not Background
{
// neighbors = connected elements with the current element's value
int** neighbors = get_neighbor_pixels(destImage, column, row, 1);
int lowest = mf.find_lowest(neighbors, 1);
if (lowest == 0) // if neighbor is empty
{
Node node = /*new*/ Node(nextLabel, destData[row*W+column] & 0x000007);
linked.push_back(node);
destData[row*W+column] = nextLabel;
nextLabel++;
}
else // to assign the smallest label
{
destData[row*W+column] = lowest;
n_labels = mf.get_neighbor_labels(neighbors, 1);
// this is the key to link weak points to strong
if (color == 1)
linked[lowest-1].color = 1;
for (int l=0; l<(int)n_labels.size(); l++)
if (n_labels[l] > 0)
mf.merge(linked[n_labels[l]-1], linked[lowest-1]);
}
deleteArray(neighbors, 3); // 3=1*2+1
}
}
}
// Second pass
for (int row=0; row<H; row++)
{
for (int column=0; column<W; column++)
{
int x = destData[row*W+column] & 0x0000ff;
if (x) // is not Background
{
Node root = mf.find(linked[x-1]);
#ifdef Canny_Edge_Detection
// this color recovery is for Canny Edge Detection
QColor qc = (root.color == 1) ? Qt::white : Qt::black;
// (root.color == 2) ? Qt::yellow : // test
// (root.color == 3) ? Qt::red :
// (root.color == 4) ? Qt::green :
// (root.color == 5) ? Qt::blue : Qt::black;
destData[row*W+column] = qc.rgba();
#else
// Blobs categorizing
destData[row*W+column] = 0x0000ff << root.label;
#endif // Canny_Edge_Detection
//printf("(%i %i) ", x, root.color);
}
}
}
return destImage;
}
Image::~Image()
{
if (dataBuffer)
deleteArray(dataBuffer);
}
FUNCTION void Q4Y8()
{
if(hasObjVar(this, "debugSkillInfo"))
{
deleteArray(0x00);
}
if(isArrayInit(0x00))
{
return;
}
list Q4Y9 = list( 0x00, 0x01, "COL_NAME", 0x03, 0x04, 0x05 );
initArray(0x00, 0x06, 0x3D, Q4Y9);
int Q5NY = 0x00;
Q4Y9 = list( 0x0FAF, 0x00, "Repair an Item", 0x00 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x13ED, 0x36, "Build Armor", 0x01 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x13EC, 0x36, "Build Ring Armor", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x13EB, 0x13EF, 0x13F0, 0x13EC );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
Q4Y9 = list( 0x13BF, 0x36, "Build Chain Armor", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x13BB, 0x13BE, 0x13BF );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
Q4Y9 = list( 0x1415, 0x36, "Build Plate Armor", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x1408, 0x36, "Build Helmets", 0x03 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x140A, 0x140C, 0x140E, 0x1408, 0x1412 );
Q5NY = Q4Y7(Q5NY, 0x03, Q4Y9);
Q4Y9 = list( 0x1413, 0x1414, 0x1410, 0x1411, 0x1415, 0x1C04 );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
Q4Y9 = list( 0x1B74, 0x36, "Build Shields", 0x01 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x1B73, 0x1B72, 0x1B7B, 0x1B78, 0x1B74, 0x1B76 );
Q5NY = Q4Y7(Q5NY, 0x01, Q4Y9);
Q4Y9 = list( 0x0F45, 0x36, "Build Weapons", 0x01 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x0F61, 0x36, "Build Blades", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x0F51, 0x1441, 0x13FF, 0x1401, 0x13B6, 0x0F5E, 0x0F61, 0x13B9 );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
Q4Y9 = list( 0x13FB, 0x36, "Build Axes", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x0F47, 0x0F49, 0x0F45, 0x1443, 0x0F4B, 0x13FB, 0x13B0 );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
Q4Y9 = list( 0x0F4D, 0x36, "Build Pole Arms", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x1403, 0x0F62, 0x1405, 0x0F4D, 0x143F );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
Q4Y9 = list( 0x1407, 0x36, "Build Bludgeoning Weapons", 0x02 );
setArrayElems(0x00, 0x00, Q5NY, Q4Y9);
Q5NY ++;
Q4Y9 = list( 0x0F5C, 0x143B, 0x1407, 0x1439, 0x143D );
Q5NY = Q4Y7(Q5NY, 0x02, Q4Y9);
debugMessage("BlackSmithing Loaded: Allocated Rows= " + 0x3D + " Computed Rows:" + Q5NY);
int Q576 = 0x000F4240;
int Q55T = 0x00;
int i;
int val;
int Q577;
int Q567;
for(i = 0x01; i < Q5NY; i ++)
{
if(getArrayIntElem(0x00, 0x01, i) != 0x36)
{
val = getArrayIntElem(0x00, 0x05, i);
if(Q55T < val)
{
Q55T = val;
Q567 = getArrayIntElem(0x00, 0x00, i);
}
if(Q576 > val)
{
Q576 = val;
Q577 = getArrayIntElem(0x00, 0x00, i);
}
}
}
debugMessage("Min Value=" + Q576 + " (" + Q577 + ") Max Value=" + Q55T + " (" + Q567 + ")");
int range = Q55T - Q576;
for(i = 0x01; i < Q5NY; i ++)
{
if(getArrayIntElem(0x00, 0x01, i) != 0x36)
{
val = getArrayIntElem(0x00, 0x05, i);
int Q4IA = (val - Q576) * 0x03E8 / range;
setArrayIntElem(0x00, 0x05, i, Q4IA);
}
}
return;
}
void getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image3D image, DataType type, float* min, float* max) {
// Get power of two size
unsigned int powerOfTwoSize = getPowerOfTwoSize(std::max(image.getImageInfo<CL_IMAGE_DEPTH>(), std::max(
image.getImageInfo<CL_IMAGE_WIDTH>(),
image.getImageInfo<CL_IMAGE_HEIGHT>())));
// Create image levels
unsigned int size = powerOfTwoSize;
size /= 2;
std::vector<cl::Image3D> levels;
while(size >= 4) {
cl::Image3D level = cl::Image3D(device->getContext(), CL_MEM_READ_WRITE, getOpenCLImageFormat(device, CL_MEM_OBJECT_IMAGE3D, type, 2), size, size, size);
levels.push_back(level);
size /= 2;
}
// Compile OpenCL code
std::string buildOptions = "";
switch(type) {
case TYPE_FLOAT:
buildOptions = "-DTYPE_FLOAT";
break;
case TYPE_UINT8:
buildOptions = "-DTYPE_UINT8";
break;
case TYPE_INT8:
buildOptions = "-DTYPE_INT8";
break;
case TYPE_UINT16:
buildOptions = "-DTYPE_UINT16";
break;
case TYPE_INT16:
buildOptions = "-DTYPE_INT16";
break;
}
std::string sourceFilename = std::string(FAST_SOURCE_DIR) + "/ImageMinMax.cl";
std::string programName = sourceFilename + buildOptions;
// Only create program if it doesn't exist for this device from before
if(!device->hasProgram(programName))
device->createProgramFromSourceWithName(programName, sourceFilename, buildOptions);
cl::Program program = device->getProgram(programName);
cl::CommandQueue queue = device->getCommandQueue();
// Fill first level
size = powerOfTwoSize/2;
cl::Kernel firstLevel(program, "createFirstMinMaxImage3DLevel");
firstLevel.setArg(0, image);
firstLevel.setArg(1, levels[0]);
queue.enqueueNDRangeKernel(
firstLevel,
cl::NullRange,
cl::NDRange(size,size,size),
cl::NullRange
);
// Fill all other levels
cl::Kernel createLevel(program, "createMinMaxImage3DLevel");
int i = 0;
size /= 2;
while(size >= 4) {
createLevel.setArg(0, levels[i]);
createLevel.setArg(1, levels[i+1]);
queue.enqueueNDRangeKernel(
createLevel,
cl::NullRange,
cl::NDRange(size,size,size),
cl::NullRange
);
i++;
size /= 2;
}
// Get result from the last level
unsigned int nrOfElements = 4*4*4;
unsigned int nrOfComponents = getOpenCLImageFormat(device, CL_MEM_OBJECT_IMAGE3D, type, 2).image_channel_order == CL_RGBA ? 4 : 2;
void* result = allocateDataArray(nrOfElements,type,nrOfComponents);
queue.enqueueReadImage(levels[levels.size()-1],CL_TRUE,createOrigoRegion(),createRegion(4,4,4),0,0,result);
switch(type) {
case TYPE_FLOAT:
getMaxAndMinFromOpenCLImageResult<float>(result, nrOfElements, nrOfComponents, min, max);
break;
case TYPE_INT8:
getMaxAndMinFromOpenCLImageResult<char>(result, nrOfElements, nrOfComponents, min, max);
break;
case TYPE_UINT8:
getMaxAndMinFromOpenCLImageResult<uchar>(result, nrOfElements, nrOfComponents, min, max);
break;
case TYPE_INT16:
getMaxAndMinFromOpenCLImageResult<short>(result, nrOfElements, nrOfComponents, min, max);
break;
case TYPE_UINT16:
getMaxAndMinFromOpenCLImageResult<ushort>(result, nrOfElements, nrOfComponents, min, max);
break;
}
deleteArray(result, type);
}
int XMLStack::loadXMLFile(const char *xmlFilePath)
{
const char *verifiedPath = MediaPathManager::lookUpMediaPath(xmlFilePath);
size_t pathLength = 0;
char *progress = 0,
*stream = 0;
bufferProgress = 0;
bufferSize = 0;
flush();
if(!verifiedPath)
return (state = XML_FILE_NOT_FOUND);
pathLength = stx_strlen(verifiedPath);
for(size_t t = 0; t < pathLength; t++)
{
if(verifiedPath[t] == '.')
break;
logFilePath += verifiedPath[t];
}
logFilePath += ".err";
state = XML_SUCCESS;
std::string fn=stx_convertpath(verifiedPath);
LOG_PRINT("XMLStack::loadXMLFile:ifstream=%s\n", fn.c_str());
ifstream fileInputStream(fn.c_str(), ifstream::in | ifstream::binary);
fileInputStream.seekg(0, ios::end);
bufferSize = fileInputStream.tellg();
stream = new char[bufferSize + 1];
progress = stream;
memset(stream, 0, bufferSize + 1);
fileInputStream.seekg(0, ios::beg);
fileInputStream.read(stream, bufferSize);
fileInputStream.close();
do
{
XMLElement *parent = new XMLElement();
progress = parseXMLStream(progress, parent);
addChild(parent);
}
while(*progress && (state == XML_SUCCESS));
deleteArray(stream);
if(state != XML_SUCCESS)
{
flush();
NatureScene::Logger::writeErrorLog(NSString("Failed to parse the XML File at <") +
verifiedPath + ">");
return -1;//???
}
return XML_SUCCESS;
}
inline void Kruscal(const Graph& g, vector<Edge>& MST)
{
int n = g.n;
int i = 0, j = 0;
map<int, vector<Edge> > edgeG;
bool** reachAble = (bool**)malloc(sizeof(bool*) * n);
for(i = 0; i < n; i++)
{
reachAble[i] = (bool*)malloc(sizeof(bool) * n);
memset(reachAble[i], false, sizeof(bool) * n);
}
MST.clear();
for(i = 0; i < n - 1; i++)
{
for(j = i + 1; j < n; j++)
{
if(g.weight[i][j] != INT_MAX)
{
edgeG[g.weight[i][j]].push_back(Edge(i, j, g.weight[i][j]));
}
}
}
for(map<int, vector<Edge> >::iterator it = edgeG.begin(); it != edgeG.end(); it++)
{
vector<Edge> vEdge(it->second.begin(), it->second.end());
for(vector<Edge>::iterator iit = vEdge.begin(); iit != vEdge.end(); iit++)
{
int n1 = (*iit).node1;
int n2 = (*iit).node2;
/* If n1 and n2 are not connected, adding this edge or not. */
if(reachAble[n1][n2])
{
continue;
}
MST.push_back(*iit);
vector<int> nset1;
vector<int> nset2;
nset1.push_back(n1);
nset2.push_back(n2);
/* Modify the reachable matrix. */
for(i = 0; i < n; i++)
{
if(reachAble[i][n1])
{
nset1.push_back(i);
}
if(reachAble[i][n2])
{
nset2.push_back(i);
}
}
for(i = 0; i < nset1.size(); i++)
{
for(j = 0; j < nset2.size(); j++)
{
reachAble[nset1[i]][nset2[j]] = true;
reachAble[nset2[j]][nset1[i]] = true;
}
}
}
/* If the minimum spanning tree has had (n - 1) edges, stop the process. */
if(MST.size() == n - 1)
{
break;
}
}
deleteArray(n, reachAble);
}
void CalculateOrdinaryScore(FlowDist *flowDist, AlleleIdentity &variant_identity,
vcf::Variant ** candidate_variant, ControlCallAndFilters &my_controls,
bool *isFiltered, int DEBUG) {
vector<float>* reflikelihoods = flowDist->getReferenceLikelihoods();
vector<float>* varlikelihoods = flowDist->getVariantLikelihoods();
int totalReads = reflikelihoods->size();
const int totalHypotheses = 2;
float **scoreLikelihoods;
float refLikelihoods;
float varLikelihoods;
float scores[totalHypotheses] = {0};
int counts[totalHypotheses] = {0};
float minDiff = 2.0;
float minLikelihoods = 3.0;
allocateArray(&scoreLikelihoods, totalReads, totalHypotheses);
for (int i = 0; i < totalReads; i++) {
refLikelihoods = reflikelihoods->at(i);
varLikelihoods = varlikelihoods->at(i);
if (DEBUG)
cout << "ref likelihood = " << refLikelihoods << endl;
scoreLikelihoods[i][0] = refLikelihoods;
scoreLikelihoods[i][1] = varLikelihoods;
}
if (variant_identity.status.isSNP || variant_identity.status.isMNV) {
minDiff = 1.0;
minLikelihoods = 0.5;
}
calc_score_hyp(totalReads, totalHypotheses, scoreLikelihoods, scores, counts, minDiff, minLikelihoods);
float BayesianScore;
BayesianScore = scores[1];
//string *filterReason = new string();
//cout << "Bayesian Score = " << BayesianScore << endl;
float stdBias = flowDist->summary_stats.getStrandBias();
float refBias = flowDist->summary_stats.getRefStrandBias();
//float baseStdBias = flowDist->summary_stats.getBaseStrandBias();
/* moving filter operation to DecisionTree
*isFiltered = filterVariants(filterReason, variant_identity.status.isSNP, variant_identity.status.isMNV, variant_identity.status.isIndel, variant_identity.status.isHPIndel,
false, BayesianScore, my_controls, 0, 0, 0, stdBias, refBias, baseStdBias,
flowDist->summary_stats.getAltAlleleFreq(), variant_identity.refHpLen, abs(variant_identity.inDelLength));
flowDist->summary_info.isFiltered= *isFiltered;
*/
flowDist->summary_info.alleleScore = BayesianScore;
//flowDist->summary_info.filterReason = *filterReason;
//now if the allele is a SNP and a possible overcall/undercall FP SNP, evaluate the score for HP lengths on either side of SNP
//we move filtering to final stage so calculate confidence of HP length for all overcall/undercall snps
if (variant_identity.status.isSNP && variant_identity.status.isOverCallUnderCallSNP &&
(variant_identity.underCallLength+1 > 11 || variant_identity.overCallLength-1 > 11) ) {
flowDist->summary_info.isFiltered = true;
flowDist->summary_info.filterReason = "Overcall/Undercall_HP_SNP";
flowDist->summary_info.alleleScore = 0.0;
}
if (!flowDist->summary_info.isFiltered && variant_identity.status.isSNP && variant_identity.status.isOverCallUnderCallSNP) {
float overCallHPScore = 0.0f;
float underCallHPScore = 0.0f;
bool isUnderCallRef = false;
bool isOverCallRef = false;
float underCallFreq = 0.0;
float overCallFreq = 0.0;
float maxProb = 0;
int * peak_finding_tuning_parameters = new int[9];
peak_finding_tuning_parameters[NDX_MIN_FREQUENCY_SMALL_PEAK] = (int)(my_controls.filter_hp_indel.min_allele_freq *100);
peak_finding_tuning_parameters[NDX_MIN_FLOW_PEAK_SHORTHP_DISTANCE] = 85;
peak_finding_tuning_parameters[NDX_MIN_FLOW_PEAK_LONGHP_DISTANCE] = 85;
peak_finding_tuning_parameters[NDX_SHORT_HP_FOR_PEAK] = 8;
peak_finding_tuning_parameters[NDX_MAX_PEAK_DEVIATION] = my_controls.control_peak.fpe_max_peak_deviation;
peak_finding_tuning_parameters[NDX_PARAM_FIVE_NOT_USED] = 0;
peak_finding_tuning_parameters[NDX_CALL_USING_EM_METHOD] = 0;
peak_finding_tuning_parameters[NDX_PARAM_SEVEN_NOT_USED] = 0;
peak_finding_tuning_parameters[NDX_STRAND_BIAS] = (int)(0.5*100);
float * peak_finding_results = new float[13];
int optimization_start, optimization_end;
optimization_start = max((variant_identity.underCallLength-3)*100, 0);
optimization_end = min((variant_identity.underCallLength+3)*100, MAXSIGDEV);
int variation_allowed = variant_identity.underCallLength;
runLMS((int*) flowDist->getHomPolyDist(), MAXSIGDEV, peak_finding_tuning_parameters, peak_finding_results,
optimization_start, optimization_end,
variant_identity.underCallLength+1, variation_allowed, DEBUG);
compute_maxProb(peak_finding_results, variant_identity.underCallLength+1, maxProb, isUnderCallRef, refBias);
underCallHPScore = compute_bayesian_score(maxProb);
underCallFreq = peak_finding_results[5];
delete[] peak_finding_results;
//now evaluate the overcall HP length
maxProb = 0;
peak_finding_results = new float[13];
for (size_t i = 0; i < 13; i++ )
peak_finding_results[i] = 0;
optimization_start = max((variant_identity.overCallLength-3)*100, 0);
optimization_end = min((variant_identity.overCallLength+3)*100, MAXSIGDEV);
variation_allowed = variant_identity.overCallLength;
runLMS((int*) flowDist->getHomPolyDist(), MAXSIGDEV, peak_finding_tuning_parameters, peak_finding_results,
optimization_start, optimization_end,
variant_identity.overCallLength-1, variation_allowed, DEBUG);
delete[] peak_finding_tuning_parameters;
compute_maxProb(peak_finding_results, variant_identity.overCallLength-1, maxProb, isOverCallRef, refBias);
overCallHPScore = compute_bayesian_score(maxProb);
overCallFreq = peak_finding_results[5];
//not sure how to move this part to decision tree, leaving it here for now.
if (isUnderCallRef || isOverCallRef
|| underCallHPScore < 5 || overCallHPScore < 5
|| overCallFreq < my_controls.filter_snps.min_allele_freq || underCallFreq < my_controls.filter_snps.min_allele_freq) {
//filter the variant as possible overcall undercall FP
flowDist->summary_info.isFiltered = true;
flowDist->summary_info.filterReason = "Overcall/Undercall_HP_SNP";
flowDist->summary_info.alleleScore = 0.0;
}
}
stringstream infoss;
infoss << "Score= " << scores[1] << " | STDBIAS= "<< stdBias;
flowDist->summary_info.infoString = infoss.str();
//InsertGenericInfoTag(candidate_variant, infoss);
//if (filterReason!=NULL)
// delete filterReason;
deleteArray(&scoreLikelihoods, totalReads, totalHypotheses);
}
void getMaxAndMinFromOpenCLBuffer(OpenCLDevice::pointer device, cl::Buffer buffer, unsigned int size, DataType type, float* min, float* max) {
// Compile OpenCL code
std::string buildOptions = "";
switch(type) {
case TYPE_FLOAT:
buildOptions = "-DTYPE_FLOAT";
break;
case TYPE_UINT8:
buildOptions = "-DTYPE_UINT8";
break;
case TYPE_INT8:
buildOptions = "-DTYPE_INT8";
break;
case TYPE_UINT16:
buildOptions = "-DTYPE_UINT16";
break;
case TYPE_INT16:
buildOptions = "-DTYPE_INT16";
break;
}
std::string sourceFilename = std::string(FAST_SOURCE_DIR) + "/ImageMinMax.cl";
std::string programName = sourceFilename + buildOptions;
// Only create program if it doesn't exist for this device from before
if(!device->hasProgram(programName))
device->createProgramFromSourceWithName(programName, sourceFilename, buildOptions);
cl::Program program = device->getProgram(programName);
cl::CommandQueue queue = device->getCommandQueue();
// Nr of work groups must be set so that work-group size does not exceed max work-group size (256 on AMD)
int length = size;
cl::Kernel reduce(program, "reduce");
cl::Buffer current = buffer;
cl::Buffer clResult;
int workGroupSize = 256;
int workGroups = 256;
int X = ceil((float)length / (workGroups*workGroupSize));
clResult = cl::Buffer(device->getContext(), CL_MEM_READ_WRITE, getSizeOfDataType(type,1)*workGroups*2);
reduce.setArg(0, current);
reduce.setArg(1, workGroupSize * getSizeOfDataType(type,1), NULL);
reduce.setArg(2, workGroupSize * getSizeOfDataType(type,1), NULL);
reduce.setArg(3, size);
reduce.setArg(4, X);
reduce.setArg(5, clResult);
queue.enqueueNDRangeKernel(
reduce,
cl::NullRange,
cl::NDRange(workGroups*workGroupSize),
cl::NDRange(workGroupSize)
);
length = workGroups;
void* result = allocateDataArray(length, type, 2);
unsigned int nrOfElements = length;
queue.enqueueReadBuffer(clResult,CL_TRUE,0,getSizeOfDataType(type,1)*workGroups*2,result);
switch(type) {
case TYPE_FLOAT:
getMaxAndMinFromOpenCLImageResult<float>(result, nrOfElements, 2, min, max);
break;
case TYPE_INT8:
getMaxAndMinFromOpenCLImageResult<char>(result, nrOfElements, 2, min, max);
break;
case TYPE_UINT8:
getMaxAndMinFromOpenCLImageResult<uchar>(result, nrOfElements, 2, min, max);
break;
case TYPE_INT16:
getMaxAndMinFromOpenCLImageResult<short>(result, nrOfElements, 2, min, max);
break;
case TYPE_UINT16:
getMaxAndMinFromOpenCLImageResult<ushort>(result, nrOfElements, 2, min, max);
break;
}
deleteArray(result, type);
}
bool PraetoriansTerrainWater::loadPackedMedia(const char* path)
{
unsigned int signature;
unsigned short chunkid;
unsigned int chunklength;
unsigned int texturescount;///use one in this version
unsigned int watercount;
unsigned int vertexcount;
unsigned int indexcount;
Tuple3f* vertices;
unsigned short* indices;
Tuple4ub* colors;
Tuple2f* txcoords;
ArchivedFile* file;
WaterDatabase* wdatabase;
if (!(file = FileSystem::checkOut(path)))
return Logger::writeErrorLog(String("Could not load -> ") + path);
wdatabase = Gateway::getWaterDatabase();
file->read(&signature, 4);
file->read(&chunkid, 2);
file->read(&chunklength, 4);
file->read(&texturescount, 4);
for (unsigned int i = 0; i < texturescount; i++)
file->seek((256 * 256 * 4) + 6, SEEKD);
file->read(&watercount, 4);
for (unsigned int i = 0; i < watercount; i++)
{
file->read(&chunkid, 2);
file->read(&chunklength, 4);
file->seek(48, SEEKD);
file->read(&vertexcount, 4);
vertices = new Tuple3f[vertexcount];
colors = new Tuple4ub[vertexcount];
txcoords = new Tuple2f[vertexcount];
for (unsigned int j = 0; j < vertexcount; j++)
{
file->read(vertices[j], 12);
Swap(vertices[j].x, vertices[j].z);
file->read(colors[j], 4);
Swap(colors[j].x, colors[j].z);
file->read(txcoords[j], 8);
}
file->read(&indexcount, 4);
indices = new unsigned short[indexcount];
file->read(indices, indexcount * 2);
String watername = String("H2O_") + int(wdatabase->getWatersCount());
Geometry* geometry;
geometry = new Geometry(watername, indexcount, vertexcount);
geometry->setIndices(indices, false);
geometry->setVertices(vertices, false);
geometry->setColors(colors, false);
geometry->setTextureElements(txcoords, 2, false);
geometry->computeBounds();
Appearance* appearance = new Appearance();
appearance->setBlendAttributes(BlendAttributes(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
appearance->setTexture(0, wdatabase->getWaterTexture());
Model* model = new Model();
model->setAppearance(appearance);
model->setGeometry(geometry);
TransformGroup* group = new TransformGroup();
group->addChild(model);
group->updateBoundsDescriptor();
wdatabase->addWaterModel(group);
deleteArray(vertices);
deleteArray(indices);
deleteArray(colors);
deleteArray(txcoords);
}
FileSystem::checkIn(file);
return true;
}
//destruktor
Players::~Players()
{
deleteArray();
}
