/////////////////////////////////////////////////////////////////////////////// // 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(); }