X-Git-Url: https://git.donarmstrong.com/?p=mothur.git;a=blobdiff_plain;f=heatmap.cpp;h=514c7af15312b60d4787bb0aa659dbd9f1ccaf08;hp=75a2b873f917dfc872d443f73bb17e7d21dbb2db;hb=b206f634aae1b4ce13978d203247fb64757d5482;hpb=c5c7502f435e1413c19e373dab1dfebcaa67588d diff --git a/heatmap.cpp b/heatmap.cpp index 75a2b87..514c7af 100644 --- a/heatmap.cpp +++ b/heatmap.cpp @@ -10,211 +10,230 @@ #include "heatmap.h" //********************************************************************************************************************** -HeatMap::HeatMap(){ +HeatMap::HeatMap(string sort, string scale, int num, int fsize, string dir, string i){ try { - globaldata = GlobalData::getInstance(); - format = globaldata->getFormat(); - sorted = globaldata->getSorted(); - util = new SharedUtil(); - + m = MothurOut::getInstance(); +// format = globaldata->getFormat(); + sorted = sort; + scaler = scale; + outputDir = dir; + numOTU = num; + fontSize = fsize; + inputfile = i; } catch(exception& e) { - cout << "Standard Error: " << e.what() << " has occurred in the HeatMap class Function HeatMap. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; - exit(1); - } - catch(...) { - cout << "An unknown error has occurred in the HeatMap class function HeatMap. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; + m->errorOut(e, "HeatMap", "HeatMap"); exit(1); } } + //********************************************************************************************************************** -void HeatMap::getPic(OrderVector* order) { + +string HeatMap::getPic(RAbundVector* rabund) { try { - colorScale.clear(); - rabund = order->getRAbundVector(); + int numBinsToDisplay = rabund->getNumBins(); - for (int i = 0; i < rabund.size(); i++) { - colorScale[rabund.get(i)] = ""; + if (numOTU != 0) { //user want to display a portion of the otus + if (numOTU < numBinsToDisplay) { numBinsToDisplay = numOTU; } } - float scaler = 255 / (float) colorScale.size(); + //sort lookup so shared bins are on top + if (sorted != "none") { sortRabund(rabund); } - //go through map and give each score a color value - for (it = colorScale.begin(); it != colorScale.end(); it++) { - it->second = toHex(int(float(it->first) * scaler)); - if(it->second.length() == 1) { it->second = "0" + it->second; } + float maxRelAbund = 0.0; + + for(int i=0;isize();i++){ + float relAbund = rabund->get(i) / (float)rabund->getNumSeqs(); + if(relAbund > maxRelAbund){ maxRelAbund = relAbund; } } - - string filenamesvg = getRootName(globaldata->inputFileName) + order->getLabel() + ".heatmap.svg"; - openOutputFile(filenamesvg, outsvg); + vector scaleRelAbund(numBinsToDisplay, ""); - //scale max rank so the maxrank = bright red + for(int i=0;iget(i) / (float)rabund->getNumSeqs(); + + if (m->control_pressed) { return "control"; } + if (rabund->get(i) != 0) { //don't want log value of 0. + if (scaler == "log10") { + scaleRelAbund[i] = toHex(int(255 * log10(relAbund) / log10(maxRelAbund))) + "0000"; + }else if (scaler == "log2") { + scaleRelAbund[i] = toHex(int(255 * log2(relAbund) / log2(maxRelAbund))) + "0000"; + }else if (scaler == "linear") { + scaleRelAbund[i] = toHex(int(255 * relAbund / maxRelAbund)) + "0000"; + }else { //if user enters invalid scaler option. + scaleRelAbund[i] = toHex(int(255 * log10(relAbund / log10(maxRelAbund)))) + "0000"; + } + } + else { scaleRelAbund[i] = "FFFFFF"; } + } + + + string filenamesvg = outputDir + m->getRootName(m->getSimpleName(inputfile)) + rabund->getLabel() + ".heatmap.bin.svg"; + m->openOutputFile(filenamesvg, outsvg); + //svg image - outsvg << "\n"; + outsvg << "\n"; outsvg << "\n"; - int x = 15; - int y = 15; + //white backround + outsvg << ""; + outsvg << "Heatmap at distance " + rabund->getLabel() + "\n"; + + //output legend and color labels string color; - - for (int i = 0; i <= rabund.getNumBins(); i++) { + int x = 0; + int y = 103 + (numBinsToDisplay*5); + printLegend(y, maxRelAbund); - color = colorScale[rabund.get(i)]; + y = 70; + + for (int i = 0; i < scaleRelAbund.size(); i++) { + if (m->control_pressed) { outsvg.close(); return "control"; } - outsvg << "\n"; + outsvg << "\n"; y += 5; } - outsvg << "\n\n"; + outsvg << "\n\n"; outsvg.close(); + return filenamesvg; } catch(exception& e) { - cout << "Standard Error: " << e.what() << " has occurred in the HeatMap class Function getPic. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; - exit(1); - } - catch(...) { - cout << "An unknown error has occurred in the HeatMap class function getPic. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; + m->errorOut(e, "HeatMap", "getPic"); exit(1); } } + //********************************************************************************************************************** -void HeatMap::getPic(SharedOrderVector* sharedorder) { + +string HeatMap::getPic(vector lookup) { try { - colorScale.clear(); + + int numBinsToDisplay = lookup[0]->size(); - //fills vector of sharedsabunds - lookup - util->getSharedVectors(globaldata->Groups, lookup, sharedorder); //fills group vectors from order vector. + if (numOTU != 0) { //user want to display a portion of the otus + if (numOTU < numBinsToDisplay) { numBinsToDisplay = numOTU; } + } //sort lookup so shared bins are on top - if (sorted == "1") { sortSharedVectors(); } + vector sortedLabels = m->currentSharedBinLabels; + if (sorted != "none") { sortedLabels = sortSharedVectors(lookup); } - //get users scaling method - scaler = globaldata->getScaler(); + vector > scaleRelAbund; + vector maxRelAbund(lookup[0]->size(), 0.0); + float superMaxRelAbund = 0; - int maxbin = 0; - for (int i = 0; i < lookup.size(); i++) { - for (int j = 0; j < lookup[i]->size(); j++) { - //if (lookup[i]->getAbundance(j) != 0) { //don't want log value of 0. - //if (scaler == "log10") { - // colorScale[-log((log10(lookup[i]->getAbundance(j)) / (float)lookup[i]->getNumSeqs()))] = ""; - //cout << "abundance = " << lookup[i]->getAbundance(j) << '\t' << " relative adundance = " << (lookup[i]->getAbundance(j) / (float)lookup[i]->getNumSeqs()) << '\t'; - //cout << -log((log10(lookup[i]->getAbundance(j)) / lookup[i]->getNumSeqs())) << endl; - //}else if (scaler == "log2") { - //colorScale[-log((log2(lookup[i]->getAbundance(j)) / (float)lookup[i]->getNumSeqs()))] = ""; //cout << (int)log2(lookup[i]->getAbundance(j)) << endl; - //cout << "abundance = " << lookup[i]->getAbundance(j) << '\t' << " relative adundance = " << lookup[i]->getAbundance(j) / (float)lookup[i]->getNumSeqs() << '\t'; - //cout << -log((log2(lookup[i]->getAbundance(j)) / lookup[i]->getNumSeqs())) << endl; - // }else if (scaler == "linear") { - colorScale[lookup[i]->getAbundance(j)] = ""; - if (maxbin < lookup[i]->getAbundance(j)) { maxbin = lookup[i]->getAbundance(j); } - //cout << "abundance = " << lookup[i]->getAbundance(j) << '\t' << " relative adundance = " << lookup[i]->getAbundance(j) / (float)lookup[i]->getNumSeqs() << '\t'; - //cout << lookup[i]->getAbundance(j) /(float) lookup[i]->getNumSeqs() << endl; - //}else { //if user enters invalid scaler option. - // cout << scaler << " is not a valid scaler option. I will use log10." << endl; - // colorScale[-log(log10(lookup[i]->getAbundance(j) / lookup[i]->getNumSeqs()))] = ""; - //} - //}else { colorScale[0] = "00"; } + for(int i = 0; i < lookup.size(); i++){ + for(int j=0; jsize(); j++){ + float relAbund = lookup[i]->getAbundance(j) / (float)lookup[i]->getNumSeqs(); + if(relAbund > maxRelAbund[i]){ maxRelAbund[i] = relAbund; } } + if(maxRelAbund[i] > superMaxRelAbund){ superMaxRelAbund = maxRelAbund[i]; } } - //get scaler - float scalers = 255 / (float) maxbin; - - //go through map and give each score a color value - for (it = colorScale.begin(); it != colorScale.end(); it++) { - it->second = toHex(int(float(it->first) * scalers)); - if(it->second.length() == 1) { it->second = "0" + it->second; } -//cout << it->first << " " << it->second << endl; + scaleRelAbund.resize(lookup.size()); + for(int i=0;icontrol_pressed) { return "control"; } + float relAbund = lookup[i]->getAbundance(j) / (float)lookup[i]->getNumSeqs(); + + if (lookup[i]->getAbundance(j) != 0) { //don't want log value of 0. + if (scaler == "log10") { + scaleRelAbund[i][j] = toHex(int(255 * log10(relAbund) / log10(maxRelAbund[i]))) + "0000"; + }else if (scaler == "log2") { + scaleRelAbund[i][j] = toHex(int(255 * log2(relAbund) / log2(maxRelAbund[i]))) + "0000"; + }else if (scaler == "linear") { + scaleRelAbund[i][j] = toHex(int(255 * relAbund / maxRelAbund[i])) + "0000"; + }else { //if user enters invalid scaler option. + scaleRelAbund[i][j] = toHex(int(255 * log10(relAbund / log10(maxRelAbund[i])))) + "0000"; + } + }else { scaleRelAbund[i][j] = "FFFFFF"; } + + } } - - string filenamesvg = getRootName(globaldata->inputFileName) + sharedorder->getLabel() + ".heatmap.svg"; - openOutputFile(filenamesvg, outsvg); + + string filenamesvg = outputDir + m->getRootName(m->getSimpleName(inputfile)) + lookup[0]->getLabel() + ".heatmap.bin.svg"; + m->openOutputFile(filenamesvg, outsvg); + int binHeight = 20; + int labelBump = 100; + int binWidth = 300; //svg image - outsvg << "getNumBins()*5 + 120)) + "\">\n"; + outsvg << "\n"; outsvg << "\n"; //white backround - outsvg << "getNumBins()*5 + 120)) + "\"/>"; - outsvg << "Heatmap at distance " + sharedorder->getLabel() + "\n"; + outsvg << ""; + outsvg << "Heatmap at distance " + lookup[0]->getLabel() + "\n"; //column labels - for (int h = 0; h < lookup.size(); h++) { - outsvg << "getGroup().length() / 2)) + "\" y=\"50\">" + lookup[h]->getGroup() + "\n"; + for (int h = 0; h < lookup.size()+1; h++) { + if (h == 0) { + string tempLabel = "OTU"; + outsvg << "" + tempLabel + "\n"; + }else { + outsvg << "getGroup().length() / 2)+labelBump/2) + "\" y=\"50\">" + lookup[h-1]->getGroup() + "\n"; + } } - - + //output legend and color labels - //go through map and give each score a color value string color; int x = 0; - int y = 90 + (lookup[0]->getNumBins()*5); - for (it = colorScale.begin(); it != colorScale.end(); it++) { - color = it->second; - outsvg << "\n"; - outsvg << "" + toString(it->first) + "\n"; - x += 25; - } + int y = 103 + (numBinsToDisplay*binHeight); + printLegend(y, superMaxRelAbund); - x = 0; y = 70; - - //start at 1 since bin 0 is nothing - for (int i = 1; i <= lookup[0]->getNumBins(); i++) { - for (int j = 0; j < lookup.size(); j++) { + for (int i = 0; i < numBinsToDisplay; i++) { + outsvg << "" + sortedLabels[i] + "\n"; + x += labelBump; + for (int j = 0; j < scaleRelAbund.size(); j++) { + if (m->control_pressed) { outsvg.close(); return "control"; } - //if (lookup[j]->getAbundance(i) != 0) { //don't want log value of 0. - //if (scaler == "log10") { - // color = colorScale[(int)log10(lookup[j]->getAbundance(i))]; - //}else if (scaler == "log2") { - // color = colorScale[(int)log2(lookup[j]->getAbundance(i))]; - // }else if (scaler == "linear") { - color = colorScale[lookup[j]->getAbundance(i)]; - //}else { color = colorScale[(int)log10(lookup[j]->getAbundance(i))]; } - //}else { color = "OO"; } - - - outsvg << "\n"; - x += 300; + outsvg << "\n"; + x += binWidth; } x = 0; - y += 5; + y += binHeight; } outsvg << "\n\n"; - outsvg.close(); - - + return filenamesvg; + } catch(exception& e) { - cout << "Standard Error: " << e.what() << " has occurred in the HeatMap class Function getPic. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; - exit(1); - } - catch(...) { - cout << "An unknown error has occurred in the HeatMap class function getPic. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; + m->errorOut(e, "HeatMap", "getPic"); exit(1); } } //********************************************************************************************************************** -void HeatMap::sortSharedVectors(){ +vector HeatMap::sortSharedVectors(vector& lookup){ try { - //copy lookup and then clear it to refill with sorted. - //loop though lookup and determine if they are shared - //if they are then insert in the front - //if not push to back - + vector looktemp; map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. map::iterator it; - int count; + + vector sortedLabels = m->currentSharedBinLabels; + + /****************** find order of otus **********************/ + if (sorted == "shared") { + place = orderShared(lookup); + }else if (sorted == "topotu") { + place = orderTopOtu(lookup); + }else if (sorted == "topgroup") { + place = orderTopGroup(lookup); + }else { m->mothurOut("Error: invalid sort option."); m->mothurOutEndLine(); return sortedLabels; } + + /******************* create copy of lookup *********************/ //create and initialize looktemp as a copy of lookup for (int i = 0; i < lookup.size(); i++) { SharedRAbundVector* temp = new SharedRAbundVector(lookup[i]->getNumBins()); @@ -226,64 +245,496 @@ void HeatMap::sortSharedVectors(){ } looktemp.push_back(temp); } + + /************************ fill lookup in order given by place *********************/ + //for each bin + for (int i = 0; i < looktemp[0]->size(); i++) { //place + //fill lookup // 2 -> 1 + for (int j = 0; j < looktemp.size(); j++) { // 3 -> 2 + int newAbund = looktemp[j]->getAbundance(i); // 1 -> 3 + lookup[j]->set(place[i], newAbund, looktemp[j]->getGroup()); //binNumber, abundance, group + } + sortedLabels[place[i]] = m->currentSharedBinLabels[i]; + } + + //delete looktemp -- Sarah look at - this is causing segmentation faults + for (int j = 0; j < looktemp.size(); j++) { +// delete looktemp[j]; + } + + return sortedLabels; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "sortSharedVectors"); + exit(1); + } +} +//********************************************************************************************************************** +map HeatMap::orderShared(vector& lookup){ + try { + + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; - //clear out lookup to create sorted lookup - lookup.clear(); + vector sharedBins; + vector uniqueBins; - //create and initialize lookup to empty vectors - for (int i = 0; i < looktemp.size(); i++) { - SharedRAbundVector* temp = new SharedRAbundVector(); - temp->setLabel(looktemp[i]->getLabel()); - temp->setGroup(looktemp[i]->getGroup()); - lookup.push_back(temp); + //for each bin + for (int i = 0; i < lookup[0]->size(); i++) { + int count = 0; + + //is this bin shared + for (int j = 0; j < lookup.size(); j++) { if (lookup[j]->getAbundance(i) != 0) { count++; } } - //initialize place map - place[i] = 0; + if (count < 2) { uniqueBins.push_back(i); } + else { sharedBins.push_back(i); } } + //fill place + for (int i = 0; i < sharedBins.size(); i++) { place[sharedBins[i]] = i; } + for (int i = 0; i < uniqueBins.size(); i++) { place[uniqueBins[i]] = (sharedBins.size() + i); } + + return place; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "orderShared"); + exit(1); + } +} +//********************************************************************************************************************** +map HeatMap::orderTopOtu(vector& lookup){ + try { + + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + vector totals; //for each bin - for (int i = 0; i < looktemp[0]->size(); i++) { - count = 0; - bool updatePlace = false; - //for each group - for (int j = 0; j < looktemp.size(); j++) { - if (looktemp[j]->getAbundance(i) != 0) { count++; } - } + for (int i = 0; i < lookup[0]->size(); i++) { + int total = 0; - //fill lookup - for (int j = 0; j < looktemp.size(); j++) { - //if they are not shared then push to back, if they are not insert in front - if (count < 2) { lookup[j]->push_back(looktemp[j]->getAbundance(i), i, looktemp[j]->getGroup()); } - //they are shared by some - else { lookup[j]->insert(looktemp[j]->getAbundance(i), place[count], looktemp[j]->getGroup()); updatePlace = true; } - } + for (int j = 0; j < lookup.size(); j++) { total += lookup[j]->getAbundance(i); } - if (updatePlace == true) { - //move place holders below where you entered up to "make space" for you entry - for (it = place.begin(); it!= place.end(); it++) { - if (it->first < count) { it->second++; } + binCount temp(i, total); + + totals.push_back(temp); + } + + sort(totals.begin(), totals.end(), comparebinCounts); + + //fill place + for (int i = 0; i < totals.size(); i++) { place[totals[i].bin] = i; } + + return place; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "orderTopOtu"); + exit(1); + } +} +//********************************************************************************************************************** +map HeatMap::orderTopGroup(vector& lookup){ + try { + + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + vector < vector > totals; //totals[0] = bin totals for group 0, totals[1] = bin totals for group 1, ... + totals.resize(lookup.size()); + + //for each bin + for (int i = 0; i < lookup[0]->size(); i++) { + for (int j = 0; j < lookup.size(); j++) { + binCount temp(i, (lookup[j]->getAbundance(i))); + totals[j].push_back(temp); + } + } + + for (int i = 0; i < totals.size(); i++) { sort(totals[i].begin(), totals[i].end(), comparebinCounts); } + + //fill place + //grab the top otu for each group adding it if its not already added + int count = 0; + for (int i = 0; i < totals[0].size(); i++) { + + for (int j = 0; j < totals.size(); j++) { + it = place.find(totals[j][i].bin); + + if (it == place.end()) { //not added yet + place[totals[j][i].bin] = count; + count++; } } } + + return place; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "orderTopGroup"); + exit(1); + } +} +//********************************************************************************************************************** + +void HeatMap::printLegend(int y, float maxbin) { + try { + + //output legend and color labels + //go through map and give each score a color value + string color; + int x = 10; + + //prints legend + for (int i = 1; i < 255; i++) { + color = toHex(int((float)(i))); + outsvg << "\n"; + x += 1; + } + + //prints legend labels + x = 10; + for (int i = 1; i<=5; i++) { + float label; + if(scaler== "log10") { label = maxbin * log10(51*i) / log10(255); } + else if(scaler== "log2") { label = maxbin * log2(51*i) / log2(255); } + else if(scaler== "linear") { label = maxbin * 51 * i / 255; } + else { label = maxbin * log10(51*i) / log10(255); } + label = int(label * 1000 + 0.5); + label /= 1000.0; + string text = toString(label, 3); + + outsvg << "" + text + "\n"; + x += 60; + } + } + + catch(exception& e) { + m->errorOut(e, "HeatMap", "printLegend"); + exit(1); + } +} +//********************************************************************************************************************** + +string HeatMap::getPic(vector lookup) { + try { + + int numBinsToDisplay = lookup[0]->size(); + + if (numOTU != 0) { //user want to display a portion of the otus + if (numOTU < numBinsToDisplay) { numBinsToDisplay = numOTU; } + } + + //sort lookup so shared bins are on top + vector sortedLabels = m->currentSharedBinLabels; + if (sorted != "none") { sortedLabels = sortSharedVectors(lookup); } - //delete looktemp + vector > scaleRelAbund; + vector maxRelAbund(lookup.size(), 0.0); + float superMaxRelAbund = 0; + + for(int i = 0; i < lookup.size(); i++){ + for(int j=0; jsize(); j++){ + + float relAbund = lookup[i]->getAbundance(j); + if(relAbund > maxRelAbund[i]){ maxRelAbund[i] = relAbund; } + } + if(maxRelAbund[i] > superMaxRelAbund){ superMaxRelAbund = maxRelAbund[i]; } + } + + scaleRelAbund.resize(lookup.size()); + for(int i=0;icontrol_pressed) { return "control"; } + float relAbund = lookup[i]->getAbundance(j); + + if (lookup[i]->getAbundance(j) != 0) { //don't want log value of 0. + if (scaler == "log10") { + scaleRelAbund[i][j] = toHex(int(255 * log10(relAbund) / log10(maxRelAbund[i]))) + "0000"; + }else if (scaler == "log2") { + scaleRelAbund[i][j] = toHex(int(255 * log2(relAbund) / log2(maxRelAbund[i]))) + "0000"; + }else if (scaler == "linear") { + scaleRelAbund[i][j] = toHex(int(255 * relAbund / maxRelAbund[i])) + "0000"; + }else { //if user enters invalid scaler option. + scaleRelAbund[i][j] = toHex(int(255 * log10(relAbund / log10(maxRelAbund[i])))) + "0000"; + } + }else { scaleRelAbund[i][j] = "FFFFFF"; } + + } + } + + string filenamesvg = outputDir + m->getRootName(m->getSimpleName(inputfile)) + lookup[0]->getLabel() + ".heatmap.bin.svg"; + m->openOutputFile(filenamesvg, outsvg); + + int binHeight = 20; + int labelBump = 100; + int binWidth = 300; + + //svg image + outsvg << "\n"; + outsvg << "\n"; + + //white backround + outsvg << ""; + outsvg << "Heatmap at distance " + lookup[0]->getLabel() + "\n"; + + //column labels + for (int h = 0; h < lookup.size()+1; h++) { + if (h == 0) { + string tempLabel = "OTU"; + outsvg << "" + tempLabel + "\n"; + }else { + outsvg << "getGroup().length() / 2)+labelBump/2) + "\" y=\"50\">" + lookup[h-1]->getGroup() + "\n"; + } + } + + //output legend and color labels + string color; + int x = 0; + int y = 103 + (numBinsToDisplay*binHeight); + printLegend(y, superMaxRelAbund); + + y = 70; + for (int i = 0; i < numBinsToDisplay; i++) { + outsvg << "" + sortedLabels[i] + "\n"; + x += labelBump; + for (int j = 0; j < scaleRelAbund.size(); j++) { + if (m->control_pressed) { outsvg.close(); return "control"; } + + outsvg << "\n"; + x += binWidth; + } + x = 0; + y += binHeight; + } + + outsvg << "\n\n"; + outsvg.close(); + + return filenamesvg; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "getPic"); + exit(1); + } +} +//********************************************************************************************************************** +vector HeatMap::sortSharedVectors(vector& lookup){ + try { + + vector looktemp; + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + vector sortedLabels = m->currentSharedBinLabels; + + /****************** find order of otus **********************/ + if (sorted == "shared") { + place = orderShared(lookup); + }else if (sorted == "topotu") { + place = orderTopOtu(lookup); + }else if (sorted == "topgroup") { + place = orderTopGroup(lookup); + }else { m->mothurOut("Error: invalid sort option."); m->mothurOutEndLine(); return sortedLabels; } + + + /******************* create copy of lookup *********************/ + //create and initialize looktemp as a copy of lookup + for (int i = 0; i < lookup.size(); i++) { + SharedRAbundFloatVector* temp = new SharedRAbundFloatVector(lookup[i]->getNumBins()); + temp->setLabel(lookup[i]->getLabel()); + temp->setGroup(lookup[i]->getGroup()); + //copy lookup i's info + for (int j = 0; j < lookup[i]->size(); j++) { + temp->set(j, lookup[i]->getAbundance(j), lookup[i]->getGroup()); + } + looktemp.push_back(temp); + } + + /************************ fill lookup in order given by place *********************/ + //for each bin + for (int i = 0; i < looktemp[0]->size(); i++) { //place + //fill lookup // 2 -> 1 + for (int j = 0; j < looktemp.size(); j++) { // 3 -> 2 + float newAbund = looktemp[j]->getAbundance(i); // 1 -> 3 + lookup[j]->set(place[i], newAbund, looktemp[j]->getGroup()); //binNumber, abundance, group + sortedLabels[place[i]] = m->currentSharedBinLabels[i]; + } + } + + //delete looktemp -- Sarah look at - this is causing segmentation faults for (int j = 0; j < looktemp.size(); j++) { - delete looktemp[j]; +// delete looktemp[j]; } + return sortedLabels; + } catch(exception& e) { - cout << "Standard Error: " << e.what() << " has occurred in the HeatMap class Function sortSharedVectors. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; + m->errorOut(e, "HeatMap", "sortSharedVectors"); exit(1); } - catch(...) { - cout << "An unknown error has occurred in the HeatMap class function sortSharedVectors. Please contact Pat Schloss at pschloss@microbio.umass.edu." << "\n"; +} +//********************************************************************************************************************** +int HeatMap::sortRabund(RAbundVector*& r){ + try { + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + /****************** find order of otus **********************/ + vector totals; + + //for each bin + for (int i = 0; i < r->getNumBins(); i++) { + binCount temp(i, r->get(i)); + + totals.push_back(temp); + } + + sort(totals.begin(), totals.end(), comparebinCounts); + + //fill place + for (int i = 0; i < totals.size(); i++) { place[totals[i].bin] = i; } + + /******************* create copy of lookup *********************/ + //create and initialize rtemp as a copy of r + + RAbundVector* rtemp = new RAbundVector(r->getNumBins()); + for (int i = 0; i < r->size(); i++) { rtemp->set(i, r->get(i)); } + rtemp->setLabel(r->getLabel()); + + /************************ fill lookup in order given by place *********************/ + //for each bin + for (int i = 0; i < rtemp->size(); i++) { //place + //fill lookup // 2 -> 1 + // 3 -> 2 + int newAbund = rtemp->get(i); // 1 -> 3 + r->set(place[i], newAbund); //binNumber, abundance + } + + return 0; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "sortRabund"); + exit(1); + } +} +//********************************************************************************************************************** +map HeatMap::orderShared(vector& lookup){ + try { + + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + vector sharedBins; + vector uniqueBins; + + //for each bin + for (int i = 0; i < lookup[0]->size(); i++) { + int count = 0; + + //is this bin shared + for (int j = 0; j < lookup.size(); j++) { if (lookup[j]->getAbundance(i) != 0) { count++; } } + + if (count < 2) { uniqueBins.push_back(i); } + else { sharedBins.push_back(i); } + } + + //fill place + for (int i = 0; i < sharedBins.size(); i++) { place[sharedBins[i]] = i; } + for (int i = 0; i < uniqueBins.size(); i++) { place[uniqueBins[i]] = (sharedBins.size() + i); } + + return place; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "orderShared"); + exit(1); + } +} +//********************************************************************************************************************** +map HeatMap::orderTopOtu(vector& lookup){ + try { + + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + vector totals; + + //for each bin + for (int i = 0; i < lookup[0]->size(); i++) { + int total = 0; + + for (int j = 0; j < lookup.size(); j++) { total += lookup[j]->getAbundance(i); } + + binCountFloat temp(i, total); + + totals.push_back(temp); + } + + sort(totals.begin(), totals.end(), comparebinFloatCounts); + + //fill place + for (int i = 0; i < totals.size(); i++) { place[totals[i].bin] = i; } + + return place; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "orderTopOtu"); + exit(1); + } +} +//********************************************************************************************************************** +map HeatMap::orderTopGroup(vector& lookup){ + try { + + map place; //spot in lookup where you insert shared by, ie, 3 -> 2 if they are shared by 3 inset into location 2. + map::iterator it; + + vector < vector > totals; //totals[0] = bin totals for group 0, totals[1] = bin totals for group 1, ... + totals.resize(lookup.size()); + + //for each bin + for (int i = 0; i < lookup[0]->size(); i++) { + for (int j = 0; j < lookup.size(); j++) { + binCountFloat temp(i, (lookup[j]->getAbundance(i))); + totals[j].push_back(temp); + } + } + + for (int i = 0; i < totals.size(); i++) { sort(totals[i].begin(), totals[i].end(), comparebinFloatCounts); } + + //fill place + //grab the top otu for each group adding it if its not already added + int count = 0; + for (int i = 0; i < totals[0].size(); i++) { + + for (int j = 0; j < totals.size(); j++) { + it = place.find(totals[j][i].bin); + + if (it == place.end()) { //not added yet + place[totals[j][i].bin] = count; + count++; + } + } + } + + return place; + + } + catch(exception& e) { + m->errorOut(e, "HeatMap", "orderTopGroup"); exit(1); } - } - //**********************************************************************************************************************