This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| //-----------------------------Gray level histogram computation ------------------------------------ | |
| void utility::ComputeHistogramGrey(image& src, image& tgt, ROI roi) | |
| { | |
| int histogram_1[256] = { 0 }; | |
| int histogram_2[256] = { 0 }; | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j)] = histogram_1[src.getPixel(i, j)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j)] = histogram_2[src.getPixel(i, j)] + 1; | |
| } | |
| } | |
| } | |
| int max = histogram_1[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_1[i] > max) | |
| max = histogram_1[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_1[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1.pgm"); | |
| max = histogram_2[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_2[i] > max) | |
| max = histogram_2[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_2[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2.pgm"); | |
| } | |
| //----------------------Gray level histogram equalisation------------------- | |
| void utility::EqualizeHistogramGrey(image& src, image& tgt, ROI roi) | |
| { | |
| int histogram_1[256] = { 0 }; | |
| int histogram_2[256] = { 0 }; | |
| int histogram_1_cdf[256] = { 0 }; | |
| int histogram_2_cdf[256] = { 0 }; | |
| tgt.resize(src.getNumberOfRows(), src.getNumberOfColumns()); | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j)] = histogram_1[src.getPixel(i, j)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j)] = histogram_2[src.getPixel(i, j)] + 1; | |
| } | |
| } | |
| } | |
| int sum1 = 0, sum2 = 0; | |
| for (int i = 0; i < 256; i++) { | |
| sum1 = sum1 + histogram_1[i]; | |
| sum2 = sum2 + histogram_2[i]; | |
| histogram_1_cdf[i] = sum1; | |
| histogram_2_cdf[i] = sum2; | |
| } | |
| int min_1 = histogram_1_cdf[0]; | |
| int min_2 = histogram_2_cdf[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_1_cdf[i] < min_1) | |
| min_1 = histogram_1_cdf[i]; | |
| if (histogram_2_cdf[i] < min_2) | |
| min_2 = histogram_2_cdf[i]; | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| int m_n = roi.M_N(0); | |
| double h = ((double)(histogram_1_cdf[src.getPixel(i, j)] - min_1) / (double)(m_n - min_1)) * 255; | |
| tgt.setPixel(i, j, (int)h); | |
| } | |
| else { | |
| int m_n = roi.M_N(1); | |
| double h = ((double)(histogram_2_cdf[src.getPixel(i, j)] - min_2) / (double)(m_n - min_2)) * 255; | |
| tgt.setPixel(i, j, (int)h); | |
| } | |
| } | |
| else | |
| tgt.setPixel(i, j, src.getPixel(i, j)); | |
| } | |
| } | |
| //---------------Color histogram computation for RGB----------------------- | |
| void utility::ComputeHistogramColor(image& src, image& tgt, ROI roi) | |
| { | |
| int histogram_1[256] = { 0 }; | |
| int histogram_2[256] = { 0 }; | |
| int histogram_3[256] = { 0 }; | |
| int histogram_4[256] = { 0 }; | |
| int histogram_5[256] = { 0 }; | |
| int histogram_6[256] = { 0 }; | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j, RED)] = histogram_1[src.getPixel(i, j, RED)] + 1; | |
| histogram_3[src.getPixel(i, j, GREEN)] = histogram_3[src.getPixel(i, j, GREEN)] + 1; | |
| histogram_5[src.getPixel(i, j, BLUE)] = histogram_5[src.getPixel(i, j, BLUE)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j, RED)] = histogram_2[src.getPixel(i, j, RED)] + 1; | |
| histogram_4[src.getPixel(i, j, GREEN)] = histogram_4[src.getPixel(i, j, GREEN)] + 1; | |
| histogram_6[src.getPixel(i, j, BLUE)] = histogram_6[src.getPixel(i, j, BLUE)] + 1; | |
| } | |
| } | |
| } | |
| int max = histogram_1[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_1[i] > max) | |
| max = histogram_1[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_1[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1_RED.pgm"); | |
| max = histogram_3[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_3[i] > max) | |
| max = histogram_3[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_3[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1_GREEN.pgm"); | |
| max = histogram_5[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_5[i] > max) | |
| max = histogram_5[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_5[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1_BLUE.pgm"); | |
| max = histogram_2[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_2[i] > max) | |
| max = histogram_2[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_2[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2_RED.pgm"); | |
| max = histogram_4[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_4[i] > max) | |
| max = histogram_4[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_4[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2_GREEN.pgm"); | |
| max = histogram_6[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_6[i] > max) | |
| max = histogram_6[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_6[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2_BLUE.pgm"); | |
| } | |
| /*--------------Histogram Equalization for color images ---------------*/ | |
| void utility::EqualizeHistogramColor(image& src, image& tgt, ROI roi) | |
| { | |
| for (int c = 0; c < 3; c++) { | |
| int histogram_1[256] = { 0 }; | |
| int histogram_2[256] = { 0 }; | |
| int histogram_1_cdf[256] = { 0 }; | |
| int histogram_2_cdf[256] = { 0 }; | |
| tgt.resize(src.getNumberOfRows(), src.getNumberOfColumns()); | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j, c)] = histogram_1[src.getPixel(i, j, c)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j, c)] = histogram_2[src.getPixel(i, j, c)] + 1; | |
| } | |
| } | |
| } | |
| int sum1 = 0, sum2 = 0; | |
| for (int i = 0; i < 256; i++) { | |
| sum1 = sum1 + histogram_1[i]; | |
| sum2 = sum2 + histogram_2[i]; | |
| histogram_1_cdf[i] = sum1; | |
| histogram_2_cdf[i] = sum2; | |
| } | |
| int min_1 = histogram_1_cdf[0]; | |
| int min_2 = histogram_2_cdf[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_1_cdf[i] < min_1) | |
| min_1 = histogram_1_cdf[i]; | |
| if (histogram_2_cdf[i] < min_2) | |
| min_2 = histogram_2_cdf[i]; | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| tgt.setPixel(i, j, RED, src.getPixel(i, j, RED)); | |
| tgt.setPixel(i, j, GREEN, src.getPixel(i, j, GREEN)); | |
| tgt.setPixel(i, j, BLUE, src.getPixel(i, j, BLUE)); | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| int m_n = roi.M_N(0); | |
| double h = ((double)(histogram_1_cdf[src.getPixel(i, j, c)] - min_1) / (double)(m_n - min_1)) * 255; | |
| tgt.setPixel(i, j, c, (int)h); | |
| } | |
| else { | |
| int m_n = roi.M_N(1); | |
| double h = ((double)(histogram_2_cdf[src.getPixel(i, j, c)] - min_2) / (double)(m_n - min_2)) * 255; | |
| tgt.setPixel(i, j, c, (int)h); | |
| } | |
| } | |
| } | |
| if (c == 0) | |
| tgt.save("histogram_Normalized_RED.ppm"); | |
| else if (c == 1) | |
| tgt.save("histogram_Normalized_GREEN.ppm"); | |
| else | |
| tgt.save("histogram_Normalized_BLUE.ppm"); | |
| } | |
| } | |
| /*--------Histogram equalization for RGB channels together ---------------------*/ | |
| void utility::EqualizeHistogramColorAll(image& src, image& tgt, ROI roi) | |
| { | |
| tgt.resize(src.getNumberOfRows(), src.getNumberOfColumns()); | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| tgt.setPixel(i, j, RED, src.getPixel(i, j, RED)); | |
| tgt.setPixel(i, j, GREEN, src.getPixel(i, j, GREEN)); | |
| tgt.setPixel(i, j, BLUE, src.getPixel(i, j, BLUE)); | |
| } | |
| for (int c = 0; c < 3; c++) { | |
| int histogram_1[256] = { 0 }; | |
| int histogram_2[256] = { 0 }; | |
| int histogram_1_cdf[256] = { 0 }; | |
| int histogram_2_cdf[256] = { 0 }; | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j, c)] = histogram_1[src.getPixel(i, j, c)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j, c)] = histogram_2[src.getPixel(i, j, c)] + 1; | |
| } | |
| } | |
| } | |
| int sum1 = 0, sum2 = 0; | |
| for (int i = 0; i < 256; i++) { | |
| sum1 = sum1 + histogram_1[i]; | |
| sum2 = sum2 + histogram_2[i]; | |
| histogram_1_cdf[i] = sum1; | |
| histogram_2_cdf[i] = sum2; | |
| } | |
| int min_1 = histogram_1_cdf[0]; | |
| int min_2 = histogram_2_cdf[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_1_cdf[i] < min_1) | |
| min_1 = histogram_1_cdf[i]; | |
| if (histogram_2_cdf[i] < min_2) | |
| min_2 = histogram_2_cdf[i]; | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| int m_n = roi.M_N(0); | |
| double h = ((double)(histogram_1_cdf[src.getPixel(i, j, c)] - min_1) / (double)(m_n - min_1)) * 255; | |
| tgt.setPixel(i, j, c, (int)h); | |
| } | |
| else { | |
| int m_n = roi.M_N(1); | |
| double h = ((double)(histogram_2_cdf[src.getPixel(i, j, c)] - min_2) / (double)(m_n - min_2)) * 255; | |
| tgt.setPixel(i, j, c, (int)h); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /* HSI histogram generation ----------------------------------------*/ | |
| void utility::ComputeHistogramHSI(image& src, image& tgt, ROI roi) | |
| { | |
| int histogram_1[360] = { 0 }; //Hue | |
| int histogram_2[360] = { 0 }; | |
| int histogram_3[100] = { 0 }; //Saturation | |
| int histogram_4[100] = { 0 }; | |
| int histogram_5[256] = { 0 }; //Intensity | |
| int histogram_6[256] = { 0 }; | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| double* HSI = RGB_HSI((double)src.getPixel(i, j, RED), (double)src.getPixel(i, j, GREEN), (double)src.getPixel(i, j, BLUE)); | |
| src.setPixel(i, j, RED, (int)HSI[0]); //Hue | |
| src.setPixel(i, j, GREEN, (int)(HSI[1])); //Saturation | |
| src.setPixel(i, j, BLUE, (int)(HSI[2])); //Intensity | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j, RED)] = histogram_1[src.getPixel(i, j, RED)] + 1; | |
| histogram_3[src.getPixel(i, j, GREEN)] = histogram_3[src.getPixel(i, j, GREEN)] + 1; | |
| histogram_5[src.getPixel(i, j, BLUE)] = histogram_5[src.getPixel(i, j, BLUE)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j, RED)] = histogram_2[src.getPixel(i, j, RED)] + 1; | |
| histogram_4[src.getPixel(i, j, GREEN)] = histogram_4[src.getPixel(i, j, GREEN)] + 1; | |
| histogram_6[src.getPixel(i, j, BLUE)] = histogram_6[src.getPixel(i, j, BLUE)] + 1; | |
| } | |
| } | |
| } | |
| int max = histogram_1[0]; | |
| for (int i = 1; i < 360; i++) { | |
| if (histogram_1[i] > max) | |
| max = histogram_1[i]; | |
| } | |
| tgt.resize(360, 360); | |
| for (int i = 0; i < 360; i++) | |
| for (int j = 0; j < 360; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 360; i++) { | |
| int j = (int)(((double)histogram_1[i] / (double)max) * 360); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1_HUE.pgm"); | |
| max = histogram_3[0]; | |
| for (int i = 1; i < 100; i++) { | |
| if (histogram_3[i] > max) | |
| max = histogram_3[i]; | |
| } | |
| tgt.resize(100, 100); | |
| for (int i = 0; i < 100; i++) | |
| for (int j = 0; j < 100; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 100; i++) { | |
| int j = (int)(((double)histogram_3[i] / (double)max) * 100); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1_SATURATION.pgm"); | |
| max = histogram_5[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_5[i] > max) | |
| max = histogram_5[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_5[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_1_INTENSITY.pgm"); | |
| max = histogram_2[0]; | |
| for (int i = 1; i < 360; i++) { | |
| if (histogram_2[i] > max) | |
| max = histogram_2[i]; | |
| } | |
| tgt.resize(360, 360); | |
| for (int i = 0; i < 360; i++) | |
| for (int j = 0; j < 360; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 360; i++) { | |
| int j = (int)(((double)histogram_2[i] / (double)max) * 360); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2_HUE.pgm"); | |
| max = histogram_4[0]; | |
| for (int i = 1; i < 100; i++) { | |
| if (histogram_4[i] > max) | |
| max = histogram_4[i]; | |
| } | |
| tgt.resize(100, 100); | |
| for (int i = 0; i < 100; i++) | |
| for (int j = 0; j < 100; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 100; i++) { | |
| int j = (int)(((double)histogram_4[i] / (double)max) * 100); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2_SATURATION.pgm"); | |
| max = histogram_6[0]; | |
| for (int i = 1; i < 256; i++) { | |
| if (histogram_6[i] > max) | |
| max = histogram_6[i]; | |
| } | |
| tgt.resize(256, 256); | |
| for (int i = 0; i < 256; i++) | |
| for (int j = 0; j < 256; j++) | |
| tgt.setPixel(i, j, 255); | |
| for (int i = 0; i < 256; i++) { | |
| int j = (int)(((double)histogram_6[i] / (double)max) * 256); | |
| for (int k = j; k >= 0; k--) | |
| tgt.setPixel(i, k, 0); | |
| } | |
| tgt.save("histogram_roi_2_INTENSITY.pgm"); | |
| } | |
| /*------- HSI histogram equalization ---------------------------------------------*/ | |
| void utility::EqualizeHistogramHSI(image& src, image& tgt, ROI roi) | |
| { | |
| tgt.resize(src.getNumberOfRows(), src.getNumberOfColumns()); | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| double* HSI = RGB_HSI((double)src.getPixel(i, j, RED), (double)src.getPixel(i, j, GREEN), (double)src.getPixel(i, j, BLUE)); | |
| src.setPixel(i, j, RED, (int)HSI[0]); //Hue | |
| src.setPixel(i, j, GREEN, (int)HSI[1]); //Saturation | |
| src.setPixel(i, j, BLUE, (int)HSI[2]); //Intensity | |
| } | |
| int size = 0; | |
| for (int c = 0; c < 3; c++) { | |
| if (c == 0) | |
| size = 360; | |
| if (c == 1) | |
| size = 100; | |
| else | |
| size = 256; | |
| int* histogram_1 = new int[size]; | |
| int* histogram_2 = new int[size]; | |
| int* histogram_1_cdf = new int[size]; | |
| int* histogram_2_cdf = new int[size]; | |
| for (int i = 0; i < size; i++) { | |
| histogram_1[i] = 0; | |
| histogram_2[i] = 0; | |
| histogram_1_cdf[i] = 0; | |
| histogram_2_cdf[i] = 0; | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| histogram_1[src.getPixel(i, j, c)] = histogram_1[src.getPixel(i, j, c)] + 1; | |
| } | |
| else { | |
| histogram_2[src.getPixel(i, j, c)] = histogram_2[src.getPixel(i, j, c)] + 1; | |
| } | |
| } | |
| } | |
| int sum1 = 0, sum2 = 0; | |
| for (int i = 0; i < size; i++) { | |
| sum1 = sum1 + histogram_1[i]; | |
| sum2 = sum2 + histogram_2[i]; | |
| histogram_1_cdf[i] = sum1; | |
| histogram_2_cdf[i] = sum2; | |
| } | |
| int min_1 = histogram_1_cdf[0]; | |
| int min_2 = histogram_2_cdf[0]; | |
| for (int i = 1; i < size; i++) { | |
| if (histogram_1_cdf[i] < min_1) | |
| min_1 = histogram_1_cdf[i]; | |
| if (histogram_2_cdf[i] < min_2) | |
| min_2 = histogram_2_cdf[i]; | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| tgt.setPixel(i, j, RED, src.getPixel(i, j, RED)); | |
| tgt.setPixel(i, j, GREEN, src.getPixel(i, j, GREEN)); | |
| tgt.setPixel(i, j, BLUE, src.getPixel(i, j, BLUE)); | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| int value = roi.InROI(i, j); | |
| if (value != -1) { | |
| if (value == 0) { | |
| int m_n = roi.M_N(0); | |
| double h = ((double)(histogram_1_cdf[src.getPixel(i, j, c)] - min_1) / (double)(m_n - min_1)) * (size - 1); | |
| tgt.setPixel(i, j, c, (int)h); | |
| } | |
| else { | |
| int m_n = roi.M_N(1); | |
| double h = ((double)(histogram_2_cdf[src.getPixel(i, j, c)] - min_2) / (double)(m_n - min_2)) * (size - 1); | |
| tgt.setPixel(i, j, c, (int)h); | |
| } | |
| } | |
| } | |
| for (int i = 0; i < src.getNumberOfRows(); i++) | |
| for (int j = 0; j < src.getNumberOfColumns(); j++) { | |
| double* RGB = HSI_RGB((double)tgt.getPixel(i, j, RED), (double)tgt.getPixel(i, j, GREEN), (double)tgt.getPixel(i, j, BLUE)); | |
| tgt.setPixel(i, j, RED, (int)RGB[0]); //Hue | |
| tgt.setPixel(i, j, GREEN, (int)(RGB[1])); //Saturation | |
| tgt.setPixel(i, j, BLUE, (int)(RGB[2])); //Intensity | |
| } | |
| if (c == 0) | |
| tgt.save("histogram_Normalized_H.ppm"); | |
| else if (c == 1) | |
| tgt.save("histogram_Normalized_S.ppm"); | |
| else | |
| tgt.save("histogram_Normalized_I.ppm"); | |
| } | |
| } | |
| //---------------------RGB to HSI--------------------------- | |
| double* utility::RGB_HSI(double red, double green, double blue) | |
| { | |
| double H, S, I; | |
| double total = red + green + blue; | |
| red = red / total; | |
| green = green / total; | |
| blue = blue / total; | |
| double Min = red < green ? red : green; | |
| Min = Min < blue ? Min : blue; | |
| double root = sqrt(pow(red - green, 2) + ((red - blue) * (green - blue))); | |
| if (blue <= green) | |
| H = acos((((2.0 * red) - green - blue) * 0.5) / root); | |
| else | |
| H = (3.141592 * 2.0) - acos((((2.0 * red) - green - blue) * 0.5) / root); | |
| S = 1.0 - (3.0 * Min); | |
| I = total / 3.0; | |
| double* HSI = new double[3]; | |
| HSI[0] = H * (180.0 / 3.141592); | |
| HSI[1] = S * 100.0; | |
| HSI[2] = I; | |
| if (HSI[0] < 0) | |
| HSI[0] = 0; | |
| if (HSI[0] > 360) | |
| HSI[0] = 360.0; | |
| if (HSI[1] < 0) | |
| HSI[1] = 0; | |
| if (HSI[1] > 100) | |
| HSI[1] = 100.0; | |
| if (HSI[2] < 0) | |
| HSI[2] = 0; | |
| if (HSI[2] > 255) | |
| HSI[2] = 255.0; | |
| return HSI; | |
| } | |
| //---------------------HSI to RGB--------------------------- | |
| double* utility::HSI_RGB(double H, double S, double I) | |
| { | |
| double red = 0.0, green = 0.0, blue = 0.0; | |
| H = H * (3.141592 / 180.0); | |
| S = S / 100.0; | |
| I = I / 255.0; | |
| double x = I * (1 - S); | |
| double y = I * (1 + ((S * cos(H)) / cos((3.141592 / 3) - H))); | |
| double z = (3 * I) - (x + y); | |
| if (H < 2 * 3.141592 / 3) { | |
| red = y; | |
| green = z; | |
| blue = x; | |
| } | |
| else if ((2 * 3.141592 / 3 <= H) && (H < 4 * 3.141592 / 3)) { | |
| H = H - (2 * 3.141592 / 3); | |
| y = I * (1 + ((S * cos(H)) / cos((3.141592 / 3) - H))); | |
| z = (3 * I) - (x + y); | |
| red = x; | |
| green = y; | |
| blue = z; | |
| } | |
| else if ((4 * 3.141592 / 3 <= H) && (H < 2 * 3.141592)) { | |
| H = H - (4 * 3.141592 / 3); | |
| y = I * (1 + ((S * cos(H)) / cos((3.141592 / 3) - H))); | |
| z = 3 * I - (x + y); | |
| red = z; | |
| blue = y; | |
| green = x; | |
| } | |
| double* RGB = new double[3]; | |
| RGB[0] = red * 255.0; | |
| RGB[1] = green * 255.0; | |
| RGB[2] = blue * 255.0; | |
| if (RGB[0] < 0) | |
| RGB[0] = 0.0; | |
| if (RGB[0] > 255) | |
| RGB[0] = 255.0; | |
| if (RGB[1] < 0) | |
| RGB[1] = 0.0; | |
| if (RGB[1] > 255) | |
| RGB[1] = 255.0; | |
| if (RGB[2] < 0) | |
| RGB[2] = 0.0; | |
| if (RGB[2] > 255) | |
| RGB[2] = 255.0; | |
| return RGB; | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment