extract_stats_images.cpp 9.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <sstream>
  4. #include <iostream>
  5. #include <fstream>
  6. #include <vector>
  7. #include <tuple>
  8. #include <cmath>
  9. #include <numeric>
  10. #include <map>
  11. #include <algorithm>
  12. #include <filesystem>
  13. #include "rawls.h"
  14. struct Point {
  15. unsigned x;
  16. unsigned y;
  17. };
  18. struct Tile {
  19. Point p1;
  20. Point p2;
  21. };
  22. void writeProgress(float progress, bool moveUp = false){
  23. int barWidth = 150;
  24. if (moveUp){
  25. // move up line
  26. std::cout << "\e[A";
  27. std::cout.flush();
  28. }
  29. std::cout << "[";
  30. int pos = barWidth * progress;
  31. for (int i = 0; i < barWidth; ++i) {
  32. if (i < pos) std::cout << "=";
  33. else if (i == pos) std::cout << ">";
  34. else std::cout << " ";
  35. }
  36. std::cout << "] " << int(progress * 100.0) << " %\r";
  37. std::cout.flush();
  38. }
  39. float getEstimator(std::string estimator, std::vector<float> values) {
  40. if (estimator == "median") {
  41. std::sort(values.begin(), values.end());
  42. unsigned size = values.size();
  43. if (size % 2 == 0)
  44. {
  45. return (values[size / 2 - 1] + values[size / 2]) / 2;
  46. }
  47. else
  48. {
  49. return values[size / 2];
  50. }
  51. } else if (estimator == "mean") {
  52. return std::accumulate(values.begin(), values.end(), 0.0) / values.size();
  53. } else if (estimator == "var") {
  54. // Calculate the mean
  55. const float mean = std::accumulate(values.begin(), values.end(), 0.0) / values.size();
  56. // Now calculate the variance
  57. auto variance_func = [&mean](float accumulator, const float& val) {
  58. return accumulator + pow(val - mean, 2);
  59. };
  60. return std::accumulate(values.begin(), values.end(), 0.0, variance_func) / values.size();
  61. } else if (estimator == "std") {
  62. return sqrt(getEstimator("var", values));
  63. } else if (estimator == "skewness") {
  64. unsigned size = values.size();
  65. float mean = getEstimator("mean", values);
  66. float std = getEstimator("std", values);
  67. // Now calculate the sum of pow 3
  68. auto order3_func = [&mean, &std](float accumulator, const float& val) {
  69. return accumulator + pow((val - mean) / std, 3);
  70. };
  71. float order3 = std::accumulate(values.begin(), values.end(), 0.0, order3_func);
  72. return order3 / size;
  73. } else if (estimator == "kurtosis") {
  74. unsigned size = values.size();
  75. float mean = getEstimator("mean", values);
  76. float std = getEstimator("std", values);
  77. // Now calculate the sum of pow 4
  78. auto order4_func = [&mean, &std](float accumulator, const float& val) {
  79. return accumulator + pow((val - mean) / std, 4);
  80. };
  81. float order4 = std::accumulate(values.begin(), values.end(), 0.0, order4_func);
  82. return order4 / size;
  83. } else if (estimator == "mode") {
  84. std::vector<float> pvalues;
  85. for (unsigned i = 0; i < values.size(); i++){
  86. pvalues.push_back(roundf(values.at(i) * 100) / 100.0);
  87. }
  88. typedef std::map<float,unsigned int> CounterMap;
  89. CounterMap counts;
  90. for (int i = 0; i < pvalues.size(); ++i)
  91. {
  92. CounterMap::iterator it(counts.find(pvalues[i]));
  93. if (it != counts.end()){
  94. it->second++;
  95. } else {
  96. counts[pvalues[i]] = 1;
  97. }
  98. }
  99. // Create a map iterator and point to beginning of map
  100. std::map<float, unsigned int>::iterator it = counts.begin();
  101. unsigned noccurences = 0;
  102. float modeValue = 0.;
  103. // Iterate over the map using Iterator till end.
  104. while (it != counts.end())
  105. {
  106. // Accessing KEY from element pointed by it.
  107. float potentialMode = it->first;
  108. // Accessing VALUE from element pointed by it.
  109. unsigned count = it->second;
  110. if (count > noccurences) {
  111. noccurences = count;
  112. modeValue = potentialMode;
  113. }
  114. // Increment the Iterator to point to next entry
  115. it++;
  116. }
  117. return modeValue;
  118. }
  119. // by default
  120. return 0.;
  121. }
  122. int main(int argc, char *argv[]){
  123. std::string folderName;
  124. std::string estimator;
  125. unsigned blockHeight;
  126. unsigned blockWidth;
  127. std::string outfileName;
  128. for (int i = 1; i < argc; ++i) {
  129. if (!strcmp(argv[i], "--folder") || !strcmp(argv[i], "-folder")) {
  130. folderName = argv[++i];
  131. } else if (!strcmp(argv[i], "--estimator") || !strcmp(argv[i], "-estimator")) {
  132. estimator = argv[++i];
  133. } else if (!strcmp(argv[i], "--bwidth") || !strcmp(argv[i], "-bwidth")) {
  134. blockHeight = atoi(argv[++i]);
  135. } else if (!strcmp(argv[i], "--bheight") || !strcmp(argv[i], "-bheight")) {
  136. blockWidth = atoi(argv[++i]);
  137. } else if (!strcmp(argv[i], "--outfile") || !strcmp(argv[i], "-outfile")) {
  138. outfileName = argv[++i];
  139. }
  140. }
  141. std::vector<std::string> imagesPath;
  142. for (const auto & entry : std::filesystem::directory_iterator(folderName)){
  143. std::string imageName = entry.path().string();
  144. if (rawls::HasExtension(imageName, ".rawls") || rawls::HasExtension(imageName, ".rawls_20")){
  145. imagesPath.push_back(imageName);
  146. }
  147. }
  148. std::sort(imagesPath.begin(), imagesPath.end());
  149. std::tuple<unsigned, unsigned, unsigned> data = rawls::getDimensionsRAWLS(imagesPath.at(0));
  150. unsigned outputWidth = std::get<0>(data);
  151. unsigned outputHeight = std::get<1>(data);
  152. unsigned nbChanels = std::get<2>(data);
  153. // new buffer size as new output buffer image (default 3 channels)
  154. float* outputBuffer = new float[outputHeight * outputWidth * nbChanels];
  155. // get all tiles to apply
  156. unsigned nWidth = ceil(outputWidth / (float)blockWidth);
  157. unsigned nHeight = ceil(outputHeight / (float)blockHeight);
  158. std::vector<Tile> tiles;
  159. for (unsigned i = 0; i < nWidth; i++) {
  160. for (unsigned j = 0; j < nHeight; j++) {
  161. unsigned x1 = i * blockWidth;
  162. unsigned y1 = j * blockHeight;
  163. unsigned x2 = i * blockWidth + blockWidth;
  164. unsigned y2 = j * blockHeight + blockHeight;
  165. x2 = x2 > outputWidth ? outputWidth: x2;
  166. y2 = y2 > outputHeight ? outputHeight: y2;
  167. Point p1 = {x1, y1};
  168. Point p2 = {x2, y2};
  169. Tile tile = {p1, p2};
  170. tiles.push_back(tile);
  171. }
  172. }
  173. unsigned nsamples = imagesPath.size();
  174. unsigned nloop = tiles.size() * nsamples;
  175. unsigned nloopCounter = 0;
  176. for (unsigned t_index = 0; t_index < tiles.size(); t_index++){
  177. Tile tile = tiles.at(t_index);
  178. //std::cout << "Tile: (" << tile.p1.x << ", " << tile.p1.y << ")" << " => " << "(" << tile.p2.x << ", " << tile.p2.y << ")" << std::endl;
  179. unsigned nvalues = (tile.p2.x - tile.p1.x) * (tile.p2.y - tile.p1.y) * 3;
  180. std::vector<std::vector<float>> rgbValues(nvalues);
  181. for (unsigned i = 0; i < nsamples; i++) {
  182. try {
  183. float* RGBpixels = rawls::getPixelsRAWLS(imagesPath.at(i));
  184. unsigned index = 0;
  185. for (int y = tile.p1.y; y < tile.p2.y; ++y) {
  186. for (int x = tile.p1.x; x < tile.p2.x; ++x) {
  187. rgbValues.at(index).push_back(RGBpixels[3 * (y * outputWidth + x) + 0]);
  188. rgbValues.at(index + 1).push_back(RGBpixels[3 * (y * outputWidth + x) + 1]);
  189. rgbValues.at(index + 2).push_back(RGBpixels[3 * (y * outputWidth + x) + 2]);
  190. index += 3;
  191. }
  192. }
  193. delete RGBpixels;
  194. } catch(std::exception& e){
  195. std::cout << "Error occurs when reading file" << std::endl;
  196. }
  197. // display progress
  198. nloopCounter += 1;
  199. writeProgress(nloopCounter / (float)nloop);
  200. }
  201. // extract stat and add predicted value into output buffer
  202. unsigned index = 0;
  203. for (int y = tile.p1.y; y < tile.p2.y; ++y) {
  204. for (int x = tile.p1.x; x < tile.p2.x; ++x) {
  205. outputBuffer[3 * (y * outputWidth + x) + 0] = getEstimator(estimator, rgbValues.at(index + 0));
  206. outputBuffer[3 * (y * outputWidth + x) + 1] = getEstimator(estimator, rgbValues.at(index + 1));
  207. outputBuffer[3 * (y * outputWidth + x) + 2] = getEstimator(estimator, rgbValues.at(index + 2));
  208. index += 3;
  209. }
  210. }
  211. }
  212. // Save here new rawls image
  213. std::string comments = rawls::getCommentsRAWLS(imagesPath.at(0));
  214. bool success = rawls::saveAsRAWLS(outputWidth, outputHeight, nbChanels, comments, outputBuffer, outfileName);
  215. if (success) {
  216. std::cout << "New image saved into " << outfileName << std::endl;
  217. }
  218. else
  219. {
  220. std::cout << "Error while saving current image " << outfileName << std::endl;
  221. }
  222. delete outputBuffer;
  223. }