QWidget* createFilters(QWidget* parent) { parent->setObjectName("filters"); QGridLayout* grid = new QGridLayout(parent); // row 1 grid->addWidget(createIndex("1"), 0, 0); grid->addWidget(createFilter(new QGroupBox(), 0), 0, 1); // row 2 grid->addWidget(createIndex("2"), 1, 0); grid->addWidget(createFilter(new QGroupBox(), 1), 1, 1); grid->setColumnStretch(1, 1); grid->setHorizontalSpacing(2); return parent; }
void TerrainGeneratorLoader::loadLayerItem (Iff& iff, TerrainGenerator* terrainGenerator, TerrainGenerator::Layer* layer) { TerrainGenerator::Boundary* boundary = createBoundary (iff); if (boundary) layer->addBoundary (boundary); else { TerrainGenerator::Filter* filter = createFilter (iff, terrainGenerator); if (filter) layer->addFilter (filter); else { TerrainGenerator::Affector* affector = createAffector (iff, terrainGenerator); if (affector) layer->addAffector (affector); else { DEBUG_FATAL (iff.getCurrentName () != TAG_LAYR, ("not at layer in terrain file")); TerrainGenerator::Layer* sublayer = new TerrainGenerator::Layer (); sublayer->load (iff, terrainGenerator); layer->addLayer (sublayer); } //lint !e429 //-- sublayer has not been freed or returned } } }
////////////////// PathInfo ////////////////// PathInfo::PathInfo(const Unit* owner, const float destX, const float destY, const float destZ, bool useStraightPath) : m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(useStraightPath), m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL) { PathNode endPoint(destX, destY, destZ); setEndPosition(endPoint); float x,y,z; m_sourceUnit->GetPosition(x, y, z); PathNode startPoint(x, y, z); setStartPosition(startPoint); DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathInfo::PathInfo for %u \n", m_sourceUnit->GetGUID()); uint32 mapId = m_sourceUnit->GetMapId(); if (MMAP::MMapFactory::IsPathfindingEnabled(mapId)) { MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager(); m_navMesh = mmap->GetNavMesh(mapId); m_navMeshQuery = mmap->GetNavMeshQuery(mapId, m_sourceUnit->GetInstanceId()); } createFilter(); if (m_navMesh && m_navMeshQuery && !m_sourceUnit->hasUnitState(UNIT_STAT_IGNORE_PATHFINDING)) { BuildPolyPath(startPoint, endPoint); } else { BuildShortcut(); m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); } }
dtPolyRef PathInfo::getPolyByLocation(const float* point, float *distance) { // first we check the current path // if the current path doesn't contain the current poly, // we need to use the expensive navMesh.findNearestPoly dtPolyRef polyRef = getPathPolyByPosition(m_pathPolyRefs, m_polyLength, point, distance); if(polyRef != INVALID_POLYREF) return polyRef; // we don't have it in our old path // try to get it by findNearestPoly() // first try with low search box float extents[VERTEX_SIZE] = {3.0f, 5.0f, 3.0f}; // bounds of poly search area dtQueryFilter filter = createFilter(); float closestPoint[VERTEX_SIZE] = {0.0f, 0.0f, 0.0f}; dtStatus result = m_navMeshQuery->findNearestPoly(point, extents, &filter, &polyRef, closestPoint); if(DT_SUCCESS == result && polyRef != INVALID_POLYREF) { *distance = dtVdist(closestPoint, point); return polyRef; } // still nothing .. // try with bigger search box extents[1] = 200.0f; result = m_navMeshQuery->findNearestPoly(point, extents, &filter, &polyRef, closestPoint); if(DT_SUCCESS == result && polyRef != INVALID_POLYREF) { *distance = dtVdist(closestPoint, point); return polyRef; } return INVALID_POLYREF; }
void HelmVoiceHandler::init() { // Create modulation and pitch wheels. mod_wheel_amount_ = new SmoothValue(0); pitch_wheel_amount_ = new SmoothValue(0); mod_sources_["pitch_wheel"] = pitch_wheel_amount_->output(); mod_sources_["mod_wheel"] = mod_wheel_amount_->output(); // Create all synthesizer voice components. createArticulation(note(), velocity(), voice_event()); createOscillators(current_frequency_->output(), amplitude_envelope_->output(Envelope::kFinished)); createModulators(amplitude_envelope_->output(Envelope::kFinished)); createFilter(osc_feedback_->output(0), note_from_center_->output(), amplitude_envelope_->output(Envelope::kFinished), voice_event()); Value* aftertouch_value = new Value(); aftertouch_value->plug(aftertouch()); addProcessor(aftertouch_value); mod_sources_["aftertouch"] = aftertouch_value->output(); output_->plug(formant_container_, 0); output_->plug(amplitude_, 1); addProcessor(output_); addGlobalProcessor(pitch_wheel_amount_); addGlobalProcessor(mod_wheel_amount_); setVoiceKiller(amplitude_envelope_->output(Envelope::kValue)); HelmModule::init(); }
void PipelineManager::createFilterEvent(Jzon::Node* params, Jzon::Object &outputNode) { int id; FilterType fType; BaseFilter* filter; if(!params) { outputNode.Add("error", "Error creating filter. Invalid JSON format..."); return; } if (!params->Has("id") || !params->Has("type")) { outputNode.Add("error", "Error creating filter. Invalid JSON format..."); return; } id = params->Get("id").ToInt(); fType = utils::getFilterTypeFromString(params->Get("type").ToString()); filter = createFilter(fType, params); if (!filter) { outputNode.Add("error", "Error creating filter. Specified type is not correct.."); return; } if (!addFilter(id, filter)) { outputNode.Add("error", "Error registering filter. Specified ID already exists.."); return; } outputNode.Add("error", Jzon::null); }
std::vector<ValueRange<>> GlyphMagnitudeColorMapping::updateBounds() { decltype(updateBounds())::value_type totalRange; for (auto & mapping : m_glyphMappingData) { // access lazily created filters auto && filter = createFilter(*mapping.first); assert(filter && filter->GetNumberOfInputConnections(0) > 0); if (!filter->GetExecutive()->Update()) { continue; } // At this pipeline stage, initial cell attributes are associated with the intermediate // point geometry. auto dataSet = vtkDataSet::SafeDownCast(filter->GetOutputDataObject(0)); assert(dataSet); auto normData = dataSet->GetPointData()->GetScalars(); assert(normData); decltype(totalRange) range; normData->GetRange(range.data()); totalRange.add(range); } return{ totalRange }; }
Bellerophon::Bellerophon(string name, bool filterSeqs, bool c, int win, int inc, int p, string o) : Chimera() { try { fastafile = name; correction = c; outputDir = o; window = win; increment = inc; processors = p; //read in sequences seqs = readSeqs(fastafile); numSeqs = seqs.size(); if (numSeqs == 0) { m->mothurOut("Error in reading you sequences."); m->mothurOutEndLine(); exit(1); } //do soft filter if (filterSeqs) { createFilter(seqs, 0.5); for (int i = 0; i < seqs.size(); i++) { runFilter(seqs[i]); } } distCalculator = new eachGapDist(); //set default window to 25% of sequence length string seq0 = seqs[0]->getAligned(); if (window == 0) { window = seq0.length() / 4; } else if (window > (seq0.length() / 2)) { m->mothurOut("Your sequence length is = " + toString(seq0.length()) + ". You have selected a window size greater than the length of half your aligned sequence. I will run it with a window size of " + toString((seq0.length() / 2))); m->mothurOutEndLine(); window = (seq0.length() / 2); } if (increment > (seqs[0]->getAlignLength() - (2*window))) { if (increment != 10) { m->mothurOut("You have selected a increment that is too large. I will use the default."); m->mothurOutEndLine(); increment = 10; if (increment > (seqs[0]->getAlignLength() - (2*window))) { increment = 0; } }else{ increment = 0; } } if (increment == 0) { iters = 1; } else { iters = ((seqs[0]->getAlignLength() - (2*window)) / increment); } //initialize pref pref.resize(iters); for (int i = 0; i < iters; i++) { Preference temp; for (int j = 0; j < numSeqs; j++) { pref[i].push_back(temp); } } } catch(exception& e) { m->errorOut(e, "Bellerophon", "Bellerophon"); exit(1); } }
PppoeWidget::PppoeWidget(QWidget *parent) : QWidget(parent), ui(new Ui::PppoeWidget) { ui->setupUi(this); createActions(); createFilter(); clear(); }
int main(int ac, char *av[]) { char rpath[MAX_NAME_LEN]; int status, *jstatus; simplequeue_t *outputQ, *workQ, *qtoa; pthread_t IGMP_broadcast_thread; // create separate thread for broadcasting IGMP group query messages pthread_create(&IGMP_broadcast_thread, NULL, IGMPBroadcast, NULL); // setup the program properties setupProgram(ac, av); // creates a PID file under router_name.pid in the current directory status = makePIDFile(rconfig.router_name, rpath); // shutdown the router on receiving SIGUSR1 or SIGUSR2 redefineSignalHandler(SIGUSR1, shutdownRouter); redefineSignalHandler(SIGUSR2, shutdownRouter); outputQ = createSimpleQueue("outputQueue", INFINITE_Q_SIZE, 0, 1); workQ = createSimpleQueue("work Queue", INFINITE_Q_SIZE, 0, 1); GNETInit(&(rconfig.ghandler), rconfig.config_dir, rconfig.router_name, outputQ); ARPInit(); IPInit(); classifier = createClassifier(); filter = createFilter(classifier, 0); pcore = createPacketCore(rconfig.router_name, outputQ, workQ); // add a default Queue.. the createClassifier has already added a rule with "default" tag // char *qname, char *dqisc, double qweight, double delay_us, int nslots); addPktCoreQueue(pcore, "default", "taildrop", 1.0, 2.0, 0); rconfig.scheduler = PktCoreSchedulerInit(pcore); rconfig.worker = PktCoreWorkerInit(pcore); infoInit(rconfig.config_dir, rconfig.router_name); addTarget("Output Queue", outputQ); qtoa = getCoreQueue(pcore, "default"); if (qtoa != NULL) addTarget("Default Queue", qtoa); else printf("Error .. found null queue for default\n"); // start the CLI.. CLIInit(&(rconfig)); wait4thread(rconfig.scheduler); wait4thread(rconfig.worker); wait4thread(rconfig.ghandler); wait4thread(IGMP_broadcast_thread); }
void CSobel::sobel_function(String filename, String fileout) { img = imread(filename, CV_LOAD_IMAGE_COLOR); if (!img.data) cout << "Could not open or find the image" << endl; else { vector<vector<double>> filter = createFilter(5, 5, 1); grayscaled = Mat(toGrayScale()); gFiltered = Mat(useFilter(grayscaled, filter)); sFiltered = Mat(sobelFilter()); imwrite(fileout, sFiltered); } }
////////////////// PathFinder ////////////////// PathFinder::PathFinder(const Unit* owner) : m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(false), m_forceDestination(false), m_pointPathLimit(MAX_POINT_PATH_LENGTH), m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL) { //DEBUG_FILTER_LOG(LOG_FILTER_PATHFINDING, "++ PathFinder::PathInfo for %u \n", m_sourceUnit->GetGUIDLow()); if (m_sourceUnit->GetTypeId() == TYPEID_UNIT && m_sourceUnit->ToCreature()->isPet() && (!m_sourceUnit->getVictim() && m_sourceUnit->isInCombat())) { createFilter(); return; } if (m_sourceUnit->GetTerrain() && m_sourceUnit->GetTerrain()->IsPathFindingEnabled(owner)) { uint32 mapId = m_sourceUnit->GetMapId(); MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager(); m_navMesh = mmap->GetNavMesh(mapId); m_navMeshQuery = mmap->GetNavMeshQuery(mapId, m_sourceUnit->GetInstanceId()); } createFilter(); }
void MainPanel::comboBoxChanged (ComboBox* ctrl) { if (ctrl == m_menuFamily) { buildTypeMenu (m_menuType); // try to map the previous type to this one via menu item id int id = 1; if (m_lastTypeId != 0) { // does a corresponding type exist enabled in the new menu? if (m_menuType->indexOfItemId (m_lastTypeId) != -1 ) { id = m_lastTypeId; } } m_menuType->setSelectedId (id); } else if (ctrl == m_menuType) { m_lastTypeId = m_menuType->getSelectedId(); createFilter (); } else if (ctrl == m_menuStateType ) { createFilter (); } else if (ctrl == m_menuSmoothing) { createFilter (); } else if (ctrl == m_menuAudio) { setAudio (ctrl->getSelectedId()); } }
void Fdisk::test(QString databaseName) { try { //qDebug() << "test fdisk connection"; std::auto_ptr< ::FdExport > pFdExport(::staff::ServiceFactory::Inst().GetService< ::FdExport >()); STAFF_ASSERT(pFdExport.get(), "Cannot get client for service FdExport!"); std::string bewerbsID=databaseName.toStdString(); staff::Optional<std::string> user = staff::Optional<std::string>("BewerbsexportZeilhofer"); staff::Optional<std::string> password = staff::Optional<std::string>("Ubu6Son6"); staff::Optional<std::string> instanz = staff::Optional<std::string>("LFKDO Niederösterreich"); const staff::Optional< ::FdWsAuthorizeReturn >& AuthorizeResponse = pFdExport->Authorize(user, password, instanz); //qDebug() << "authorize: " << strConv(AuthorizeResponse->statusMessage); staff::Optional<std::string> md5session = AuthorizeResponse->md5session; // save the session key! staff::Optional< ::FdWsPrepareDataRequest > xmlRequest; xmlRequest->type = FdWsExportType_Wasserdienstleistungsbewerbe; FdWsWasserdienstleistungsbewerbeRequest wdlbReq; wdlbReq.filterGroup = createFilter(bewerbsID); xmlRequest->wasserdienstleistungsbewerbe = wdlbReq; //qDebug() << "Prepare Data on Server for BewerbsID = " << strConv(bewerbsID) << "..."; const staff::Optional< ::FdWsPrepareDataReturn >& PrepareDataResponse = pFdExport->PrepareData(md5session, xmlRequest); //qDebug() << "PrepareData result: " << strConv(PrepareDataResponse->statusMessage); pFdExport->closeSession(md5session); //qDebug() << "session closed"; if(PrepareDataResponse->statusCode==StatusCodes_OK) { MainWindow::app()->infoscreen()->appendInfo(tr("FDISK-Verbindung erfolgreich getestet")); } else { MainWindow::app()->infoscreen()->appendError(tr("FDISK-Verbindung konnte nicht hergestellt werden")); } } catch(...) { MainWindow::app()->infoscreen()->appendError(tr("FDISK-Verbindung konnte nicht hergestellt werden")); } }
Error_t Mono2Stereo::initInstance(float sampleRate, int numOfFrames) { m_fSampleRate = sampleRate; //set parameter ranges for (int i = 1; i < kNumOfFilter; i++) { m_aaafParamRange[i][kBandWidth][0] = 100.f; m_aaafParamRange[i][kBandWidth][1] = 800.f; m_aaafParamRange[i][kCenterFreq][0] = 100.f; m_aaafParamRange[i][kCenterFreq][1] = 20000.f; m_aaafParamRange[i][kFilterGain][0] = .01f; m_aaafParamRange[i][kFilterGain][1] = 2.f; } //create array of pointers: point to band pass filters createFilter(); //set initial parameters for each filter //Left channel 1 initialBandPassFilterParam("Left1"); m_pLeft1Filter->setParams(m_FilterParams); //Left channel 2 initialBandPassFilterParam("Left2"); m_pLeft2Filter->setParams(m_FilterParams); //Left channel 3 initialBandPassFilterParam("Left3"); m_pLeft3Filter->setParams(m_FilterParams); //Right channel 1 initialBandPassFilterParam("Right1"); m_pRight1Filter->setParams(m_FilterParams); //Right channel 2 initialBandPassFilterParam("Right2"); m_pRight2Filter->setParams(m_FilterParams); //Right channel 3 initialBandPassFilterParam("Right3"); m_pRight3Filter->setParams(m_FilterParams); //Common filter initialBandPassFilterParam("Common"); m_pBothChannelFilter->setParams(m_FilterParams); //allocate memory for temporary buffer based on number of frames per block m_pfTempBuffer = new float* [1]; m_pfTempBuffer[0] = new float [numOfFrames * 4]; m_bisInitialized = true; return kNoError; }
////////////////// PathFinder ////////////////// PathFinder::PathFinder(const Unit* owner) : m_polyLength(0), m_type(PATHFIND_BLANK), m_useStraightPath(false), m_forceDestination(false), m_pointPathLimit(MAX_POINT_PATH_LENGTH), m_sourceUnit(owner), m_navMesh(NULL), m_navMeshQuery(NULL) { sLog->outDebug(LOG_FILTER_PATHFINDING, "++ PathFinder::PathInfo for %u \n", m_sourceUnit->GetGUIDLow()); uint32 mapId = m_sourceUnit->GetMapId(); if(MMAP::MMapFactory::IsPathfindingEnabled(mapId)) { MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager(); m_navMesh = mmap->GetNavMesh(mapId); m_navMeshQuery = mmap->GetNavMeshQuery(mapId, m_sourceUnit->GetInstanceId()); } createFilter(); }
/* * Wrapper functions for filtering and for ksv f0 analysis * * all other analyses come with a 'computeXYZ' functions with identical * signatures but for various reasons these two do not. These function provide * wrappers. */ DOBJ * computeFilter(DOBJ * inpDOp, AOPTS * anaOpts, DOBJ * outDOp) { int FILE_IN, FILE_OUT, CREATED; DOBJ *filtDOp = NULL; if (inpDOp == NULL || anaOpts == NULL || outDOp != NULL) { setAsspMsg(AEB_BAD_ARGS, "computeFilter"); return (NULL); } FILE_IN = FILE_OUT = CREATED = FALSE; /* * check input object */ if (inpDOp->fp != NULL) { if (inpDOp->numRecords <= 0) { setAsspMsg(AEF_EMPTY, inpDOp->filePath); return (NULL); } FILE_IN = TRUE; } else if (anaOpts == NULL || (anaOpts != NULL && !(anaOpts->options & AOPT_INIT_ONLY))) { if (inpDOp->dataBuffer == NULL || inpDOp->bufNumRecs <= 0) { setAsspMsg(AED_NO_DATA, "(computeFilter)"); return (NULL); } } filtDOp = createFilter(inpDOp, anaOpts); if (filtDOp == NULL) { return (NULL); } if ((outDOp = filterSignal(inpDOp, filtDOp, outDOp)) == NULL) { return (NULL); } filtDOp = destroyFilter(filtDOp); return (outDOp); }
/************************************************* Function: prlRead2HashTable Description: 1. Imports the reads from the lib file one by one. 2. Chops the reads into kmers and store them in KmerSets. 3. Removes the kmers with low coverage. 4. Marks the linear kmers. 5. Counts the kmer frequences. Input: 1. libfile : the reads config file 2. outfile : the output file prefix Output: None. Return: 1 if exits normally. *************************************************/ boolean prlRead2HashTable ( char * libfile, char * outfile ) { char * cach1; char * cach2; unsigned char asm_ctg = 1; long long i; char * next_name, name[256]; FILE * fo; time_t start_t, stop_t; int maxReadNum; int libNo; pthread_t threads[thrd_num]; unsigned char thrdSignal[thrd_num + 1]; PARAMETER paras[thrd_num]; boolean flag, pairs = 0; WORDFILTER = createFilter ( overlaplen ); maxReadLen = 0; maxNameLen = 256; scan_libInfo ( libfile ); alloc_pe_mem ( num_libs ); if ( !maxReadLen ) { maxReadLen = 100; } if ( gLineLen < maxReadLen ) { gStr = ( char * ) ckalloc ( ( maxReadLen + 1 ) * sizeof ( char ) ); } //init maxReadLen4all = maxReadLen; fprintf ( stderr, "In %s, %d lib(s), maximum read length %d, maximum name length %d.\n\n", libfile, num_libs, maxReadLen, maxNameLen ); next_name = ( char * ) ckalloc ( ( maxNameLen + 1 ) * sizeof ( char ) ); kmerBuffer = ( Kmer * ) ckalloc ( buffer_size * sizeof ( Kmer ) ); hashBanBuffer = ( ubyte8 * ) ckalloc ( buffer_size * sizeof ( ubyte8 ) ); prevcBuffer = ( char * ) ckalloc ( buffer_size * sizeof ( char ) ); nextcBuffer = ( char * ) ckalloc ( buffer_size * sizeof ( char ) ); maxReadNum = buffer_size / ( maxReadLen - overlaplen + 1 ); //printf("buffer size %d, max read len %d, max read num %d\n",buffer_size,maxReadLen,maxReadNum); int maxAIOSize = 32768; aioBuffer1 = ( char * ) ckalloc ( ( maxAIOSize ) * sizeof ( char ) ); aioBuffer2 = ( char * ) ckalloc ( ( maxAIOSize ) * sizeof ( char ) ); readBuffer1 = ( char * ) ckalloc ( ( maxAIOSize + ( maxReadLen * 4 + 1024 ) ) * sizeof ( char ) ); //(char *)ckalloc(maxAIOSize*sizeof(char)); //1024 readBuffer2 = ( char * ) ckalloc ( ( maxAIOSize + ( maxReadLen * 4 + 1024 ) ) * sizeof ( char ) ); //1024 cach1 = ( char * ) ckalloc ( ( maxReadLen * 4 + 1024 ) * sizeof ( char ) ); //1024 cach2 = ( char * ) ckalloc ( ( maxReadLen * 4 + 1024 ) * sizeof ( char ) ); //1024 memset ( cach1, '\0', ( maxReadLen * 4 + 1024 ) ); //1024 memset ( cach2, '\0', ( maxReadLen * 4 + 1024 ) ); //1024 seqBuffer = ( char ** ) ckalloc ( maxReadNum * sizeof ( char * ) ); lenBuffer = ( int * ) ckalloc ( maxReadNum * sizeof ( int ) ); indexArray = ( int * ) ckalloc ( maxReadNum * sizeof ( int ) ); for ( i = 0; i < maxReadNum; i++ ) { seqBuffer[i] = ( char * ) ckalloc ( maxReadLen * sizeof ( char ) ); } rcSeq = ( char ** ) ckalloc ( ( thrd_num + 1 ) * sizeof ( char * ) ); if ( 1 ) { kmerCounter = ( long long * ) ckalloc ( ( thrd_num + 1 ) * sizeof ( long long ) ); KmerSets = ( KmerSet ** ) ckalloc ( thrd_num * sizeof ( KmerSet * ) ); ubyte8 init_size = 1024; ubyte8 k = 0; if ( initKmerSetSize ) { #ifdef MER127 init_size = ( ubyte8 ) ( ( double ) initKmerSetSize * 1024.0f * 1024.0f * 1024.0f / ( double ) thrd_num / 40 ); #else init_size = ( ubyte8 ) ( ( double ) initKmerSetSize * 1024.0f * 1024.0f * 1024.0f / ( double ) thrd_num / 24 ); //is it true? #endif do { ++k; } while ( k * 0xFFFFFFLLU < init_size ); } for ( i = 0; i < thrd_num; i++ ) { //KmerSets[i] = init_kmerset(1024,0.77f); KmerSets[i] = init_kmerset ( ( ( initKmerSetSize ) ? ( k * 0xFFFFFFLLU ) : ( init_size ) ), 0.77f ); thrdSignal[i + 1] = 0; paras[i].threadID = i; paras[i].mainSignal = &thrdSignal[0]; paras[i].selfSignal = &thrdSignal[i + 1]; kmerCounter[i + 1] = 0; rcSeq[i + 1] = ( char * ) ckalloc ( maxReadLen * sizeof ( char ) ); } creatThrds ( threads, paras ); } thrdSignal[0] = kmerCounter[0] = 0; time ( &start_t ); kmer_c = n_solexa = read_c = i = libNo = readNumBack = gradsCounter = 0; while ( openNextFile ( &libNo, pairs, asm_ctg ) ) { //read bam file if ( lib_array[libNo].curr_type == 4 ) { int type = 0; //deside the PE reads is good or bad while ( ( flag = read1seqInLibBam ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), &libNo, pairs, 1, &type ) ) != 0 ) { if ( type == -1 ) //if the reads is bad, go back. { i--; if ( lenBuffer[read_c - 1] >= overlaplen + 1 ) { kmer_c -= lenBuffer[read_c - 1] - overlaplen + 1; read_c--; } n_solexa -= 2; continue; } if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { continue; } /* if(lenBuffer[read_c]>70) lenBuffer[read_c] = 50; else if(lenBuffer[read_c]>40) lenBuffer[read_c] = 40; */ indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } } } //read PE fasta or fastq else if ( lib_array[libNo].curr_type == 1 || lib_array[libNo].curr_type == 2 ) { initAIO ( &aio1, aioBuffer1, fileno ( lib_array[libNo].fp1 ), maxAIOSize ); initAIO ( &aio2, aioBuffer2, fileno ( lib_array[libNo].fp2 ), maxAIOSize ); int offset1, offset2, flag1, flag2, rt1, rt2; offset1 = offset2 = 0; rt1 = aio_read ( &aio1 ); rt2 = aio_read ( &aio2 ); flag1 = AIORead ( &aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type ); flag2 = AIORead ( &aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type ); if ( flag1 && flag2 ) { int start1, start2, turn; start1 = start2 = 0; turn = 1; while ( start1 < offset1 || start2 < offset2 ) { if ( turn == 1 ) { turn = 2; readseqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), readBuffer1, &start1, offset1, libNo ); if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { if ( start1 >= offset1 ) { start1 = 0; offset1 = 0; flag1 = AIORead ( &aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type ); } continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( start1 >= offset1 ) { start1 = 0; offset1 = 0; flag1 = AIORead ( &aio1, &offset1, readBuffer1, cach1, &rt1, lib_array[libNo].curr_type ); } if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } continue; } if ( turn == 2 ) { turn = 1; readseqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), readBuffer2, &start2, offset2, libNo ); if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { if ( ( flag2 == 2 ) && ( start2 >= offset2 ) ) { break; } if ( start2 >= offset2 ) { start2 = 0; offset2 = 0; flag2 = AIORead ( &aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type ); } continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( ( flag2 == 2 ) && ( start2 >= offset2 ) ) { break; } if ( start2 >= offset2 ) { start2 = 0; offset2 = 0; flag2 = AIORead ( &aio2, &offset2, readBuffer2, cach2, &rt2, lib_array[libNo].curr_type ); } if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } continue; } } } else { fprintf(stderr, "Error: aio_read error.\n"); } } //read single fasta, single fastq and PE fasta in one file else { initAIO ( &aio1, aioBuffer1, fileno ( lib_array[libNo].fp1 ), maxAIOSize ); int offset, flag1, rt; offset = 0; rt = aio_read ( &aio1 ); while ( ( flag1 = AIORead ( &aio1, &offset, readBuffer1, cach1, &rt, lib_array[libNo].curr_type ) ) ) { int start = 0; while ( start < offset ) { readseqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), readBuffer1, &start, offset, libNo ); if ( ( ++i ) % 100000000 == 0 ) { fprintf ( stderr, "--- %lldth reads.\n", i ); } if ( lenBuffer[read_c] < 0 ) { fprintf ( stderr, "Read len %d.\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { continue; } indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; } if ( read_c > maxReadNum - 1024 ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer kmer_c = read_c = 0; } if ( flag1 == 2 ) { break; } } } } if ( read_c ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); //chopKmer4read sendWorkSignal ( 1, thrdSignal ); //singleKmer } time ( &stop_t ); fprintf ( stderr, "Time spent on hashing reads: %ds, %lld read(s) processed.\n", ( int ) ( stop_t - start_t ), i ); //record insert size info if ( pairs ) { if ( gradsCounter ) { fprintf ( stderr, "%d pe insert size, the largest boundary is %lld.\n\n", gradsCounter, pes[gradsCounter - 1].PE_bound ); } else { fprintf ( stderr, "No paired reads found.\n" ); } sprintf ( name, "%s.peGrads", outfile ); fo = ckopen ( name, "w" ); fprintf ( fo, "grads&num: %d\t%lld\n", gradsCounter, n_solexa ); for ( i = 0; i < gradsCounter; i++ ) { fprintf ( fo, "%d\t%lld\t%d\n", pes[i].insertS, pes[i].PE_bound, pes[i].rank ); } fclose ( fo ); } free_pe_mem (); free_libs (); if ( 1 ) { unsigned long long alloCounter = 0; unsigned long long allKmerCounter = 0; for ( i = 0; i < thrd_num; i++ ) { alloCounter += count_kmerset ( ( KmerSets[i] ) ); allKmerCounter += kmerCounter[i + 1]; free ( ( void * ) rcSeq[i + 1] ); } fprintf ( stderr, "%lli node(s) allocated, %lli kmer(s) in reads, %lli kmer(s) processed.\n", alloCounter, kmerCounter[0], allKmerCounter ); } free ( ( void * ) rcSeq ); free ( ( void * ) kmerCounter ); for ( i = 0; i < maxReadNum; i++ ) { free ( ( void * ) seqBuffer[i] ); } free ( ( void * ) seqBuffer ); free ( ( void * ) lenBuffer ); free ( ( void * ) indexArray ); free ( ( void * ) kmerBuffer ); free ( ( void * ) hashBanBuffer ); free ( ( void * ) nextcBuffer ); free ( ( void * ) prevcBuffer ); free ( ( void * ) next_name ); free ( ( void * ) aioBuffer1 ); free ( ( void * ) aioBuffer2 ); free ( ( void * ) readBuffer1 ); free ( ( void * ) readBuffer2 ); free ( ( void * ) cach1 ); free ( ( void * ) cach2 ); fprintf ( stderr, "done hashing nodes\n" ); if ( deLowKmer ) { time ( &start_t ); deLowCov ( thrdSignal ); time ( &stop_t ); fprintf ( stderr, "Time spent on delowcvgNode: %ds.\n", ( int ) ( stop_t - start_t ) ); } time ( &start_t ); Mark1in1outNode ( thrdSignal ); freqStat ( outfile ); time ( &stop_t ); fprintf ( stderr, "Time spent on marking linear nodes: %ds.\n", ( int ) ( stop_t - start_t ) ); sendWorkSignal ( 3, thrdSignal ); //exit thread_wait ( threads ); return 1; }
void PathInfo::BuildPolyPath(PathNode startPos, PathNode endPos) { // *** getting start/end poly logic *** float distToStartPoly, distToEndPoly; float startPoint[VERTEX_SIZE] = {startPos.y, startPos.z, startPos.x}; float endPoint[VERTEX_SIZE] = {endPos.y, endPos.z, endPos.x}; dtPolyRef startPoly = getPolyByLocation(startPoint, &distToStartPoly); dtPolyRef endPoly = getPolyByLocation(endPoint, &distToEndPoly); // we have a hole in our mesh // make shortcut path and mark it as NOPATH ( with flying exception ) // its up to caller how he will use this info if (startPoly == INVALID_POLYREF || endPoly == INVALID_POLYREF) { PATH_DEBUG("++ BuildPolyPath :: (startPoly == 0 || endPoly == 0)\n"); BuildShortcut(); m_type = (m_sourceUnit->GetTypeId() == TYPEID_UNIT && ((Creature*)m_sourceUnit)->canFly()) ? PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH) : PATHFIND_NOPATH; return; } // we may need a better number here bool farFromPoly = (distToStartPoly > 7.0f || distToEndPoly > 7.0f); if (farFromPoly) { PATH_DEBUG("++ BuildPolyPath :: farFromPoly distToStartPoly=%.3f distToEndPoly=%.3f\n", distToStartPoly, distToEndPoly); bool buildShotrcut = false; if (m_sourceUnit->GetTypeId() == TYPEID_UNIT) { Creature* owner = (Creature*)m_sourceUnit; PathNode p = (distToStartPoly > 7.0f) ? startPos : endPos; if (m_sourceUnit->GetMap()->IsUnderWater(p.x, p.y, p.z)) { PATH_DEBUG("++ BuildPolyPath :: underWater case\n"); if (owner->canSwim() || owner->isPet()) buildShotrcut = true; } else { PATH_DEBUG("++ BuildPolyPath :: flying case\n"); if (owner->canFly()) buildShotrcut = true; } } if (buildShotrcut) { BuildShortcut(); m_type = PathType(PATHFIND_NORMAL | PATHFIND_NOT_USING_PATH); return; } else { float closestPoint[VERTEX_SIZE]; // we may want to use closestPointOnPolyBoundary instead if (DT_SUCCESS == m_navMeshQuery->closestPointOnPoly(endPoly, endPoint, closestPoint)) { dtVcopy(endPoint, closestPoint); setActualEndPosition(PathNode(endPoint[2],endPoint[0],endPoint[1])); } m_type = PATHFIND_INCOMPLETE; } } // *** poly path generating logic *** // start and end are on same polygon // just need to move in straight line if (startPoly == endPoly) { PATH_DEBUG("++ BuildPolyPath :: (startPoly == endPoly)\n"); BuildShortcut(); m_pathPolyRefs = new dtPolyRef[1]; m_pathPolyRefs[0] = startPoly; m_polyLength = 1; m_type = farFromPoly ? PATHFIND_INCOMPLETE : PATHFIND_NORMAL; PATH_DEBUG("++ BuildPolyPath :: path type %d\n", m_type); return; } // look for startPoly/endPoly in current path // TODO: we can merge it with getPathPolyByPosition() loop bool startPolyFound = false; bool endPolyFound = false; uint32 pathStartIndex, pathEndIndex; if (m_polyLength) { for (pathStartIndex = 0; pathStartIndex < m_polyLength; ++pathStartIndex) if (m_pathPolyRefs[pathStartIndex] == startPoly) { startPolyFound = true; break; } for (pathEndIndex = m_polyLength-1; pathEndIndex > pathStartIndex; --pathEndIndex) if (m_pathPolyRefs[pathEndIndex] == endPoly) { endPolyFound = true; break; } } if (startPolyFound && endPolyFound) { PATH_DEBUG("++ BuildPolyPath :: (startPolyFound && endPolyFound)\n"); // we moved along the path and the target did not move out of our old poly-path // our path is a simple subpath case, we have all the data we need // just "cut" it out m_polyLength = pathEndIndex - pathStartIndex + 1; dtPolyRef* newPolyRefs = new dtPolyRef[m_polyLength]; memcpy(newPolyRefs, m_pathPolyRefs+pathStartIndex, m_polyLength*sizeof(dtPolyRef)); delete [] m_pathPolyRefs; m_pathPolyRefs = newPolyRefs; } else if (startPolyFound && !endPolyFound) { PATH_DEBUG("++ BuildPolyPath :: (startPolyFound && !endPolyFound)\n"); // we are moving on the old path but target moved out // so we have atleast part of poly-path ready m_polyLength -= pathStartIndex; // try to adjust the suffix of the path instead of recalculating entire length // at given interval the target cannot get too far from its last location // thus we have less poly to cover // sub-path of optimal path is optimal // take ~80% of the original length // TODO : play with the values here uint32 prefixPolyLength = uint32(m_polyLength*0.8f + 0.5f); dtPolyRef prefixPathPolys[MAX_PATH_LENGTH]; memcpy(prefixPathPolys, m_pathPolyRefs+pathStartIndex, prefixPolyLength*sizeof(dtPolyRef)); dtPolyRef suffixStartPoly = prefixPathPolys[prefixPolyLength-1]; // we need any point on our suffix start poly to generate poly-path, so we need last poly in prefix data float suffixEndPoint[VERTEX_SIZE]; if (DT_SUCCESS != m_navMeshQuery->closestPointOnPoly(suffixStartPoly, endPoint, suffixEndPoint)) { // suffixStartPoly is invalid somehow, or the navmesh is broken => error state sLog.outError("%u's Path Build failed: invalid polyRef in path", m_sourceUnit->GetGUID()); BuildShortcut(); m_type = PATHFIND_NOPATH; return; } // generate suffix dtQueryFilter filter = createFilter(); dtPolyRef suffixPathPolys[MAX_PATH_LENGTH]; uint32 suffixPolyLength = 0; dtStatus dtResult = m_navMeshQuery->findPath( suffixStartPoly, // start polygon endPoly, // end polygon suffixEndPoint, // start position endPoint, // end position &filter, // polygon search filter suffixPathPolys, // [out] path (int*)&suffixPolyLength, MAX_PATH_LENGTH-prefixPolyLength); // max number of polygons in output path if (!suffixPolyLength || dtResult != DT_SUCCESS) { // this is probably an error state, but we'll leave it // and hopefully recover on the next Update // we still need to copy our preffix sLog.outError("%u's Path Build failed: 0 length path", m_sourceUnit->GetGUID()); } PATH_DEBUG("++ m_polyLength=%u prefixPolyLength=%u suffixPolyLength=%u \n",m_polyLength, prefixPolyLength, suffixPolyLength); // new path = prefix + suffix - overlap m_polyLength = prefixPolyLength + suffixPolyLength - 1; delete [] m_pathPolyRefs; m_pathPolyRefs = new dtPolyRef[m_polyLength]; // copy the part of the old path we keep - prefix memcpy(m_pathPolyRefs, prefixPathPolys, prefixPolyLength*sizeof(dtPolyRef)); // copy the newly created suffix - skip first poly, we have it at prefix end if (suffixPathPolys) memcpy(m_pathPolyRefs+prefixPolyLength, suffixPathPolys+1, (suffixPolyLength-1)*sizeof(dtPolyRef)); } else { PATH_DEBUG("++ BuildPolyPath :: (!startPolyFound && !endPolyFound)\n"); // either we have no path at all -> first run // or something went really wrong -> we aren't moving along the path to the target // just generate new path // free and invalidate old path data clear(); dtQueryFilter filter = createFilter(); // use special filter so we use proper terrain types dtPolyRef pathPolys[MAX_PATH_LENGTH]; m_polyLength = 0; dtStatus dtResult = m_navMeshQuery->findPath( startPoly, // start polygon endPoly, // end polygon startPoint, // start position endPoint, // end position &filter, // polygon search filter pathPolys, // [out] path (int*)&m_polyLength, MAX_PATH_LENGTH); // max number of polygons in output path if (!m_polyLength || dtResult != DT_SUCCESS) { // only happens if we passed bad data to findPath(), or navmesh is messed up sLog.outError("%u's Path Build failed: 0 length path", m_sourceUnit->GetGUID()); BuildShortcut(); m_type = PATHFIND_NOPATH; return; } m_pathPolyRefs = new dtPolyRef[m_polyLength]; memcpy(m_pathPolyRefs, pathPolys, m_polyLength*sizeof(dtPolyRef)); } // by now we know what type of path we can get if (m_pathPolyRefs[m_polyLength - 1] == endPoly && !(m_type & PATHFIND_INCOMPLETE)) m_type = PATHFIND_NORMAL; else m_type = PATHFIND_INCOMPLETE; // generate the point-path out of our up-to-date poly-path BuildPointPath(startPoint, endPoint); }
HSVFilter::HSVFilter( int iLowH, int iHighH, int iLowS, int iHighS, int iLowV, int iHighV) { createFilter(iLowH, iHighH, iLowS, iHighS, iLowV, iHighV); }
void FilterBank::createFilterBank() { int support = 49; filters.push_back(createFilter(support, 2, 1)); filters.push_back(createFilter(support, 4, 1)); filters.push_back(createFilter(support, 4, 2)); filters.push_back(createFilter(support, 6, 1)); filters.push_back(createFilter(support, 6, 2)); filters.push_back(createFilter(support, 6, 3)); filters.push_back(createFilter(support, 8, 1)); filters.push_back(createFilter(support, 8, 2)); filters.push_back(createFilter(support, 8, 3)); filters.push_back(createFilter(support, 10, 1)); filters.push_back(createFilter(support, 10, 2)); filters.push_back(createFilter(support, 10, 3)); filters.push_back(createFilter(support, 10, 4)); }
boolean prlContig2nodes (char *grapfile, int len_cut) { long long i, num_seq; char name[256], *next_name; FILE *fp; pthread_t threads[thrd_num]; time_t start_t, stop_t; unsigned char thrdSignal[thrd_num + 1]; PARAMETER paras[thrd_num]; int maxCtgLen, minCtgLen, nameLen; unsigned int lenSum, contigId; WORDFILTER = createFilter (overlaplen); time (&start_t); sprintf (name, "%s.contig", grapfile); fp = ckopen (name, "r"); maxCtgLen = nameLen = 10; minCtgLen = 1000; num_seq = readseqpar (&maxCtgLen, &minCtgLen, &nameLen, fp); printf ("\nthere're %lld contigs in file: %s, max seq len %d, min seq len %d, max name len %d\n", num_seq, grapfile, maxCtgLen, minCtgLen, nameLen); maxReadLen = maxCtgLen; fclose (fp); time (&stop_t); printf ("time spent on parse contigs file %ds\n", (int) (stop_t - start_t)); next_name = (char *) ckalloc ((maxNameLen + 1) * sizeof (char)); // extract all the EDONs seq_buffer_size = buffer_size * 2; max_read_c = seq_buffer_size / 20; kmerBuffer = (Kmer *) ckalloc (buffer_size * sizeof (Kmer)); hashBanBuffer = (ubyte8 *) ckalloc (buffer_size * sizeof (ubyte8)); smallerBuffer = (boolean *) ckalloc (buffer_size * sizeof (boolean)); seqBuffer = (char *) ckalloc (seq_buffer_size * sizeof (char)); lenBuffer = (int *) ckalloc (max_read_c * sizeof (int)); indexArray = (unsigned int *) ckalloc ((max_read_c + 1) * sizeof (unsigned int)); seqBreakers = (unsigned int *) ckalloc ((max_read_c + 1) * sizeof (unsigned int)); ctgIdArray = (int *) ckalloc (max_read_c * sizeof (int)); fp = ckopen (name, "r"); //node_mem_manager = createMem_manager(EDONBLOCKSIZE,sizeof(EDON)); rcSeq = (char **) ckalloc ((thrd_num + 1) * sizeof (char *)); if (1) { kmerCounter = (long long *) ckalloc ((thrd_num + 1) * sizeof (long long)); KmerSets = (KmerSet **) ckalloc (thrd_num * sizeof (KmerSet *)); for (i = 0; i < thrd_num; i++) { KmerSets[i] = init_kmerset (1024, 0.77f); thrdSignal[i + 1] = 0; paras[i].threadID = i; paras[i].mainSignal = &thrdSignal[0]; paras[i].selfSignal = &thrdSignal[i + 1]; kmerCounter[i + 1] = 0; rcSeq[i + 1] = (char *) ckalloc (maxCtgLen * sizeof (char)); } creatThrds (threads, paras); } kmer_c = thrdSignal[0] = kmerCounter[0] = 0; time (&start_t); read_c = lenSum = i = seqBreakers[0] = indexArray[0] = 0; readseq1by1 (seqBuffer + seqBreakers[read_c], next_name, &(lenBuffer[read_c]), fp, -1); while (!feof (fp)) { contigId = getID (next_name); readseq1by1 (seqBuffer + seqBreakers[read_c], next_name, &(lenBuffer[read_c]), fp, 1); if ((++i) % 10000000 == 0) { printf ("--- %lldth contigs\n", i); } if (lenBuffer[read_c] < overlaplen + 1 || lenBuffer[read_c] < len_cut) { contigId = getID (next_name); continue; } //printf("len of seq %d is %d, ID %d\n",read_c,lenBuffer[read_c],contigId); ctgIdArray[read_c] = contigId > 0 ? contigId : i; lenSum += lenBuffer[read_c]; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; seqBreakers[read_c] = lenSum; indexArray[read_c] = kmer_c; //printf("seq %d start at %d\n",read_c,seqBreakers[read_c]); if (read_c == max_read_c || (lenSum + maxCtgLen) > seq_buffer_size || (kmer_c + maxCtgLen - overlaplen + 1) > buffer_size) { kmerCounter[0] += kmer_c; sendWorkSignal (2, thrdSignal); sendWorkSignal (1, thrdSignal); kmer_c = read_c = lenSum = 0; } } if (read_c) { kmerCounter[0] += kmer_c; sendWorkSignal (2, thrdSignal); sendWorkSignal (1, thrdSignal); } sendWorkSignal (3, thrdSignal); thread_wait (threads); time (&stop_t); printf ("time spent on hash reads: %ds\n", (int) (stop_t - start_t)); if (1) { unsigned long long alloCounter = 0; unsigned long long allKmerCounter = 0; for (i = 0; i < thrd_num; i++) { alloCounter += count_kmerset ((KmerSets[i])); allKmerCounter += kmerCounter[i + 1]; free ((void *) rcSeq[i + 1]); } printf ("%lli nodes allocated, %lli kmer in reads, %lli kmer processed\n", alloCounter, kmerCounter[0], allKmerCounter); } free ((void *) rcSeq); free ((void *) kmerCounter); free ((void *) seqBuffer); free ((void *) lenBuffer); free ((void *) indexArray); free ((void *) seqBreakers); free ((void *) ctgIdArray); free ((void *) kmerBuffer); free ((void *) hashBanBuffer); free ((void *) smallerBuffer); free ((void *) next_name); fclose (fp); return 1; }
// Two different constructors HSVFilter::HSVFilter() { int sensitivity = 30; createFilter(60 - sensitivity, 60 + sensitivity, 100, 255, 100, 255); }
dtStatus PathInfo::findSmoothPath(const float* startPos, const float* endPos, const dtPolyRef* polyPath, const uint32 polyPathSize, float* smoothPath, int* straightPathCount, const uint32 maxSmoothPathSize) { ASSERT(polyPathSize <= MAX_PATH_LENGTH); *straightPathCount = 0; uint32 nsmoothPath = 0; dtPolyRef polys[MAX_PATH_LENGTH]; memcpy(polys, polyPath, sizeof(dtPolyRef)*polyPathSize); uint32 npolys = polyPathSize; float iterPos[VERTEX_SIZE], targetPos[VERTEX_SIZE]; if(DT_SUCCESS != m_navMeshQuery->closestPointOnPolyBoundary(polys[0], startPos, iterPos)) return DT_FAILURE; if(DT_SUCCESS != m_navMeshQuery->closestPointOnPolyBoundary(polys[npolys-1], endPos, targetPos)) return DT_FAILURE; dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos); nsmoothPath++; // Move towards target a small advancement at a time until target reached or // when ran out of memory to store the path. while (npolys && nsmoothPath < maxSmoothPathSize) { // Find location to steer towards. float steerPos[VERTEX_SIZE]; unsigned char steerPosFlag; dtPolyRef steerPosRef = INVALID_POLYREF; if (!getSteerTarget(iterPos, targetPos, SMOOTH_PATH_SLOP, polys, npolys, steerPos, steerPosFlag, steerPosRef)) break; bool endOfPath = (steerPosFlag & DT_STRAIGHTPATH_END); bool offMeshConnection = (steerPosFlag & DT_STRAIGHTPATH_OFFMESH_CONNECTION); // Find movement delta. float delta[VERTEX_SIZE]; dtVsub(delta, steerPos, iterPos); float len = dtSqrt(dtVdot(delta,delta)); // If the steer target is end of path or off-mesh link, do not move past the location. if ((endOfPath || offMeshConnection) && len < SMOOTH_PATH_STEP_SIZE) len = 1.0f; else len = SMOOTH_PATH_STEP_SIZE / len; float moveTgt[VERTEX_SIZE]; dtVmad(moveTgt, iterPos, delta, len); // Move float result[VERTEX_SIZE]; const static uint32 MAX_VISIT_POLY = 16; dtPolyRef visited[MAX_VISIT_POLY]; dtQueryFilter filter = createFilter(); uint32 nvisited = 0; m_navMeshQuery->moveAlongSurface(polys[0], iterPos, moveTgt, &filter, result, visited, (int*)&nvisited, MAX_VISIT_POLY); npolys = fixupCorridor(polys, npolys, MAX_PATH_LENGTH, visited, nvisited); m_navMeshQuery->getPolyHeight(polys[0], result, &result[1]); dtVcopy(iterPos, result); // Handle end of path and off-mesh links when close enough. if (endOfPath && inRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 2.0f)) { // Reached end of path. dtVcopy(iterPos, targetPos); if (nsmoothPath < maxSmoothPathSize) { dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos); nsmoothPath++; } break; } else if (offMeshConnection && inRangeYZX(iterPos, steerPos, SMOOTH_PATH_SLOP, 2.0f)) { // Reached off-mesh connection. float startPos[VERTEX_SIZE], endPos[VERTEX_SIZE]; // Advance the path up to and over the off-mesh connection. dtPolyRef prevRef = INVALID_POLYREF; dtPolyRef polyRef = polys[0]; uint32 npos = 0; while (npos < npolys && polyRef != steerPosRef) { prevRef = polyRef; polyRef = polys[npos]; npos++; } for (uint32 i = npos; i < npolys; ++i) polys[i-npos] = polys[i]; npolys -= npos; // Handle the connection. if (DT_SUCCESS == m_navMesh->getOffMeshConnectionPolyEndPoints(prevRef, polyRef, startPos, endPos)) { if (nsmoothPath < maxSmoothPathSize) { dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], startPos); nsmoothPath++; // Hack to make the dotted path not visible during off-mesh connection. if (nsmoothPath & 1) { dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], startPos); nsmoothPath++; } } // Move position at the other side of the off-mesh link. dtVcopy(iterPos, endPos); m_navMeshQuery->getPolyHeight(polys[0], iterPos, &iterPos[1]); } } // Store results. if (nsmoothPath < maxSmoothPathSize) { dtVcopy(&smoothPath[nsmoothPath*VERTEX_SIZE], iterPos); nsmoothPath++; } } *straightPathCount = nsmoothPath; return DT_SUCCESS; }
int FilterSeqsCommand::execute() { try { if (abort == true) { if (calledHelp) { return 0; } return 2; } ifstream inFASTA; m->openInputFile(fastafileNames[0], inFASTA); Sequence testSeq(inFASTA); alignmentLength = testSeq.getAlignLength(); inFASTA.close(); ////////////create filter///////////////// m->mothurOut("Creating Filter... "); m->mothurOutEndLine(); filter = createFilter(); m->mothurOutEndLine(); m->mothurOutEndLine(); if (m->control_pressed) { outputTypes.clear(); return 0; } ofstream outFilter; //prevent giantic file name map<string, string> variables; variables["[filename]"] = outputDir + filterFileName + "."; if (fastafileNames.size() > 3) { variables["[filename]"] = outputDir + "merge."; } string filterFile = getOutputFileName("filter", variables); m->openOutputFile(filterFile, outFilter); outFilter << filter << endl; outFilter.close(); outputNames.push_back(filterFile); outputTypes["filter"].push_back(filterFile); ////////////run filter///////////////// m->mothurOut("Running Filter... "); m->mothurOutEndLine(); filterSequences(); m->mothurOutEndLine(); m->mothurOutEndLine(); int filteredLength = 0; for(int i=0;i<alignmentLength;i++){ if(filter[i] == '1'){ filteredLength++; } } if (m->control_pressed) { outputTypes.clear(); for(int i = 0; i < outputNames.size(); i++) { m->mothurRemove(outputNames[i]); } return 0; } m->mothurOutEndLine(); m->mothurOut("Length of filtered alignment: " + toString(filteredLength)); m->mothurOutEndLine(); m->mothurOut("Number of columns removed: " + toString((alignmentLength-filteredLength))); m->mothurOutEndLine(); m->mothurOut("Length of the original alignment: " + toString(alignmentLength)); m->mothurOutEndLine(); m->mothurOut("Number of sequences used to construct filter: " + toString(numSeqs)); m->mothurOutEndLine(); //set fasta file as new current fastafile string current = ""; itTypes = outputTypes.find("fasta"); if (itTypes != outputTypes.end()) { if ((itTypes->second).size() != 0) { current = (itTypes->second)[0]; m->setFastaFile(current); } } m->mothurOutEndLine(); m->mothurOut("Output File Names: "); m->mothurOutEndLine(); for(int i = 0; i < outputNames.size(); i++) { m->mothurOut(outputNames[i]); m->mothurOutEndLine(); } m->mothurOutEndLine(); return 0; } catch(exception& e) { m->errorOut(e, "FilterSeqsCommand", "execute"); exit(1); } }
void Fdisk::run() { try { Competition* comp=MainWindow::competition(); if(comp->getDatabaseName().isEmpty()) { return; } MainWindow::app()->infoscreen()->appendInfo("FDISK-Daten werden gelesen..."); std::auto_ptr< ::FdExport > pFdExport(::staff::ServiceFactory::Inst().GetService< ::FdExport >()); STAFF_ASSERT(pFdExport.get(), "Cannot get client for service FdExport!"); //std::string bewerbsID("912"); // ID aus orignal Beispiel von ACP //std::string bewerbsID("1641"); // Testbewerb, den Zani angelegt hat. //std::string bewerbsID("1503"); // BewerbsID des Amstettner Bewerbs in Zell 2013 //std::string bewerbsID("1574"); // BewerbsID WLA-Gold, Marchegg (funktioniert nicht) //std::string bewerbsID("1609"); // BewerbsID des Kremser Bewerbs in Hollenburg 2013 std::string bewerbsID=comp->getDatabaseName().toStdString(); staff::Optional<std::string> user = staff::Optional<std::string>("BewerbsexportZeilhofer"); staff::Optional<std::string> password = staff::Optional<std::string>("Ubu6Son6"); staff::Optional<std::string> instanz = staff::Optional<std::string>("LFKDO Niederösterreich"); const staff::Optional< ::FdWsAuthorizeReturn >& AuthorizeResponse = pFdExport->Authorize(user, password, instanz); //qDebug() << "authorize: " << strConv(AuthorizeResponse->statusMessage); staff::Optional<std::string> md5session = AuthorizeResponse->md5session; // save the session key! staff::Optional< ::FdWsPrepareDataRequest > xmlRequest; xmlRequest->type = FdWsExportType_Wasserdienstleistungsbewerbe; FdWsWasserdienstleistungsbewerbeRequest wdlbReq; wdlbReq.filterGroup = createFilter(bewerbsID); xmlRequest->wasserdienstleistungsbewerbe = wdlbReq; //qDebug() << "Prepare Data on Server for BewerbsID = " << strConv(bewerbsID) << "..."; const staff::Optional< ::FdWsPrepareDataReturn >& PrepareDataResponse = pFdExport->PrepareData(md5session, xmlRequest); //qDebug() << "PrepareData result: " << strConv(PrepareDataResponse->statusMessage); //qDebug() << "fetching data"; std::list< staff::Nillable< ::FdWsWasserdienstleistungsbewerbeStruct > > list; while(true) { const staff::Optional< ::FdWsGetNextDataBlockReturn >& getNextDataBlockResponse = pFdExport->getNextDataBlock(md5session); //staff::LogInfo() << "getNextDataBlock result: " << getNextDataBlockResponse->statusMessage; std::list< staff::Nillable< ::FdWsWasserdienstleistungsbewerbeStruct > > blockList = getNextDataBlockResponse->wasserdienstleistungsbewerbe->FdWsWasserdienstleistungsbewerbeStruct; // append blockList to list list.insert(list.end(), blockList.begin(), blockList.end()); //std::cout << "blockList.size() = " << blockList.size() << "\n"; if(getNextDataBlockResponse->statusCode != StatusCodes_OK) { break; } //qDebug() << "."; } //qDebug() << "done\n"; while(list.size()) { staff::Nillable< ::FdWsWasserdienstleistungsbewerbeStruct > itemHelper = list.front(); list.pop_front(); FdWsWasserdienstleistungsbewerbeStruct item = itemHelper.Get(); int round=strConv(item.Durchgang.Get()).toInt(); int boatID=strConv(item.Zillennummer.Get()).toInt(); int ID=(round-1)*comp->getBoatsPerRound()+boatID; if(ID>comp->getNumOfRuns()) { break; } else { RunData* run=comp->getRun(ID); run->startEditing(); run->setColor(strConv(item.Farbe.Get())); run->setFireBrigade(strConv(item.Instanzname.Get())); run->setValuationClass(strConv(item.Wertungsklasse.Get())); run->setAgePoints(strConv(item.AlterspunkteWert.Get())); QStringList name1=strConv(item.Name1.Get()).split(" ", QString::SkipEmptyParts); QStringList name2=strConv(item.Name2.Get()).split(" ", QString::SkipEmptyParts); //qDebug()<<round<<" "<<boatID<<" "<<name1<<" "<<name2<<"\n"; if(!name1.isEmpty()) { // the last substring is the lastname run->setLastName1(name1.takeLast()); if(!name1.isEmpty()) { // the substring next to last is the firstname run->setFirstName1(name1.takeLast()); if(!name1.isEmpty()) { // the rest of the string (at the front) is the title run->setTitle1(name1.join(" ")); } } } if(!name2.isEmpty()) { // the last substring is the lastname run->setLastName2(name2.takeLast()); if(!name2.isEmpty()) { // the substring next to last is the firstname run->setFirstName2(name2.takeLast()); if(!name2.isEmpty()) { // the rest of the string (at the front) is the title run->setTitle2(name2.join(" ")); } } } run->editingFinished(); } } MainWindow::app()->infoscreen()->appendInfo(tr("FDISK-Daten wurden erfolgreich gelesen")); pFdExport->closeSession(md5session); //qDebug() << "session closed"; } catch(...) { MainWindow::app()->infoscreen()->appendError(tr("FDISK-Daten konnten nicht gelesen werden")); } //STAFF_CATCH_ALL }
boolean prlRead2HashTable ( char * libfile, char * outfile ) { long long i; char * next_name, name[256]; FILE * fo; time_t start_t, stop_t; int maxReadNum; int libNo; pthread_t threads[thrd_num]; unsigned char thrdSignal[thrd_num + 1]; PARAMETER paras[thrd_num]; boolean flag, pairs = 0; WORDFILTER = createFilter ( overlaplen ); maxReadLen = 0; maxNameLen = 256; scan_libInfo ( libfile ); alloc_pe_mem ( num_libs ); if ( !maxReadLen ) { maxReadLen = 100; } maxReadLen4all = maxReadLen; printf ( "In %s, %d libs, max seq len %d, max name len %d\n\n", libfile, num_libs, maxReadLen, maxNameLen ); next_name = ( char * ) ckalloc ( ( maxNameLen + 1 ) * sizeof ( char ) ); kmerBuffer = ( Kmer * ) ckalloc ( buffer_size * sizeof ( Kmer ) ); hashBanBuffer = ( ubyte8 * ) ckalloc ( buffer_size * sizeof ( ubyte8 ) ); prevcBuffer = ( char * ) ckalloc ( buffer_size * sizeof ( char ) ); nextcBuffer = ( char * ) ckalloc ( buffer_size * sizeof ( char ) ); maxReadNum = buffer_size / ( maxReadLen - overlaplen + 1 ); //printf("buffer size %d, max read len %d, max read num %d\n",buffer_size,maxReadLen,maxReadNum); seqBuffer = ( char ** ) ckalloc ( maxReadNum * sizeof ( char * ) ); lenBuffer = ( int * ) ckalloc ( maxReadNum * sizeof ( int ) ); indexArray = ( int * ) ckalloc ( maxReadNum * sizeof ( int ) ); for ( i = 0; i < maxReadNum; i++ ) { seqBuffer[i] = ( char * ) ckalloc ( maxReadLen * sizeof ( char ) ); } rcSeq = ( char ** ) ckalloc ( ( thrd_num + 1 ) * sizeof ( char * ) ); if ( 1 ) { kmerCounter = ( long long * ) ckalloc ( ( thrd_num + 1 ) * sizeof ( long long ) ); KmerSets = ( KmerSet ** ) ckalloc ( thrd_num * sizeof ( KmerSet * ) ); ubyte8 init_size = 1024; ubyte8 k = 0; if ( initKmerSetSize ) { init_size = ( ubyte8 ) ( ( double ) initKmerSetSize * 1024.0f * 1024.0f * 1024.0f / ( double ) thrd_num / 32 ); do { ++k; } while ( k * 0xFFFFFFLLU < init_size ); } for ( i = 0; i < thrd_num; i++ ) { //KmerSets[i] = init_kmerset(1024,0.77f); KmerSets[i] = init_kmerset ( k * 0xFFFFFFLLU, 0.77f ); thrdSignal[i + 1] = 0; paras[i].threadID = i; paras[i].mainSignal = &thrdSignal[0]; paras[i].selfSignal = &thrdSignal[i + 1]; kmerCounter[i + 1] = 0; rcSeq[i + 1] = ( char * ) ckalloc ( maxReadLen * sizeof ( char ) ); } creatThrds ( threads, paras ); } thrdSignal[0] = kmerCounter[0] = 0; time ( &start_t ); kmer_c = n_solexa = read_c = i = libNo = readNumBack = gradsCounter = 0; while ( ( flag = read1seqInLib ( seqBuffer[read_c], next_name, & ( lenBuffer[read_c] ), &libNo, pairs, 1 ) ) != 0 ) { if ( ( ++i ) % 100000000 == 0 ) { printf ( "--- %lldth reads\n", i ); } if ( lenBuffer[read_c] < 0 ) { printf ( "read len %d\n", lenBuffer[read_c] ); } if ( lenBuffer[read_c] < overlaplen + 1 ) { continue; } /* if(lenBuffer[read_c]>70) lenBuffer[read_c] = 50; else if(lenBuffer[read_c]>40) lenBuffer[read_c] = 40; */ indexArray[read_c] = kmer_c; kmer_c += lenBuffer[read_c] - overlaplen + 1; read_c++; if ( read_c == maxReadNum ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); sendWorkSignal ( 1, thrdSignal ); kmer_c = read_c = 0; } } if ( read_c ) { kmerCounter[0] += kmer_c; sendWorkSignal ( 2, thrdSignal ); sendWorkSignal ( 1, thrdSignal ); } time ( &stop_t ); printf ( "time spent on hash reads: %ds, %lld reads processed\n", ( int ) ( stop_t - start_t ), i ); //record insert size info if ( pairs ) { if ( gradsCounter ) printf ( "%d pe insert size, the largest boundary is %lld\n\n", gradsCounter, pes[gradsCounter - 1].PE_bound ); else { printf ( "no paired reads found\n" ); } sprintf ( name, "%s.peGrads", outfile ); fo = ckopen ( name, "w" ); fprintf ( fo, "grads&num: %d\t%lld\n", gradsCounter, n_solexa ); for ( i = 0; i < gradsCounter; i++ ) { fprintf ( fo, "%d\t%lld\t%d\n", pes[i].insertS, pes[i].PE_bound, pes[i].rank ); } fclose ( fo ); } free_pe_mem(); free_libs(); if ( 1 ) { unsigned long long alloCounter = 0; unsigned long long allKmerCounter = 0; for ( i = 0; i < thrd_num; i++ ) { alloCounter += count_kmerset ( ( KmerSets[i] ) ); allKmerCounter += kmerCounter[i + 1]; free ( ( void * ) rcSeq[i + 1] ); } printf ( "%lli nodes allocated, %lli kmer in reads, %lli kmer processed\n" , alloCounter, kmerCounter[0], allKmerCounter ); } free ( ( void * ) rcSeq ); free ( ( void * ) kmerCounter ); for ( i = 0; i < maxReadNum; i++ ) { free ( ( void * ) seqBuffer[i] ); } free ( ( void * ) seqBuffer ); free ( ( void * ) lenBuffer ); free ( ( void * ) indexArray ); free ( ( void * ) kmerBuffer ); free ( ( void * ) hashBanBuffer ); free ( ( void * ) nextcBuffer ); free ( ( void * ) prevcBuffer ); free ( ( void * ) next_name ); //printf("done hashing nodes\n"); if ( deLowKmer ) { time ( &start_t ); deLowCov ( thrdSignal ); time ( &stop_t ); printf ( "time spent on delowcvgNode %ds\n", ( int ) ( stop_t - start_t ) ); } time ( &start_t ); Mark1in1outNode ( thrdSignal ); freqStat ( outfile ); time ( &stop_t ); printf ( "time spent on marking linear nodes %ds\n", ( int ) ( stop_t - start_t ) ); fflush ( stdout ); sendWorkSignal ( 3, thrdSignal ); thread_wait ( threads ); /* Kmer word = 0x21c3ca82c734c8d0; Kmer hash_ban = hash_kmer(word); int setPicker = hash_ban%thrd_num; kmer_t *node; boolean found = search_kmerset(KmerSets[setPicker], word, &node); if(!found) printf("kmer %llx not found,\n",word); else{ printf("kmer %llx, linear %d\n",word,node->linear); for(i=0;i<4;i++){ if(get_kmer_right_cov(*node,i)>0) printf("right %d, kmer %llx\n",i,nextKmer(node->seq,i)); if(get_kmer_left_cov(*node,i)>0) printf("left %d, kmer %llx\n",i,prevKmer(node->seq,i)); } } */ return 1; }
//*************************************************************************************************************** int Ccode::getChimeras(Sequence* query) { try { closest.clear(); refCombo = 0; sumRef.clear(); varRef.clear(); varQuery.clear(); sdRef.clear(); sdQuery.clear(); sumQuery.clear(); sumSquaredRef.clear(); sumSquaredQuery.clear(); averageRef.clear(); averageQuery.clear(); anova.clear(); isChimericConfidence.clear(); isChimericTStudent.clear(); isChimericANOVA.clear(); trim.clear(); spotMap.clear(); windowSizes = window; windows.clear(); querySeq = query; //find closest matches to query closest = findClosest(query, numWanted); if (m->control_pressed) { return 0; } //initialize spotMap for (int i = 0; i < query->getAligned().length(); i++) { spotMap[i] = i; } //mask sequences if the user wants to if (seqMask != "") { decalc->setMask(seqMask); decalc->runMask(query); //mask closest for (int i = 0; i < closest.size(); i++) { decalc->runMask(closest[i].seq); } spotMap = decalc->getMaskMap(); } if (filter) { vector<Sequence*> temp; for (int i = 0; i < closest.size(); i++) { temp.push_back(closest[i].seq); } temp.push_back(query); createFilter(temp, 0.5); for (int i = 0; i < temp.size(); i++) { if (m->control_pressed) { return 0; } runFilter(temp[i]); } //update spotMap map<int, int> newMap; int spot = 0; for (int i = 0; i < filterString.length(); i++) { if (filterString[i] == '1') { //add to newMap newMap[spot] = spotMap[i]; spot++; } } spotMap = newMap; } //trim sequences - this follows ccodes remove_extra_gaps trimSequences(query); if (m->control_pressed) { return 0; } //windows are equivalent to words - ccode paper recommends windows are between 5% and 20% on alignment length(). //Our default will be 10% and we will warn if user tries to use a window above or below these recommendations windows = findWindows(); if (m->control_pressed) { return 0; } //remove sequences that are more than 20% different and less than 0.5% different - may want to allow user to specify this later removeBadReferenceSeqs(closest); if (m->control_pressed) { return 0; } //find the averages for each querys references getAverageRef(closest); //fills sumRef, averageRef, sumSquaredRef and refCombo. getAverageQuery(closest, query); //fills sumQuery, averageQuery, sumSquaredQuery. if (m->control_pressed) { return 0; } //find the averages for each querys references findVarianceRef(); //fills varRef and sdRef also sets minimum error rate to 0.001 to avoid divide by 0. if (m->control_pressed) { return 0; } //find the averages for the query findVarianceQuery(); //fills varQuery and sdQuery also sets minimum error rate to 0.001 to avoid divide by 0. if (m->control_pressed) { return 0; } determineChimeras(); //fills anova, isChimericConfidence, isChimericTStudent and isChimericANOVA. if (m->control_pressed) { return 0; } return 0; } catch(exception& e) { m->errorOut(e, "Ccode", "getChimeras"); exit(1); } }
bool ConfigReader::createConfig() { bool inProcessingMode = false; while(!atEnd()) { TokenType token = readNext(); // First, check if processing is possible if(token == StartElement && name() == "olvisConfig") { inProcessingMode = true; continue; } if(!inProcessingMode) continue; switch(token) { case StartElement: if(name() == "makroFilter") createMakroFilter(); else if(name() == "processor") createProcessor(); else if(name() == "buffer") createBuffer(); else if(name() == "join") createJoin(); else if(name() == "filter") { createFilter(); // Filter could not be created, cancel loading if(mCurrentFilter == -1){ return false; } } else if(name() == "port") setPort(); else if(name() == "makroInput") addMakroInput(); else if(name() == "makroOutput") addMakroOutput(); else if(name() == "processorOutput") addProcessorOutput(); else if(name() == "source") setSource(); else if(name() == "connection") connectProcessors(); else if(name() == "inputConnection") connectProcessorInput(); mCurrentData = ""; break; case Characters: mCurrentData += text(); break; case EndElement: if(name() == "processor") mCurrentProcessor = 0; else if(name() == "filter") mCurrentFilter = 0; else if(name() == "port") mCurrentPort = ""; else if(name() == "value") setValue(); else if(name() == "olvisConfig") inProcessingMode = false; break; default: break; } } // Default: Return true, as config was loaded return true; }
//*************************************************************************** void Kwave::FilterPlugin::run(QStringList params) { Kwave::UndoTransactionGuard *undo_guard = 0; m_pause = false; if (!interpreteParameters(params)) m_params = params; sample_index_t first, last; QList<unsigned int> tracks; selection(&tracks, &first, &last, true); // switch to interactive mode in pre-listen mode Kwave::StreamObject::setInteractive(m_listen); // create all objects Kwave::MultiTrackReader source( (m_listen) ? Kwave::FullSnapshot : Kwave::SinglePassForward, signalManager(), tracks, first, last); Kwave::SampleSource *filter = createFilter(tracks.count()); Q_ASSERT(filter); if (m_listen) { // pre-listen mode Q_ASSERT(m_sink); } else { // normal mode, with undo undo_guard = new(std::nothrow) Kwave::UndoTransactionGuard(*this, actionName()); Q_ASSERT(undo_guard); if (!undo_guard) { if (filter) delete filter; Kwave::StreamObject::setInteractive(false); return; } m_sink = new(std::nothrow) MultiTrackWriter(signalManager(), tracks, Kwave::Overwrite, first, last); Q_ASSERT(m_sink); } if (!filter || !m_sink || m_sink->done()) { if (filter) delete filter; if (undo_guard) delete undo_guard; if (m_sink) delete m_sink; m_sink = 0; Kwave::StreamObject::setInteractive(false); return; } // set up the progress dialog when in processing (not pre-listen) mode if (!m_listen) { connect(&source, SIGNAL(progress(qreal)), this, SLOT(updateProgress(qreal)), Qt::BlockingQueuedConnection); } // force initial update of the filter settings updateFilter(filter, true); // connect them Kwave::connect(source, SIGNAL(output(Kwave::SampleArray)), *filter, SLOT(input(Kwave::SampleArray))); Kwave::connect(*filter, SIGNAL(output(Kwave::SampleArray)), *m_sink, SLOT(input(Kwave::SampleArray))); // transport the samples while (!shouldStop() && (!source.done() || m_listen)) { // process one step source.goOn(); filter->goOn(); // watch out for changed parameters when in // pre-listen mode if (m_listen && paramsChanged()) { updateFilter(filter); } if (m_listen && source.done()) { // start the next loop source.reset(); continue; } // this lets the process wait if the user pressed cancel // and the confirm_cancel dialog is active while (m_pause && !shouldStop()) sleep(1); } // cleanup if (filter) delete filter; if (m_sink) delete m_sink; m_sink = 0; if (undo_guard) delete undo_guard; m_pause = false; m_listen = false; Kwave::StreamObject::setInteractive(false); }