void CoreApplication::saveOriginalFrame(QString path, int frame, bool cropped){
const Frame* f = originalVideo->getFrameAt(frame);
const Mat& originalData = f->getOriginalData();
if (cropped) {
Mat cropped = originalData(originalVideo->getCropBox());
cv::imwrite(path.toStdString(), cropped);
} else {
cv::imwrite(path.toStdString(), originalData);
}
}
static void testWritePad(skiatest::Reporter* reporter, SkWriter32* writer) {
// Create some random data to write.
const size_t dataSize = 10;
SkAutoTMalloc<uint32_t> originalData(dataSize);
{
SkRandom rand(0);
for (size_t i = 0; i < dataSize; i++) {
originalData[(int) i] = rand.nextU();
}
// Write the random data to the writer at different lengths for
// different alignments.
for (size_t len = 0; len < dataSize; len++) {
writer->writePad(originalData.get(), len);
}
}
size_t totalBytes = writer->bytesWritten();
SkAutoMalloc readStorage(totalBytes);
writer->flatten(readStorage.get());
SkReader32 reader;
reader.setMemory(readStorage.get(), totalBytes);
for (size_t len = 0; len < dataSize; len++) {
const char* readPtr = static_cast<const char*>(reader.skip(len));
// Ensure that the data read is the same as what was written.
REPORTER_ASSERT(reporter, memcmp(readPtr, originalData.get(), len) == 0);
// Ensure that the rest is padded with zeroes.
const char* stop = readPtr + SkAlign4(len);
readPtr += len;
while (readPtr < stop) {
REPORTER_ASSERT(reporter, *readPtr++ == 0);
}
}
}
void encode2Meta(char *database, char *manifestIn, char *outMetaRa)
/* encode2Meta - Create meta files.. */
{
int dbIx = stringArrayIx(database, metaDbs, ArraySize(metaDbs));
if (dbIx < 0)
errAbort("Unrecognized database %s", database);
/* Create a three level meta.ra format file based on hgFixed.encodeExp
* and database.metaDb tables. The levels are composite, experiment, file */
struct metaNode *metaTree = metaTreeNew("encode2");
/* Load up the manifest. */
struct encode2Manifest *mi, *miList = encode2ManifestShortLoadAll(manifestIn);
struct hash *miHash = hashNew(18);
for (mi = miList; mi != NULL; mi = mi->next)
hashAdd(miHash, mi->fileName, mi);
verbose(1, "%d files in %s\n", miHash->elCount, manifestIn);
/* Load up encodeExp info. */
struct sqlConnection *expConn = sqlConnect(expDb);
struct encodeExp *expList = encodeExpLoadByQuery(expConn, "NOSQLINJ select * from encodeExp");
sqlDisconnect(&expConn);
verbose(1, "%d experiments in encodeExp\n", slCount(expList));
struct hash *compositeHash = hashNew(0);
/* Go through each organism database in turn. */
int i;
for (i=0; i<ArraySize(metaDbs); ++i)
{
char *db = metaDbs[i];
if (!sameString(database, db))
continue;
verbose(1, "exploring %s\n", db);
struct mdbObj *mdb, *mdbList = getMdbList(db);
verbose(1, "%d meta objects in %s\n", slCount(mdbList), db);
/* Get info on all composites. */
for (mdb = mdbList; mdb != NULL; mdb = mdb->next)
{
char *objType = mdbVarLookup(mdb->vars, "objType");
if (objType != NULL && sameString(objType, "composite"))
{
char compositeName[256];
safef(compositeName, sizeof(compositeName), "%s", mdb->obj);
struct metaNode *compositeNode = metaNodeNew(compositeName);
slAddHead(&metaTree->children, compositeNode);
compositeNode->parent = metaTree;
struct mdbVar *v;
for (v=mdb->vars; v != NULL; v = v->next)
{
metaNodeAddVar(compositeNode, v->var, v->val);
}
metaNodeAddVar(compositeNode, "assembly", db);
hashAdd(compositeHash, mdb->obj, compositeNode);
}
}
/* Make up one more for experiments with no composite. */
char *noCompositeName = "wgEncodeZz";
struct metaNode *noCompositeNode = metaNodeNew(noCompositeName);
slAddHead(&metaTree->children, noCompositeNode);
noCompositeNode->parent = metaTree;
hashAdd(compositeHash, noCompositeName, noCompositeNode);
/* Now go through objects trying to tie experiments to composites. */
struct hash *expToComposite = hashNew(16);
for (mdb = mdbList; mdb != NULL; mdb = mdb->next)
{
char *composite = mdbVarLookup(mdb->vars, "composite");
if (originalData(composite))
{
char *dccAccession = mdbVarLookup(mdb->vars, "dccAccession");
if (dccAccession != NULL)
{
char *oldComposite = hashFindVal(expToComposite, dccAccession);
if (oldComposite != NULL)
{
if (!sameString(oldComposite, composite))
verbose(2, "%s maps to %s ignoring mapping to %s", dccAccession, oldComposite, composite);
}
else
{
hashAdd(expToComposite, dccAccession, composite);
}
}
}
}
/* Now get info on all experiments in this organism. */
struct hash *expHash = hashNew(0);
struct encodeExp *exp;
for (exp = expList; exp != NULL; exp = exp->next)
{
if (sameString(exp->organism, organisms[i]))
{
if (exp->accession != NULL)
{
char *composite = hashFindVal(expToComposite, exp->accession);
struct metaNode *compositeNode;
if (composite != NULL)
{
compositeNode = hashMustFindVal(compositeHash, composite);
}
else
{
compositeNode = noCompositeNode;
}
struct metaNode *expNode = wrapNodeAroundExp(exp);
hashAdd(expHash, expNode->name, expNode);
slAddHead(&compositeNode->children, expNode);
expNode->parent = compositeNode;
}
}
}
for (mdb = mdbList; mdb != NULL; mdb = mdb->next)
{
char *fileName = NULL, *dccAccession = NULL;
char *objType = mdbVarLookup(mdb->vars, "objType");
if (objType != NULL && sameString(objType, "composite"))
continue;
dccAccession = mdbVarLookup(mdb->vars, "dccAccession");
if (dccAccession == NULL)
continue;
char *composite = hashFindVal(expToComposite, dccAccession);
if (composite == NULL)
errAbort("Can't find composite for %s", mdb->obj);
struct mdbVar *v;
for (v = mdb->vars; v != NULL; v = v->next)
{
char *var = v->var, *val = v->val;
if (sameString("fileName", var))
{
fileName = val;
char path[PATH_LEN];
char *comma = strchr(fileName, ',');
if (comma != NULL)
*comma = 0; /* Cut off comma separated list. */
safef(path, sizeof(path), "%s/%s/%s", db,
composite, fileName); /* Add database path */
fileName = val = v->val = cloneString(path);
}
}
if (fileName != NULL)
{
if (hashLookup(miHash, fileName))
{
struct metaNode *expNode = hashFindVal(expHash, dccAccession);
if (expNode != NULL)
{
struct metaNode *fileNode = metaNodeNew(mdb->obj);
slAddHead(&expNode->children, fileNode);
fileNode->parent = expNode;
struct mdbVar *v;
for (v=mdb->vars; v != NULL; v = v->next)
{
metaNodeAddVar(fileNode, v->var, v->val);
}
}
}
}
}
#ifdef SOON
#endif /* SOON */
}
struct hash *suppress = makeSuppress();
struct hash *closeEnoughTags = makeCloseEnoughTags();
metaTreeHoist(metaTree, closeEnoughTags);
metaTreeSortChildrenSortTags(metaTree);
FILE *f = mustOpen(outMetaRa, "w");
struct metaNode *node;
for (node = metaTree->children; node != NULL; node = node->next)
metaTreeWrite(0, 0, BIGNUM, FALSE, NULL, node, suppress, f);
carefulClose(&f);
/* Write warning about tags in highest parent. */
struct mdbVar *v;
for (v = metaTree->vars; v != NULL; v = v->next)
verbose(1, "Omitting universal %s %s\n", v->var, v->val);
}
//**********************************************************************************************************************
int SparccCommand::process(vector<SharedRAbundVector*>& lookup){
try {
cout.setf(ios::fixed, ios::floatfield);
cout.setf(ios::showpoint);
vector<vector<float> > sharedVector;
vector<string> otuNames = m->currentSharedBinLabels;
//fill sharedVector to pass to CalcSparcc
for (int i = 0; i < lookup.size(); i++) {
vector<int> abunds = lookup[i]->getAbundances();
vector<float> temp;
for (int j = 0; j < abunds.size(); j++) { temp.push_back((float) abunds[j]); }
sharedVector.push_back(temp);
}
int numOTUs = (int)sharedVector[0].size();
int numGroups = lookup.size();
map<string, string> variables;
variables["[filename]"] = outputDir + m->getRootName(m->getSimpleName(sharedfile));
variables["[distance]"] = lookup[0]->getLabel();
string relAbundFileName = getOutputFileName("sparccrelabund", variables);
ofstream relAbundFile;
m->openOutputFile(relAbundFileName, relAbundFile);
outputNames.push_back(relAbundFileName); outputTypes["sparccrelabund"].push_back(relAbundFileName);
relAbundFile << "OTU\taveRelAbund\n";
for(int i=0;i<numOTUs;i++){
if (m->control_pressed) { relAbundFile.close(); return 0; }
double relAbund = 0.0000;
for(int j=0;j<numGroups;j++){
relAbund += sharedVector[j][i]/(double)lookup[j]->getNumSeqs();
}
relAbundFile << otuNames[i] <<'\t' << relAbund / (double) numGroups << endl;
}
relAbundFile.close();
CalcSparcc originalData(sharedVector, maxIterations, numSamplings, normalizeMethod);
vector<vector<float> > origCorrMatrix = originalData.getRho();
string correlationFileName = getOutputFileName("corr", variables);
ofstream correlationFile;
m->openOutputFile(correlationFileName, correlationFile);
outputNames.push_back(correlationFileName); outputTypes["corr"].push_back(correlationFileName);
correlationFile.setf(ios::fixed, ios::floatfield);
correlationFile.setf(ios::showpoint);
for(int i=0;i<numOTUs;i++){ correlationFile << '\t' << otuNames[i]; } correlationFile << endl;
for(int i=0;i<numOTUs;i++){
correlationFile << otuNames[i];
for(int j=0;j<numOTUs;j++){
correlationFile << '\t' << origCorrMatrix[i][j];
}
correlationFile << endl;
}
if(numPermutations != 0){
vector<vector<float> > pValues = createProcesses(sharedVector, origCorrMatrix);
if (m->control_pressed) { return 0; }
string pValueFileName = getOutputFileName("pvalue", variables);
ofstream pValueFile;
m->openOutputFile(pValueFileName, pValueFile);
outputNames.push_back(pValueFileName); outputTypes["pvalue"].push_back(pValueFileName);
pValueFile.setf(ios::fixed, ios::floatfield);
pValueFile.setf(ios::showpoint);
for(int i=0;i<numOTUs;i++){ pValueFile << '\t' << otuNames[i]; } pValueFile << endl;
for(int i=0;i<numOTUs;i++){
pValueFile << otuNames[i];
for(int j=0;j<numOTUs;j++){
pValueFile << '\t' << pValues[i][j];
}
pValueFile << endl;
}
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "SparccCommand", "process");
exit(1);
}
}
