VstInt32 MidiCCReset::setChunk(void *data, VstInt32 byteSize, bool isPreset) {
dbg("setChunk " << isPreset);
if (byteSize > 0 && data != 0)
{
if (isPreset) {
MidiCCResetProgram* ap = reinterpret_cast<MidiCCResetProgram*>(data);
setProgramName(ap->name);
for (int i=0;i<kNumParams;i++) {
param[i] = ap->param[i];
}
for (int ch=0;ch<16;ch++) {
for (int n=0;n<128;n++) lastCC[ch][n] = ap->lastCC[ch][n];
}
}
else {
MidiCCResetProgram* ap = reinterpret_cast<MidiCCResetProgram*>(data);
for (int p=0;p<kNumPrograms;p++) {
strcpy(programs[p].name,ap->name);
for (int i=0;i<kNumParams;i++) {
programs[p].param[i] = ap->param[i];
}
for (int ch=0;ch<16;ch++) {
for (int n=0;n<128;n++) programs[p].lastCC[ch][n] = ap->lastCC[ch][n];
}
ap++;
}
firstTime=true;
setProgram(0);
}
}
return 0;
}
//-------------------------------------------------------------------------------------------------------
VstIntPtr AudioEffect::dispatcher (VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt)
{
VstIntPtr v = 0;
switch (opcode)
{
case effOpen: open (); break;
case effClose: close (); break;
case effSetProgram: if (value < numPrograms) setProgram ((VstInt32)value); break;
case effGetProgram: v = getProgram (); break;
case effSetProgramName: setProgramName ((char*)ptr); break;
case effGetProgramName: getProgramName ((char*)ptr); break;
case effGetParamLabel: getParameterLabel (index, (char*)ptr); break;
case effGetParamDisplay: getParameterDisplay (index, (char*)ptr); break;
case effGetParamName: getParameterName (index, (char*)ptr); break;
case effSetSampleRate: setSampleRate (opt); break;
case effSetBlockSize: setBlockSize ((VstInt32)value); break;
case effMainsChanged: if (!value) suspend (); else resume (); break;
#if !VST_FORCE_DEPRECATED
case effGetVu: v = (VstIntPtr)(getVu () * 32767.); break;
#endif
//---Editor------------
case effEditGetRect: if (editor) v = editor->getRect ((ERect**)ptr) ? 1 : 0; break;
case effEditOpen: if (editor) v = editor->open (ptr) ? 1 : 0; break;
case effEditClose: if (editor) editor->close (); break;
case effEditIdle: if (editor) editor->idle (); break;
#if (TARGET_API_MAC_CARBON && !VST_FORCE_DEPRECATED)
case effEditDraw: if (editor) editor->draw ((ERect*)ptr); break;
case effEditMouse: if (editor) v = editor->mouse (index, value); break;
case effEditKey: if (editor) v = editor->key (value); break;
case effEditTop: if (editor) editor->top (); break;
case effEditSleep: if (editor) editor->sleep (); break;
#endif
case DECLARE_VST_DEPRECATED (effIdentify): v = CCONST ('N', 'v', 'E', 'f'); break;
//---Persistence-------
case effGetChunk: v = getChunk ((void**)ptr, index ? true : false); break;
case effSetChunk: v = setChunk (ptr, (VstInt32)value, index ? true : false); break;
}
return v;
}
//-----------------------------------------------------------------------------
long AudioEffect::dispatcher(long opCode, long index, long value, void *ptr, float opt)
{
long v = 0;
switch(opCode)
{
case effOpen: open(); break;
case effClose: close(); break;
case effSetProgram: if(value < numPrograms) setProgram(value); break;
case effGetProgram: v = getProgram(); break;
case effSetProgramName: setProgramName((char *)ptr); break;
case effGetProgramName: getProgramName((char *)ptr); break;
case effGetParamLabel: getParameterLabel(index, (char *)ptr); break;
case effGetParamDisplay: getParameterDisplay(index, (char *)ptr); break;
case effGetParamName: getParameterName(index, (char *)ptr); break;
case effSetSampleRate: setSampleRate(opt); break;
case effSetBlockSize: setBlockSize(value); break;
case effMainsChanged: if(!value) suspend(); else resume(); break;
case effGetVu: v = (long)(getVu() * 32767.); break;
// editor
case effEditGetRect: if(editor) v = editor->getRect((ERect **)ptr); break;
case effEditOpen: if(editor) v = editor->open(ptr); break;
case effEditClose: if(editor) editor->close(); break;
case effEditIdle: if(editor) editor->idle(); break;
#if MAC
case effEditDraw: if(editor) editor->draw((ERect *)ptr); break;
case effEditMouse: if(editor) v = editor->mouse(index, value); break;
case effEditKey: if(editor) v = editor->key(value); break;
case effEditTop: if(editor) editor->top(); break;
case effEditSleep: if(editor) editor->sleep(); break;
#endif
// new
case effIdentify: v = 'NvEf'; break;
case effGetChunk: v = getChunk((void**)ptr, index ? true : false); break;
case effSetChunk: v = setChunk(ptr, value, index ? true : false); break;
}
return v;
}
int
main (int argc, char **argv)
{
char *run1, *run2, *qrels = (char *) 0;
setProgramName (argv[0]);
if (argc == 3 || argc == 4)
{
run1 = argv[1];
run2 = argv[2];
if (argc == 4)
qrels= argv[3];
}
else
usage ();
computeRelevanceProbabilities ();
med (run1, run2, qrels);
return 0;
}
bool Assembler::assemble(string path){
Assembler* ptr = this;
setRootDirectory(parser.filePathToParentDirectory(path));
setProgramName(parser.filePathToFileName(path));
bool invalidateAssembly = false;
try{
loadProgramFromFile(programName);
splitLabels();
replaceEqv();
extractMacroDefinitions();
replaceMacros();
pseudoInstructionPad();
alignRawProgram();
pseudoInstructionReplace();
replaceLabels();
writeAlignedRawProgramToDisk(rootDirectory + programName + alignedProgramNamePostfix);
mapAlignedProgramToVirtualMemory();
builtObjectFileName = rootDirectory + programName + objectNamePostfix;
virtualMemory.serialize(builtObjectFileName);
}catch(AssemblerException &e){
string message = e.toString();
cout << '\n' << message << '\n';
invalidateAssembly = true;
}catch(InvalidTokenException &e){
cout << "ERROR [Assembler::assemble(string fileName)]: HANDLE INVALID TOKEN EXCEPTION IN ASSEMBLER!!!:\t" + e.toString();
getchar();
}
if(recoverableExceptions.size() != 0 || invalidateAssembly){
for(int i=0; i<recoverableExceptions.size(); i++){
cout << recoverableExceptions[i].toString() << '\n';
}
return false;
}
return true;
}
/* heavily outdated */
int main(int argc, char **argv)
{
wchar_t *database = mbstowcs_alloc("test_file");
/* if (database == NULL)
memerrmsg("main in dbio.c");
*/
/* REMEMBER: set the INDEXDIR environment variable. */
setProgramName(*argv);
findUtf8OrDie();
set_dbase_dir();
/* Testing with book.idx and db, renamed, then edited sending output to
stdout, so I can compare! */
fprintf(stderr, "Reading indexfile\n");
read_idxfile(database);
fprintf(stderr, "Reading databasefile\n");
read_database(database);
print_db(database, NULL);
dbmodified = 1;
save_db();
release_idx();
release_db();
return 0;
}
int main(int argc, char **argv) {
time_t starttime=time(0);
struct scalpelState state;
if (ldiv(SIZE_OF_BUFFER,SCALPEL_BLOCK_SIZE).rem != 0) {
fprintf (stderr, SCALPEL_SIZEOFBUFFER_PANIC_STRING);
exit (-1);
}
#ifndef __GLIBC__
setProgramName(argv[0]);
#endif
fprintf (stdout,SCALPEL_BANNER_STRING);
initializeState(argv,&state);
processCommandLineArgs(argc,argv,&state);
convertFileNames(&state);
if (state.modeVerbose) {
fprintf (stdout,"Output directory: \"%s\"\n", state.outputdirectory);
fprintf (stdout,"Configuration file: \"%s\"\n", state.conffile);
fprintf (stdout,"Coverage maps directory: \"%s\"\n", state.coveragedirectory);
}
// read configuration file
if (readSearchSpecFile(&state)) {
// error in configuration file, msg has already been output
exit(-1);
}
setttywidth();
argv += optind;
if (*argv != NULL || state.useInputFileList) {
// prepare audit file and make sure output directory is empty.
if(openAuditFile(&state)){
fprintf(stderr, "Aborting.\n\n");
exit(-1);
}
digAllFiles(argc,argv,&state);
closeFile(state.auditFile);
} else {
usage();
fprintf(stdout,"\nERROR: No image files specified.\n\n");
}
#ifdef __WIN32
fprintf (stdout,"\nScalpel is done, files carved = %I64u, elapsed = %ld seconds.\n",
state.fileswritten,
(int)time(0) - starttime);
#else
fprintf (stdout,"\nScalpel is done, files carved = %llu, elapsed = %ld seconds.\n",
state.fileswritten,
(int)time(0) - starttime);
#endif
return 0;
}
//----------------------------------------------------------------------------
//Plugin Constructor - create programs, set certain variables
//----------------------------------------------------------------------------
AmplitudeImposer::AmplitudeImposer(audioMasterCallback audioMaster)
: AudioEffectX(audioMaster, kNumPrograms, kNumParams)
{
programs = 0;
fDepth = 1.0f;
fThreshold = 0.5f;
for(int i=0;i<NUM_EVENTS_MAX;i++)
{
MIDIEvent[i] = new VstMidiEvent;
MIDIEvent[i]->type = 1;
MIDIEvent[i]->midiData[3] = 0;
MIDIEvent[i]->reserved1 = 99;
MIDIEvent[i]->deltaFrames = -99;
MIDIEvent[i]->noteLength = 0;
MIDIEvent[i]->noteOffset = 0;
EventNumArray[i] = -1;
}
NumPendingEvents = 0;
Events = new VstEvents;
Events->numEvents = 1;
Events->events[0] = (VstEvent *)MIDIEvent[0];
NumEvents = 0;
Frames = 0;
programs = new AmplitudeImposerProg[numPrograms];
if(programs)
{
setProgram(0);
setParameter(kDepth, 1.0f);
setParameter(kThreshold, 0.5f);
setProgramName("Amplitude Imposer");
}
strcpy(kEffectName, "Amplitude Imposer");
strcpy(kProduct, "ndc Plugs Amp Imposer");
strcpy(kVendor, "ndc Plugs");
AudioEffect::__hasVuDeprecated(kVU);
setNumInputs(kNumInputs);
setNumOutputs(kNumOutputs);
AudioEffect::__canMonoDeprecated(kCanMono);
canProcessReplacing(kCanReplacing);
isSynth(kIsSynth);
setUniqueID(kID);
tempo = 125.0f;
samplerate = getSampleRate();
if(samplerate <= 11025.0f)
samplerate = 44100.0f;
checkTooSoon = 0;
checkTempo = 1024;
checkBSZero = false;
ampEnvelope_l = 0.0f;
ampEnvelope_r = 0.0f;
envDecay = 0.0001f;
audioEnvelope_l = 0.0f;
audioEnvelope_r = 0.0f;
//----------------
editor = new AmplitudeImposerEditor(this);
if(!editor)
oome = true;
}
int main(int argc, char **argv)
{
ReadSet *sequences = NULL;
RoadMapArray *rdmaps;
PreGraph *preGraph;
Graph *graph;
char *directory, *graphFilename, *connectedGraphFilename,
*preGraphFilename, *seqFilename, *roadmapFilename,
*lowCovContigsFilename, *highCovContigsFilename;
double coverageCutoff = -1;
double longCoverageCutoff = -1;
double maxCoverageCutoff = -1;
double expectedCoverage = -1;
Coordinate minContigLength = -1;
Coordinate minContigKmerLength;
boolean *dubious = NULL;
Coordinate insertLength[CATEGORIES];
Coordinate insertLengthLong = -1;
Coordinate std_dev[CATEGORIES];
Coordinate std_dev_long = -1;
short int accelerationBits = 24;
boolean readTracking = false;
boolean exportAssembly = false;
boolean unusedReads = false;
boolean estimateCoverage = false;
boolean estimateCutoff = false;
boolean exportAlignments = false;
FILE *file;
int arg_index, arg_int;
double arg_double;
char *arg;
ShortLength *sequenceLengths = NULL;
Category cat;
boolean scaffolding = true;
int pebbleRounds = 1;
long long longlong_var;
short int short_var;
boolean exportFilteredNodes = false;
int clean = 0;
boolean conserveLong = false;
boolean shadows[CATEGORIES];
int coverageMask = 1;
SequencesReader *seqReadInfo = NULL;
setProgramName("velvetg");
for (cat = 0; cat < CATEGORIES; cat++) {
insertLength[cat] = -1;
std_dev[cat] = -1;
shadows[cat] = false;
}
// Error message
if (argc == 1) {
puts("velvetg - de Bruijn graph construction, error removal and repeat resolution");
printf("Version %i.%i.%2.2i\n", VERSION_NUMBER,
RELEASE_NUMBER, UPDATE_NUMBER);
puts("Copyright 2007, 2008 Daniel Zerbino ([email protected])");
puts("This is free software; see the source for copying conditions. There is NO");
puts("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.");
puts("Compilation settings:");
printf("CATEGORIES = %i\n", CATEGORIES);
printf("MAXKMERLENGTH = %i\n", MAXKMERLENGTH);
#ifdef _OPENMP
puts("OPENMP");
#endif
#ifdef LONGSEQUENCES
puts("LONGSEQUENCES");
#endif
#ifdef BIGASSEMBLY
puts("BIGASSEMBLY");
#endif
#ifdef COLOR
puts("COLOR");
#endif
#ifdef DEBUG
puts("DEBUG");
#endif
puts("");
printUsage();
return 1;
}
if (strcmp(argv[1], "--help") == 0) {
printUsage();
return 0;
}
// Memory allocation
directory = argv[1];
graphFilename = mallocOrExit(strlen(directory) + 100, char);
connectedGraphFilename = mallocOrExit(strlen(directory) + 100, char);
preGraphFilename =
mallocOrExit(strlen(directory) + 100, char);
roadmapFilename = mallocOrExit(strlen(directory) + 100, char);
seqFilename = mallocOrExit(strlen(directory) + 100, char);
lowCovContigsFilename = mallocOrExit(strlen(directory) + 100, char);
highCovContigsFilename = mallocOrExit(strlen(directory) + 100, char);
// Argument parsing
for (arg_index = 2; arg_index < argc; arg_index++) {
arg = argv[arg_index++];
if (arg_index >= argc) {
velvetLog("Unusual number of arguments!\n");
printUsage();
#ifdef DEBUG
abort();
#endif
exit(1);
}
if (strcmp(arg, "-cov_cutoff") == 0) {
if (strcmp(argv[arg_index], "auto") == 0) {
estimateCutoff = true;
} else {
sscanf(argv[arg_index], "%lf", &coverageCutoff);
}
} else if (strcmp(arg, "-long_cov_cutoff") == 0) {
sscanf(argv[arg_index], "%lf", &longCoverageCutoff);
} else if (strcmp(arg, "-exp_cov") == 0) {
if (strcmp(argv[arg_index], "auto") == 0) {
estimateCoverage = true;
readTracking = true;
} else {
sscanf(argv[arg_index], "%lf", &expectedCoverage);
if (expectedCoverage > 0)
readTracking = true;
}
} else if (strcmp(arg, "-ins_length") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
insertLength[0] = (Coordinate) longlong_var;
if (insertLength[0] < 0) {
velvetLog("Invalid insert length: %lli\n",
(long long) insertLength[0]);
#ifdef DEBUG
abort();
#endif
exit(1);
}
} else if (strcmp(arg, "-ins_length_sd") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
std_dev[0] = (Coordinate) longlong_var;
if (std_dev[0] < 0) {
velvetLog("Invalid std deviation: %lli\n",
(long long) std_dev[0]);
#ifdef DEBUG
abort();
#endif
exit(1);
}
} else if (strcmp(arg, "-ins_length_long") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
insertLengthLong = (Coordinate) longlong_var;
} else if (strcmp(arg, "-ins_length_long_sd") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
std_dev_long = (Coordinate) longlong_var;
} else if (strncmp(arg, "-ins_length", 11) == 0
&& strchr(arg, 'd') == NULL) {
sscanf(arg, "-ins_length%hi", &short_var);
cat = (Category) short_var;
if (cat < 1 || cat > CATEGORIES) {
velvetLog("Unknown option: %s\n", arg);
#ifdef DEBUG
abort();
#endif
exit(1);
}
sscanf(argv[arg_index], "%lli", &longlong_var);
insertLength[cat - 1] = (Coordinate) longlong_var;
if (insertLength[cat - 1] < 0) {
velvetLog("Invalid insert length: %lli\n",
(long long) insertLength[cat - 1]);
#ifdef DEBUG
abort();
#endif
exit(1);
}
} else if (strncmp(arg, "-ins_length", 11) == 0) {
sscanf(arg, "-ins_length%hi_sd", &short_var);
cat = (Category) short_var;
if (cat < 1 || cat > CATEGORIES) {
velvetLog("Unknown option: %s\n", arg);
#ifdef DEBUG
abort();
#endif
exit(1);
}
sscanf(argv[arg_index], "%lli", &longlong_var);
std_dev[cat - 1] = (Coordinate) longlong_var;
if (std_dev[cat - 1] < 0) {
velvetLog("Invalid std deviation: %lli\n",
(long long) std_dev[cat - 1]);
#ifdef DEBUG
abort();
#endif
exit(1);
}
} else if (strcmp(arg, "-read_trkg") == 0) {
readTracking =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-scaffolding") == 0) {
scaffolding =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-exportFiltered") == 0) {
exportFilteredNodes =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-amos_file") == 0) {
exportAssembly =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-alignments") == 0) {
exportAlignments =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-min_contig_lgth") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
minContigLength = (Coordinate) longlong_var;
} else if (strcmp(arg, "-coverage_mask") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
coverageMask = (IDnum) longlong_var;
} else if (strcmp(arg, "-accel_bits") == 0) {
sscanf(argv[arg_index], "%hi", &accelerationBits);
if (accelerationBits < 0) {
velvetLog
("Illegal acceleration parameter: %s\n",
argv[arg_index]);
printUsage();
return -1;
}
} else if (strcmp(arg, "-max_branch_length") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setMaxReadLength(arg_int);
setLocalMaxReadLength(arg_int);
} else if (strcmp(arg, "-max_divergence") == 0) {
sscanf(argv[arg_index], "%lf", &arg_double);
setMaxDivergence(arg_double);
setLocalMaxDivergence(arg_double);
} else if (strcmp(arg, "-max_gap_count") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setMaxGaps(arg_int);
setLocalMaxGaps(arg_int);
} else if (strcmp(arg, "-min_pair_count") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setUnreliableConnectionCutoff(arg_int);
} else if (strcmp(arg, "-max_coverage") == 0) {
sscanf(argv[arg_index], "%lf", &maxCoverageCutoff);
} else if (strcmp(arg, "-long_mult_cutoff") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setMultiplicityCutoff(arg_int);
} else if (strcmp(arg, "-paired_exp_fraction") == 0) {
sscanf(argv[arg_index], "%lf", &arg_double);
setPairedExpFraction(arg_double);
} else if (strcmp(arg, "-clean") == 0) {
if (strcmp(argv[arg_index], "yes") == 0)
clean = 1;
} else if (strcmp(arg, "-very_clean") == 0) {
if (strcmp(argv[arg_index], "yes") == 0)
clean = 2;
} else if (strcmp(arg, "-conserveLong") == 0) {
if (strcmp(argv[arg_index], "yes") == 0)
conserveLong = 2;
} else if (strcmp(arg, "-unused_reads") == 0) {
unusedReads =
(strcmp(argv[arg_index], "yes") == 0);
if (unusedReads)
readTracking = true;
} else if (strcmp(arg, "-shortMatePaired") == 0) {
shadows[0] = (strcmp(argv[arg_index], "yes") == 0);
} else if (strncmp(arg, "-shortMatePaired", 16) == 0) {
sscanf(arg, "-shortMatePaired%hi", &short_var);
cat = (Category) short_var;
if (cat < 1 || cat > CATEGORIES) {
velvetLog("Unknown option: %s\n", arg);
#ifdef DEBUG
abort();
#endif
exit(1);
}
shadows[cat - 1] = (strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "--help") == 0) {
printUsage();
return 0;
} else {
velvetLog("Unknown option: %s;\n", arg);
printUsage();
return 1;
}
}
// Bookkeeping
logInstructions(argc, argv, directory);
seqReadInfo = callocOrExit(1, SequencesReader);
strcpy(seqFilename, directory);
// if binary CnyUnifiedSeq exists, use it. Otherwise try Sequences
strcat(seqFilename, "/CnyUnifiedSeq");
if (access(seqFilename, R_OK) == 0) {
seqReadInfo->m_bIsBinary = true;
} else {
seqReadInfo->m_bIsBinary = false;
strcpy(seqFilename, directory);
strcat(seqFilename, "/Sequences");
}
seqReadInfo->m_seqFilename = seqFilename;
strcpy(roadmapFilename, directory);
strcat(roadmapFilename, "/Roadmaps");
strcpy(preGraphFilename, directory);
strcat(preGraphFilename, "/PreGraph");
strcpy(connectedGraphFilename, directory);
strcat(connectedGraphFilename, "/ConnectedGraph");
if (!readTracking) {
strcpy(graphFilename, directory);
strcat(graphFilename, "/Graph");
} else {
strcpy(graphFilename, directory);
strcat(graphFilename, "/Graph2");
}
strcpy(lowCovContigsFilename, directory);
strcat(lowCovContigsFilename, "/lowCoverageContigs.fa");
strcpy(highCovContigsFilename, directory);
strcat(highCovContigsFilename, "/highCoverageContigs.fa");
// Graph uploading or creation
if ((file = fopen(graphFilename, "r")) != NULL) {
fclose(file);
graph = importGraph(graphFilename);
} else if ((file = fopen(connectedGraphFilename, "r")) != NULL) {
fclose(file);
if (seqReadInfo->m_bIsBinary) {
sequences = importCnyReadSet(seqFilename);
#if 0
// compare to velvet's version of a seq
ReadSet *compareSequences = NULL;
compareSeqFilename = mallocOrExit(strlen(directory) + 100, char);
strcpy(compareSeqFilename, directory);
strcat(compareSeqFilename, "/Sequences");
compareSequences = importReadSet(compareSeqFilename);
convertSequences(compareSequences);
if (sequences->readCount != compareSequences->readCount) {
printf("read count mismatch\n");
exit(1);
}
int i;
for (i = 0; i < sequences->readCount; i++) {
TightString *tString = getTightStringInArray(sequences->tSequences, i);
TightString *tStringCmp = getTightStringInArray(compareSequences->tSequences, i);
if (getLength(tString) != getLength(tStringCmp)) {
printf("sequence %d len mismatch\n", i);
exit(1);
}
if (strcmp(readTightString(tString), readTightString(tStringCmp)) != 0) {
printf("sequence %d cmp mismatch\n", i);
printf("seq %s != cmp %s\n", readTightString(tString), readTightString(tStringCmp));
exit(1);
}
}
#endif
} else {
int main(int argc, char **argv)
{
ReadSet *allSequences = NULL;
SplayTable *splayTable;
int hashLength, hashLengthStep, hashLengthMax, h;
char *directory, *filename, *seqFilename, *buf;
boolean double_strand = true;
boolean multiple_kmers = false;
DIR *dir;
setProgramName("velveth");
if (argc < 4) {
printf("velveth - simple hashing program\n");
printf("Version %i.%i.%2.2i\n", VERSION_NUMBER,
RELEASE_NUMBER, UPDATE_NUMBER);
printf("\nCopyright 2007, 2008 Daniel Zerbino ([email protected])\n");
printf("This is free software; see the source for copying conditions. There is NO\n");
printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
printf("Compilation settings:\n");
printf("CATEGORIES = %i\n", CATEGORIES);
printf("MAXKMERLENGTH = %i\n", MAXKMERLENGTH);
printf("\n");
printUsage();
return 0;
}
if ( strstr(argv[2],"," ) )
{
sscanf(argv[2],"%d,%d,%d",&hashLength,&hashLengthMax,&hashLengthStep);
multiple_kmers = true;
}
else
{
hashLength = atoi(argv[2]);
hashLengthMax = hashLength + 1;
hashLengthStep = 2;
}
if (hashLengthMax > MAXKMERLENGTH) {
velvetLog
("Velvet can't handle k-mers as long as %i! We'll stick to %i if you don't mind.\n",
hashLength, MAXKMERLENGTH);
hashLength = MAXKMERLENGTH;
} else if (hashLength <= 0) {
velvetLog("Invalid hash length: %s\n", argv[2]);
printUsage();
return 0;
} else if ( hashLength > hashLengthMax ) {
velvetLog("hashLengthMin <= hashLengthMax is required %s", argv[2]);
printUsage();
return 0;
}
if (hashLength % 2 == 0) {
velvetLog
("Velvet can't work with even length k-mers, such as %i. We'll use %i instead, if you don't mind.\n",
hashLength, hashLength - 1);
hashLength--;
}
if (hashLengthStep % 2 == 1) {
velvetLog
("Velvet can't work with an odd length k-mer step, such as %i. We'll use %i instead, if you don't mind.\n",
hashLengthStep, hashLengthStep - 1);
hashLengthStep--;
}
for (h = hashLength; h < hashLengthMax; h += hashLengthStep) {
resetWordFilter(h);
buf = mallocOrExit(strlen(argv[1]) + 100, char);
if ( multiple_kmers ) {
sprintf(buf,"%s_%d",argv[1],h);
directory = mallocOrExit(strlen(buf) + 100, char);
strcpy(directory,buf);
} else
directory = argv[1];
filename = mallocOrExit(strlen(directory) + 100, char);
seqFilename = mallocOrExit(strlen(directory) + 100, char);
dir = opendir(directory);
if (dir == NULL)
mkdir(directory, 0777);
else {
sprintf(buf, "%s/PreGraph", directory);
remove(buf);
sprintf(buf, "%s/Graph", directory);
remove(buf);
sprintf(buf, "%s/Graph2", directory);
remove(buf);
sprintf(buf, "%s/Graph3", directory);
remove(buf);
sprintf(buf, "%s/Graph4", directory);
remove(buf);
sprintf(buf, "%s/Log", directory);
remove(buf);
}
logInstructions(argc, argv, directory);
strcpy(seqFilename, directory);
strcat(seqFilename, "/Sequences");
if ( h == hashLength ) {
parseDataAndReadFiles(seqFilename, argc - 2, &(argv[2]), &double_strand);
} else {
sprintf(buf,"ln -s ../%s_%d/Sequences %s",argv[1],hashLength,seqFilename);
system(buf);
}
splayTable = newSplayTable(h, double_strand);
if (!allSequences)
allSequences = importReadSet(seqFilename);
velvetLog("%li sequences in total.\n", (long) allSequences->readCount);
strcpy(filename, directory);
strcat(filename, "/Roadmaps");
inputSequenceArrayIntoSplayTableAndArchive(allSequences,
splayTable, filename, seqFilename);
destroySplayTable(splayTable);
if (dir)
closedir(dir);
if (directory != argv[1])
free(directory);
free(filename);
free(seqFilename);
free(buf);
}
int main(int argc, char **argv)
{
ReadSet *sequences = NULL;
RoadMapArray *rdmaps;
PreGraph *preGraph;
Graph *graph;
char *directory, *graphFilename, *preGraphFilename, *seqFilename,
*roadmapFilename;
double coverageCutoff = -1;
double maxCoverageCutoff = -1;
double expectedCoverage = -1;
int longMultCutoff = -1;
Coordinate minContigLength = -1;
Coordinate minContigKmerLength;
boolean *dubious = NULL;
Coordinate insertLength[CATEGORIES];
Coordinate insertLengthLong = -1;
Coordinate std_dev[CATEGORIES];
Coordinate std_dev_long = -1;
short int accelerationBits = 24;
boolean readTracking = false;
boolean exportAssembly = false;
boolean unusedReads = false;
boolean estimateCoverage = false;
boolean estimateCutoff = false;
FILE *file;
int arg_index, arg_int;
double arg_double;
char *arg;
Coordinate *sequenceLengths = NULL;
Category cat;
boolean scaffolding = true;
int pebbleRounds = 1;
long long longlong_var;
short int short_var;
setProgramName("velvetg");
for (cat = 0; cat < CATEGORIES; cat++) {
insertLength[cat] = -1;
std_dev[cat] = -1;
}
// Error message
if (argc == 1) {
puts("velvetg - de Bruijn graph construction, error removal and repeat resolution");
printf("Version %i.%i.%2.2i\n", VERSION_NUMBER,
RELEASE_NUMBER, UPDATE_NUMBER);
puts("\nCopyright 2007, 2008 Daniel Zerbino ([email protected])");
puts("This is free software; see the source for copying conditions. There is NO");
puts("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n");
puts("Compilation settings:");
printf("CATEGORIES = %i\n", CATEGORIES);
printf("MAXKMERLENGTH = %i\n", MAXKMERLENGTH);
puts("");
printUsage();
return 1;
}
if (strcmp(argv[1], "--help") == 0) {
printUsage();
return 0;
}
// Memory allocation
directory = argv[1];
graphFilename = mallocOrExit(strlen(directory) + 100, char);
preGraphFilename =
mallocOrExit(strlen(directory) + 100, char);
roadmapFilename = mallocOrExit(strlen(directory) + 100, char);
seqFilename = mallocOrExit(strlen(directory) + 100, char);
// Argument parsing
for (arg_index = 2; arg_index < argc; arg_index++) {
arg = argv[arg_index++];
if (arg_index >= argc) {
puts("Unusual number of arguments!");
printUsage();
exit(1);
}
if (strcmp(arg, "-cov_cutoff") == 0) {
if (strcmp(argv[arg_index], "auto") == 0) {
estimateCutoff = true;
} else {
sscanf(argv[arg_index], "%lf", &coverageCutoff);
}
} else if (strcmp(arg, "-exp_cov") == 0) {
if (strcmp(argv[arg_index], "auto") == 0) {
estimateCoverage = true;
readTracking = true;
} else {
sscanf(argv[arg_index], "%lf", &expectedCoverage);
if (expectedCoverage > 0)
readTracking = true;
}
} else if (strcmp(arg, "-ins_length") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
insertLength[0] = (Coordinate) longlong_var;
if (insertLength[0] < 0) {
printf("Invalid insert length: %lli\n",
(long long) insertLength[0]);
exit(1);
}
} else if (strcmp(arg, "-ins_length_sd") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
std_dev[0] = (Coordinate) longlong_var;
if (std_dev[0] < 0) {
printf("Invalid std deviation: %lli\n",
(long long) std_dev[0]);
exit(1);
}
} else if (strcmp(arg, "-ins_length_long") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
insertLengthLong = (Coordinate) longlong_var;
} else if (strcmp(arg, "-ins_length_long_sd") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
std_dev_long = (Coordinate) longlong_var;
} else if (strncmp(arg, "-ins_length", 11) == 0
&& strchr(arg, 'd') == NULL) {
sscanf(arg, "-ins_length%hi", &short_var);
cat = (Category) short_var;
if (cat < 1 || cat > CATEGORIES) {
printf("Unknown option: %s\n", arg);
exit(1);
}
sscanf(argv[arg_index], "%lli", &longlong_var);
insertLength[cat - 1] = (Coordinate) longlong_var;
if (insertLength[cat - 1] < 0) {
printf("Invalid insert length: %lli\n",
(long long) insertLength[cat - 1]);
exit(1);
}
} else if (strncmp(arg, "-ins_length", 11) == 0) {
sscanf(arg, "-ins_length%hi_sd", &short_var);
cat = (Category) short_var;
if (cat < 1 || cat > CATEGORIES) {
printf("Unknown option: %s\n", arg);
exit(1);
}
sscanf(argv[arg_index], "%lli", &longlong_var);
std_dev[cat - 1] = (Coordinate) longlong_var;
if (std_dev[cat - 1] < 0) {
printf("Invalid std deviation: %lli\n",
(long long) std_dev[cat - 1]);
exit(1);
}
} else if (strcmp(arg, "-read_trkg") == 0) {
readTracking =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-scaffolding") == 0) {
scaffolding =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-amos_file") == 0) {
exportAssembly =
(strcmp(argv[arg_index], "yes") == 0);
} else if (strcmp(arg, "-min_contig_lgth") == 0) {
sscanf(argv[arg_index], "%lli", &longlong_var);
minContigLength = (Coordinate) longlong_var;
} else if (strcmp(arg, "-accel_bits") == 0) {
sscanf(argv[arg_index], "%hi", &accelerationBits);
if (accelerationBits < 0) {
printf
("Illegal acceleration parameter: %s\n",
argv[arg_index]);
printUsage();
return -1;
}
} else if (strcmp(arg, "-max_branch_length") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setMaxReadLength(arg_int);
setLocalMaxReadLength(arg_int);
} else if (strcmp(arg, "-max_divergence") == 0) {
sscanf(argv[arg_index], "%lf", &arg_double);
setMaxDivergence(arg_double);
setLocalMaxDivergence(arg_double);
} else if (strcmp(arg, "-max_gap_count") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setMaxGaps(arg_int);
setLocalMaxGaps(arg_int);
} else if (strcmp(arg, "-min_pair_count") == 0) {
sscanf(argv[arg_index], "%i", &arg_int);
setUnreliableConnectionCutoff(arg_int);
} else if (strcmp(arg, "-max_coverage") == 0) {
sscanf(argv[arg_index], "%lf", &maxCoverageCutoff);
} else if (strcmp(arg, "-long_mult_cutoff") == 0) {
sscanf(argv[arg_index], "%i", &longMultCutoff);
setMultiplicityCutoff(longMultCutoff);
} else if (strcmp(arg, "-unused_reads") == 0) {
unusedReads =
(strcmp(argv[arg_index], "yes") == 0);
if (unusedReads)
readTracking = true;
} else if (strcmp(arg, "--help") == 0) {
printUsage();
return 0;
} else {
printf("Unknown option: %s;\n", arg);
printUsage();
return 1;
}
}
// Bookkeeping
logInstructions(argc, argv, directory);
strcpy(seqFilename, directory);
strcat(seqFilename, "/Sequences");
strcpy(roadmapFilename, directory);
strcat(roadmapFilename, "/Roadmaps");
strcpy(preGraphFilename, directory);
strcat(preGraphFilename, "/PreGraph");
if (!readTracking) {
strcpy(graphFilename, directory);
strcat(graphFilename, "/Graph");
} else {
strcpy(graphFilename, directory);
strcat(graphFilename, "/Graph2");
}
// Graph uploading or creation
if ((file = fopen(graphFilename, "r")) != NULL) {
fclose(file);
graph = importGraph(graphFilename);
} else if ((file = fopen(preGraphFilename, "r")) != NULL) {
fclose(file);
sequences = importReadSet(seqFilename);
convertSequences(sequences);
graph =
importPreGraph(preGraphFilename, sequences,
readTracking, accelerationBits);
sequenceLengths =
getSequenceLengths(sequences, getWordLength(graph));
correctGraph(graph, sequenceLengths);
exportGraph(graphFilename, graph, sequences->tSequences);
} else if ((file = fopen(roadmapFilename, "r")) != NULL) {
fclose(file);
rdmaps = importRoadMapArray(roadmapFilename);
preGraph = newPreGraph_pg(rdmaps, seqFilename);
clipTips_pg(preGraph);
exportPreGraph_pg(preGraphFilename, preGraph);
destroyPreGraph_pg(preGraph);
sequences = importReadSet(seqFilename);
convertSequences(sequences);
graph =
importPreGraph(preGraphFilename, sequences,
readTracking, accelerationBits);
sequenceLengths =
getSequenceLengths(sequences, getWordLength(graph));
correctGraph(graph, sequenceLengths);
exportGraph(graphFilename, graph, sequences->tSequences);
} else {
puts("No Roadmap file to build upon! Please run velveth (see manual)");
exit(1);
}
// Set insert lengths and their standard deviations
for (cat = 0; cat < CATEGORIES; cat++) {
if (insertLength[cat] > -1 && std_dev[cat] < 0)
std_dev[cat] = insertLength[cat] / 10;
setInsertLengths(graph, cat,
insertLength[cat], std_dev[cat]);
}
if (insertLengthLong > -1 && std_dev_long < 0)
std_dev_long = insertLengthLong / 10;
setInsertLengths(graph, CATEGORIES,
insertLengthLong, std_dev_long);
// Coverage cutoff
if (expectedCoverage < 0 && estimateCoverage == true) {
expectedCoverage = estimated_cov(graph);
if (coverageCutoff < 0) {
coverageCutoff = expectedCoverage / 2;
estimateCutoff = true;
}
} else {
estimateCoverage = false;
if (coverageCutoff < 0 && estimateCutoff)
coverageCutoff = estimated_cov(graph) / 2;
else
estimateCutoff = false;
}
if (coverageCutoff < 0) {
puts("WARNING: NO COVERAGE CUTOFF PROVIDED");
puts("Velvet will probably leave behind many detectable errors");
puts("See manual for instructions on how to set the coverage cutoff parameter");
}
dubious =
removeLowCoverageNodesAndDenounceDubiousReads(graph,
coverageCutoff);
removeHighCoverageNodes(graph, maxCoverageCutoff);
clipTipsHard(graph);
if (expectedCoverage > 0) {
if (sequences == NULL) {
sequences = importReadSet(seqFilename);
convertSequences(sequences);
}
// Mixed length sequencing
readCoherentGraph(graph, isUniqueSolexa, expectedCoverage,
sequences);
// Paired ends module
createReadPairingArray(sequences);
for (cat = 0; cat < CATEGORIES; cat++)
if(pairUpReads(sequences, 2 * cat + 1))
pebbleRounds++;
if (pairUpReads(sequences, 2 * CATEGORIES + 1))
pebbleRounds++;
detachDubiousReads(sequences, dubious);
activateGapMarkers(graph);
for ( ;pebbleRounds > 0; pebbleRounds--)
exploitShortReadPairs(graph, sequences, dubious, scaffolding);
} else {
puts("WARNING: NO EXPECTED COVERAGE PROVIDED");
puts("Velvet will be unable to resolve any repeats");
puts("See manual for instructions on how to set the expected coverage parameter");
}
free(dubious);
concatenateGraph(graph);
if (minContigLength < 2 * getWordLength(graph))
minContigKmerLength = getWordLength(graph);
else
minContigKmerLength = minContigLength - getWordLength(graph) + 1;
strcpy(graphFilename, directory);
strcat(graphFilename, "/contigs.fa");
exportLongNodeSequences(graphFilename, graph, minContigKmerLength);
strcpy(graphFilename, directory);
strcat(graphFilename, "/stats.txt");
displayGeneralStatistics(graph, graphFilename);
if (sequences == NULL) {
sequences = importReadSet(seqFilename);
convertSequences(sequences);
}
strcpy(graphFilename, directory);
strcat(graphFilename, "/LastGraph");
exportGraph(graphFilename, graph, sequences->tSequences);
if (exportAssembly) {
strcpy(graphFilename, directory);
strcat(graphFilename, "/velvet_asm.afg");
exportAMOSContigs(graphFilename, graph, minContigKmerLength, sequences);
}
if (unusedReads)
exportUnusedReads(graph, sequences, minContigKmerLength, directory);
if (estimateCoverage)
printf("Estimated Coverage = %f\n", expectedCoverage);
if (estimateCutoff)
printf("Estimated Coverage cutoff = %f\n", coverageCutoff);
logFinalStats(graph, minContigKmerLength, directory);
destroyGraph(graph);
free(graphFilename);
free(preGraphFilename);
free(seqFilename);
free(roadmapFilename);
destroyReadSet(sequences);
return 0;
}
int main(int argc, char **argv)
{
ReadSet *allSequences = NULL;
SplayTable *splayTable;
int hashLength, hashLengthStep, hashLengthMax, h;
char *directory, *filename, *seqFilename, *baseSeqName, *buf;
char * token;
boolean double_strand = true;
boolean noHash = false;
boolean multiple_kmers = false;
char buffer[100];
DIR *dir;
setProgramName("velveth");
if (argc < 4) {
printf("velveth - simple hashing program\n");
printf("Version %i.%i.%2.2i\n", VERSION_NUMBER,
RELEASE_NUMBER, UPDATE_NUMBER);
printf("\nCopyright 2007, 2008 Daniel Zerbino ([email protected])\n");
printf("This is free software; see the source for copying conditions. There is NO\n");
printf("warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
printf("Compilation settings:\n");
printf("CATEGORIES = %i\n", CATEGORIES);
printf("MAXKMERLENGTH = %i\n", MAXKMERLENGTH);
#ifdef _OPENMP
puts("OPENMP");
#endif
#ifdef LONGSEQUENCES
puts("LONGSEQUENCES");
#endif
#ifdef BIGASSEMBLY
puts("BIGASSEMBLY");
#endif
#ifdef COLOR
puts("COLOR");
#endif
#ifdef DEBUG
puts("DEBUG");
#endif
printf("\n");
printUsage();
return 0;
}
strcpy(buffer, argv[2]);
token = strtok(buffer, ",");
hashLength = atoi(token);
token = strtok(NULL, ",");
if (token == NULL) {
multiple_kmers = false;
hashLengthMax = hashLength + 1;
} else {
multiple_kmers = true;
hashLengthMax = atoi(token);
}
token = strtok(NULL, ",");
if (token == NULL) {
hashLengthStep = 2;
} else {
hashLengthStep = atoi(token);
}
if (hashLength > MAXKMERLENGTH) {
velvetLog
("Velvet can't handle k-mers as long as %i! We'll stick to %i if you don't mind.\n",
hashLength, MAXKMERLENGTH);
hashLength = MAXKMERLENGTH;
}
if (hashLength <= 0) {
velvetLog("Invalid hash length: %s\n", argv[2]);
printUsage();
return 0;
}
if (hashLength % 2 == 0) {
velvetLog
("Velvet can't work with even length k-mers, such as %i. We'll use %i instead, if you don't mind.\n",
hashLength, hashLength - 1);
hashLength--;
}
if (multiple_kmers) {
if (hashLengthMax > MAXKMERLENGTH + 1) {
velvetLog
("Velvet can't handle k-mers as long as %i! We'll stick to %i if you don't mind.\n",
hashLengthMax, MAXKMERLENGTH + 1);
hashLengthMax = MAXKMERLENGTH + 1;
}
if (hashLengthMax <= hashLength) {
velvetLog("hashLengthMin < hashLengthMax is required %s", argv[2]);
printUsage();
return 0;
}
if (hashLengthStep <= 0) {
velvetLog("Non-positive hash length! Setting it to 2\n");
hashLengthStep = 2;
}
if (hashLengthStep % 2 == 1) {
velvetLog
("Velvet can't work with an odd length k-mer step, such as %i. We'll use %i instead, if you don't mind.\n",
hashLengthStep, hashLengthStep + 1);
hashLengthStep++;
}
}
// check if binary sequences should be used
int argIndex;
for (argIndex = 3; argIndex < argc; argIndex++)
if (strcmp(argv[argIndex], "-create_binary") == 0 || strcmp(argv[argIndex], "-reuse_binary") == 0)
setCreateBinary(true);
for (h = hashLength; h < hashLengthMax; h += hashLengthStep) {
resetWordFilter(h);
buf = mallocOrExit(2 * strlen(argv[1]) + 500, char);
if ( multiple_kmers ) {
sprintf(buf,"%s_%d",argv[1],h);
directory = mallocOrExit(strlen(buf) + 100, char);
strcpy(directory,buf);
} else
directory = argv[1];
filename = mallocOrExit(strlen(directory) + 100, char);
seqFilename = mallocOrExit(strlen(directory) + 100, char);
baseSeqName = mallocOrExit(100, char);
dir = opendir(directory);
if (dir == NULL)
mkdir(directory, 0777);
else {
sprintf(buf, "%s/PreGraph", directory);
remove(buf);
sprintf(buf, "%s/Graph", directory);
remove(buf);
sprintf(buf, "%s/Graph2", directory);
remove(buf);
sprintf(buf, "%s/Graph3", directory);
remove(buf);
sprintf(buf, "%s/Graph4", directory);
remove(buf);
}
logInstructions(argc, argv, directory);
strcpy(seqFilename, directory);
if (isCreateBinary()) {
// use the CNY unified seq writer
strcpy(baseSeqName, "/CnyUnifiedSeq");
// remove other style sequences file
sprintf(buf, "%s/Sequences", directory);
remove(buf);
} else {
strcpy(baseSeqName, "/Sequences");
// remove other style sequences file
sprintf(buf, "%s/CnyUnifiedSeq", directory);
remove(buf);
sprintf(buf, "%s/CnyUnifiedSeq.names", directory);
remove(buf);
}
strcat(seqFilename, baseSeqName);
if ( h == hashLength ) {
parseDataAndReadFiles(seqFilename, argc - 2, &(argv[2]), &double_strand, &noHash);
} else {
sprintf(buf,"rm -f %s",seqFilename);
if (system(buf)) {
velvetLog("Command failed!\n");
velvetLog("%s\n", buf);
#ifdef DEBUG
abort();
#endif
exit(1);
}
if (argv[1][0] == '/')
sprintf(buf,"ln -s %s_%d%s %s",argv[1],hashLength,baseSeqName,seqFilename);
else
sprintf(buf,"ln -s `pwd`/%s_%d%s %s",argv[1],hashLength,baseSeqName,seqFilename);
if (system(buf)) {
velvetLog("Command failed!\n");
velvetLog("%s\n", buf);
#ifdef DEBUG
abort();
#endif
exit(1);
}
}
if (noHash)
continue;
splayTable = newSplayTable(h, double_strand);
if (isCreateBinary()) {
allSequences = importCnyReadSet(seqFilename);
} else {
allSequences = importReadSet(seqFilename);
}
velvetLog("%li sequences in total.\n", (long) allSequences->readCount);
strcpy(filename, directory);
strcat(filename, "/Roadmaps");
inputSequenceArrayIntoSplayTableAndArchive(allSequences,
splayTable, filename, seqFilename);
destroySplayTable(splayTable);
if (dir)
closedir(dir);
if (directory != argv[1])
free(directory);
free(filename);
free(seqFilename);
free(baseSeqName);
free(buf);
if (allSequences) {
destroyReadSet(allSequences);
}
}
