IsolateColor.H

00001 #ifndef ISOLATE_COLOR
00002 #define ISOLATE_COLOR
00003 
00004 #include "Image/Image.H"
00005 #include "Image/PixelsTypes.H"
00006 
00007 // #include "BeoSub/HoughTransform.H"
00008 
00009 // #define GREEN
00010 
00011 // int isolateBlack(const Image< PixRGB<byte> > &inputImage,  Image<byte> &outputImage) {
00012 //   int blackCount = 0;
00013 //   for(int j = 0; j < inputImage.getHeight(); j++ ) {
00014 //     for(int i = 0; i < inputImage.getWidth(); i++ )
00015 //       {
00016 
00017 //         /* float h1 = inputImage.getVal(i, j).H1();
00018 //            float h2 = inputImage.getVal(i, j).H2();
00019 //            float s = inputImage.getVal(i, j).S();
00020 //            float v = inputImage.getVal(i, j).V();*/
00021 
00022 
00023 //         float avgR = inputImage.getVal(i, j).red();
00024 //         float avgG = inputImage.getVal(i, j).green();
00025 //         float avgB = inputImage.getVal(i, j).blue();
00026 
00027 //         float avg = (avgR+avgG+avgB)/3.0;
00028 //         float sigma = pow(avgR - avg, 2.) + pow(avgG - avg, 2.) + pow(avgB - avg, 2.);
00029 //         float stdDev = sqrt( (1./3.) * sigma );
00030 
00031 
00032 //         if (avgG > avgR && avgG > avgB && stdDev > 15) {
00033 
00034 //           if (outputImage.coordsOk(i, j)) {
00035 
00036 //             blackCount++;
00037 //             outputImage.setVal(i, j, 255);
00038 //           }
00039 
00040 //         }
00041 //         else {
00042 //           if(outputImage.coordsOk(i,j)){
00043 //             outputImage.setVal(i, j, 0);
00044 
00045 //           }
00046 
00047 //         }
00048 
00049 //       }
00050 //   }
00051 //   //return blackCount;
00052 //   return (blackCount*100)/(inputImage.getHeight() * inputImage.getWidth());
00053 // }
00054 
00055 // int isolateGreen(const Image< PixRGB<byte> > &inputImage,  Image<byte> &outputImage) {
00056 //   int blackCount = 0;
00057 //   for(int j = 0; j < inputImage.getHeight(); j++ ) {
00058 //     for(int i = 0; i < inputImage.getWidth(); i++ )
00059 //       {
00060 
00061 //         /* float h1 = inputImage.getVal(i, j).H1();
00062 //            float h2 = inputImage.getVal(i, j).H2();
00063 //            float s = inputImage.getVal(i, j).S();*/
00064 //         float v = ((PixH2SV2 <float> )inputImage.getVal(i, j)).V();
00065 
00066 
00067 //         /*          float avgR = inputImage.getVal(i, j).red();
00068 //                     float avgG = inputImage.getVal(i, j).green();
00069 //                     float avgB = inputImage.getVal(i, j).blue();
00070 
00071 //                     float avg = (avgR+avgG+avgB)/3.0;
00072 //                     float sigma = pow(avgR - avg, 2.) + pow(avgG - avg, 2.) + pow(avgB - avg, 2.);
00073 //                     float stdDev = sqrt( (1./3.) * sigma );
00074 
00075 
00076 //                     if (avgG > avgR && avgG > avgB && stdDev > 15) {
00077 //         */
00078 //         if (v < 0.3) {
00079 //           if (outputImage.coordsOk(i, j)) {
00080 
00081 //             blackCount++;
00082 //             outputImage.setVal(i, j, 255);
00083 //           }
00084 
00085 //         }
00086 //         else {
00087 //           if(outputImage.coordsOk(i,j)){
00088 //             outputImage.setVal(i, j, 0);
00089 
00090 //           }
00091 
00092 //         }
00093 
00094 //       }
00095 //   }
00096 //   //return blackCount;
00097 //   return (blackCount*100)/(inputImage.getHeight() * inputImage.getWidth());
00098 // }
00099 
00100 // int isolateWhite(const Image< PixRGB<byte> > &inputImage,  Image<byte> &outputImage, int& x, int& y) {
00101 //   int whiteCount = 0;
00102 //   x = 0; y = 0;
00103 //   for(int j = 0; j < inputImage.getHeight(); j++ ) {
00104 //     for(int i = 0; i < inputImage.getWidth(); i++ )
00105 //       {
00106 
00107 
00108 
00109 //         //float h1 = ((PixH2SV2 <float> )inputImage.getVal(i, j)).H1();
00110 //         //float h2 = ((PixH2SV2 <float> )inputImage.getVal(i, j)).H2();
00111 //         float s = ((PixH2SV2 <float> )inputImage.getVal(i, j)).S();
00112 //         float v = ((PixH2SV2 <float> )inputImage.getVal(i, j)).V();
00113 
00114 //         //printf("\tS: %f V: %f", s, v);
00115 //         if (/*h1 > 0.25 && h1 < 0.733333  && h2 > 0.0 && h2 < 0.312500 &&*//* s > 0.020490 && */s < 0.30 && v > 0.85 /*&& v < 1.0*/ ) {
00116 //           //        if (s < 0.07 && v > 0.48) {
00117 //           //printf("FOUND");
00118 //           if (outputImage.coordsOk(i,j)) {
00119 //             //printf("OK");
00120 //             outputImage.setVal(i, j, 0);
00121 //             whiteCount++;
00122 //             x+=i;
00123 //             y+=j;
00124 
00125 //           }
00126 //         }
00127 
00128 //         else if(outputImage.coordsOk(i,j)) {
00129 //           outputImage.setVal(i, j, 255);
00130 //         }
00131 //         //  printf("H1: %f %f %f %f\t", h1, h2, s, v);
00132 //         /*
00133 //           float avgR = inputImage.getVal(i, j).red();
00134 //           float avgG = inputImage.getVal(i, j).green();
00135 //           float avgB = inputImage.getVal(i, j).blue();
00136 
00137 //           float avg = (avgR+avgG+avgB)/3.0;
00138 //           float sigma = pow(avgR - avg, 2.) + pow(avgG - avg, 2.) + pow(avgB - avg, 2.);
00139 //           float stdDev = sqrt( (1./3.) * sigma );
00140 
00141 //           if (stdDev < 10 && avg > 200 && outputImage.coordsOk(i,j)) {
00142 //           outputImage.setVal(i, j, 0);
00143 //           whiteCount++;
00144 
00145 //           }
00146 //           else if(outputImage.coordsOk(i,j)) {
00147 //           outputImage.setVal(i, j, 255);
00148 //           }*/
00149 //       }
00150 //   }
00151 
00152 //   if(whiteCount) {
00153 //     x /= whiteCount;
00154 //     y /= whiteCount;
00155 //   }
00156 //   else {
00157 //     x = -1;
00158 //     y = -1;
00159 //   }
00160 
00161 //   return (whiteCount*100)/(inputImage.getHeight() * inputImage.getWidth());
00162 // }
00163 
00164 
00165 float isolateOrange(Image< PixRGB<byte> > &inputImage,  Image<byte> &outputImage)
00166 {
00167   LINFO("happy");
00168   int orangeCount = 0;
00169 
00170   Image<PixRGB<byte> >::iterator iptr = inputImage.beginw();
00171   Image<byte>::iterator          optr = outputImage.beginw();
00172   Image<PixRGB<byte> >::iterator stop = inputImage.endw();
00173 
00174 //   float tR = 150.0;
00175 //   float tG = 200.0;
00176 //   float tB = 128.0;
00177 
00178 //   float R = 255;
00179 //   float G = 198;
00180 //   float B = 0;
00181 
00182   float tR = 150.0;
00183   float tG = 200.0;
00184   float tB = 128.0;
00185 
00186   float R = 255;
00187   float G = 198;
00188   float B = 0;
00189 
00190 
00191   while (iptr != stop)
00192     {
00193       float avgR = (*iptr).red();
00194       float avgG = (*iptr).green();
00195       float avgB = (*iptr).blue();
00196 
00197       //float avg = (avgR+avgG+avgB)/3.0;
00198       //float sigma = pow(avgR - avg, 2.) + pow(avgG - avg, 2.) + pow(avgB - avg, 2.);
00199       //float stdDev = sqrt( (1./3.) * sigma );
00200 
00201       if (avgR > R - tR && avgR < R + tR &&
00202           avgG > G - tG && avgG < G + tG &&
00203           avgB > B - tB && avgB < B + tB   )
00204         {
00205           (*optr) = (byte)255;  // orange
00206           orangeCount++;
00207         }
00208 //       else
00209 //         {
00210 //           //if(outputImage.coordsOk(i,j)){
00211 //           //(*optr) = (byte)0; //not orange
00212 //           //}
00213 //         }
00214 
00215       iptr++; optr++;
00216     }
00217   return float(orangeCount)/float( (inputImage.getHeight() * inputImage.getWidth()));
00218 }
00219 
00220 
00221 
00222 // int isolateRed(const Image< PixRGB<byte> > &inputImage,  Image<byte> &outputImage) {
00223 //   int blackCount = 0;
00224 //   for(int j = 0; j < inputImage.getHeight(); j++ ) {
00225 //     for(int i = 0; i < inputImage.getWidth(); i++ )
00226 //       {
00227 
00228 //         /* float h1 = inputImage.getVal(i, j).H1();
00229 //            float h2 = inputImage.getVal(i, j).H2();
00230 //            float s = inputImage.getVal(i, j).S();
00231 //            float v = inputImage.getVal(i, j).V();*/
00232 
00233 
00234 //         float avgR = inputImage.getVal(i, j).red();
00235 //         float avgG = inputImage.getVal(i, j).green();
00236 //         float avgB = inputImage.getVal(i, j).blue();
00237 
00238 //         float avg = (avgR+avgG+avgB)/3.0;
00239 //         float sigma = pow(avgR - avg, 2.) + pow(avgG - avg, 2.) + pow(avgB - avg, 2.);
00240 //         float stdDev = sqrt( (1./3.) * sigma );
00241 
00242 //         if (avgR > avgG && avgR > avgB && stdDev > 15 && outputImage.coordsOk(i,j)) {
00243 //           outputImage.setVal(i, j, 255);
00244 //           blackCount++;
00245 
00246 //         }
00247 //         else {
00248 //           if(outputImage.coordsOk(i,j)){
00249 //             outputImage.setVal(i, j, 0);
00250 //           }
00251 //         }
00252 
00253 //       }
00254 //   }
00255 
00256 //   return (blackCount*100)/(inputImage.getHeight() * inputImage.getWidth());
00257 // }
00258 
00259 // // int houghTransform(Image< PixRGB <byte> >  &image, std::vector<LineSegment2D> &lines, int houghThreshold = 25, bool copyOver = false) {
00260 // //                 float sigma = .7;
00261 // //                 float tlow = 0.2;
00262 // //                 float thigh = .97;
00263 // //                 unsigned char *edge;
00264 
00265 // //                 char *dirfilename = NULL;
00266 
00267 
00268 
00269 // //                 Image<byte> byteImage = luminance(image);
00270 
00271 
00272 // //                 Image< PixRGB<byte> > houghImg = byteImage;
00273 
00274 // //                 canny(byteImage.getArrayPtr(), byteImage.getHeight(), byteImage.getWidth(), sigma, tlow, thigh, &edge, dirfilename);
00275 // //                 Image<unsigned char> edgeImage(edge, byteImage.getWidth(), byteImage.getHeight());
00276 // //                 houghImg = edgeImage;
00277 
00278 // //                         //perform the hough transform on the green isolated image
00279 // //                 lines = houghTransform(edgeImage, PI/180, 1, houghThreshold, houghImg);
00280 
00281 // //         if (copyOver) {
00282 // //                 image = luminance(houghImg);
00283 // //         }
00284 
00285 // //                 return lines.size();
00286 
00287 // // }
00288 
00289 // std::vector<LineSegment2D> pruneIntersections(std::vector<LineSegment2D> &lines, double angle=-1) {
00290 //   std::vector<LineSegment2D> lines2;
00291 //   int size = lines.size();
00292 //   double x, y;
00293 
00294 //   bool bad[size];
00295 
00296 
00297 //   for (int z = 0; z < size; z++) bad[z] = false;
00298 
00299 //   if (size > 1) {
00300 
00301 //     for (int i = 0; i < size; i++) {
00302 //       for (int a = 0; a < size; a++) {
00303 //         if (a == i) continue;
00304 
00305 
00306 //         if (lines[i].intersects(lines[a], x, y) && (angle == -1 || lines[i].angleBetween(lines[a]) < angle)) {
00307 //           //whenever two lines intersect, prune the shorter one. as long as neither of them have been flagged as intersecting before
00308 //           if (!bad[a] && !bad[i]) {
00309 
00310 //             int x = lines[i].length() > lines[a].length() ? a : i;
00311 //             bad[x] = true;
00312 //           }
00313 //         }
00314 
00315 //       }
00316 //     }
00317 //     /*
00318 //       for (int i = 0; i < size - 1; i++) {
00319 //       //printf("Line: %d %d, %d %d\n", lines[i].point1().i, lines[i].point1().j, lines[i].point2().i, lines[i].point2().j);
00320 
00321 //       for (int a = i + 1; a < size; a++) {
00322 
00323 //       if (lines[i].intersects(lines[a], x, y)) {
00324 //       //printf("Intersects at: %f, %f\n", x, y);
00325 //       bad[i] = true;
00326 //       break;
00327 //       }
00328 //       else {
00329 //       bad[i] = false;
00330 //       }
00331 //       }
00332 //       }*/
00333 //   }
00334 
00335 //   for (int i = 0; i < size; i++) {
00336 //     if (!bad[i]) {
00337 //       lines2.push_back(lines[i]);
00338 //     }
00339 //   }
00340 
00341 
00342 //   return lines2;
00343 // }
00344 #endif
Generated on Sun May 8 08:40:20 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3