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