00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef __IMAGEPROCESSORS
00027 #define __IMAGEPROCESSORS
00028
00029 #include "imageprocessor.h"
00030
00031 #include <selforg/stl_adds.h>
00032
00033 #define MIN3(x,y,z) x<y ? (x<z ? x : z) : (y<z ? y : z)
00034 #define MAX3(x,y,z) x>y ? (x>z ? x : z) : (y>z ? y : z)
00035
00036 namespace lpzrobots {
00037
00038
00039
00040
00041
00042
00043
00044
00045 struct StdImageProcessor : public ImageProcessor {
00046 StdImageProcessor(bool show, float scale) {
00047 _dest.show = show;
00048 _dest.scale = scale;
00049 };
00050 virtual ~StdImageProcessor() {
00051 };
00052
00053
00054 virtual void initDestImage(Camera::CameraImage& dest, const Camera::CameraImage& src) = 0;
00055
00056
00057 virtual void process(const osg::Image* src, osg::Image* dest) = 0;
00058
00059
00060 virtual Camera::CameraImage init(const Camera::CameraImages& imgs){
00061 assert(imgs.size()>0);
00062 _src = imgs.back();
00063
00064 _dest.img = new osg::Image;
00065 initDestImage(_dest, _src);
00066 return _dest;
00067 }
00068
00069 virtual void process(){
00070 process(_src.img, _dest.img);
00071 _dest.img->dirty();
00072 }
00073
00074 protected:
00075 Camera::CameraImage _dest;
00076 Camera::CameraImage _src;
00077 };
00078
00079
00080
00081
00082 struct BWImageProcessor : public StdImageProcessor {
00083 enum ChannelMask {Red = 1, Green = 2, Blue = 4, Hue = 1, Saturation = 2, Value = 4};
00084
00085
00086 BWImageProcessor(bool show, float scale, char channelmask = 7)
00087 : StdImageProcessor(show,scale), channelmask(channelmask) {}
00088
00089 virtual ~BWImageProcessor() {}
00090
00091 virtual void initDestImage(Camera::CameraImage& dest, const Camera::CameraImage& src){
00092 dest.img->allocateImage(src.img->s(), src.img->t(), 1, GL_LUMINANCE, GL_UNSIGNED_BYTE);
00093 dest.name = "bw(" + src.name + ")";
00094 red = (channelmask & 1);
00095 green = (channelmask & 2);
00096 blue = (channelmask & 4);
00097 numchannels = red+green+blue;
00098 printf("BWImageProcessor: Select: Red %i, Green %i, Blue %i : numchannels %i\n",
00099 red, green, blue,numchannels);
00100 if(numchannels==0) numchannels=1;
00101 }
00102
00103 virtual void process(const osg::Image* src, osg::Image* dest){
00104 assert(src && src->getPixelFormat()==GL_RGB && src->getDataType()==GL_UNSIGNED_BYTE);
00105 for(int r=0; r < src->t(); ++r) {
00106 const unsigned char* sdata = src->data(0, r);
00107 unsigned char* ddata = dest->data(0, r);
00108 for(int c=0; c < src->s(); ++c) {
00109 (*ddata) = (*(sdata)*red + *(sdata+1)*green + *(sdata+2)*blue)/numchannels;
00110 sdata+=3;
00111 ddata++;
00112 }
00113 }
00114 }
00115 bool red, green, blue;
00116 char numchannels;
00117 char channelmask;
00118 };
00119
00120
00121
00122
00123
00124
00125 struct HSVImgProc : public StdImageProcessor {
00126 enum Colors {Red=0, Yellow=30, Green=60, Cyan=90,
00127 Blue=120, Magenta=150, Red2=180, Gray=255, Span=30};
00128
00129 HSVImgProc(bool show, float scale)
00130 : StdImageProcessor(show,scale) {
00131 }
00132
00133 virtual ~HSVImgProc() {}
00134
00135 virtual void initDestImage(Camera::CameraImage& dest, const Camera::CameraImage& src){
00136 dest.img->allocateImage(src.img->s(), src.img->t(), 1, GL_RGB, GL_UNSIGNED_BYTE);
00137 dest.name = "hsv(" + src.name + ")";
00138 }
00139
00140 virtual void process(const osg::Image* src, osg::Image* dest){
00141 assert(src && src->getPixelFormat()==GL_RGB && src->getDataType()==GL_UNSIGNED_BYTE);
00142 for(int r=0; r < src->t(); ++r) {
00143 const unsigned char* sdata = src->data(0, r);
00144 unsigned char* ddata = dest->data(0, r);
00145 for(int c=0; c < src->s(); ++c) {
00146 RGBtoHSV(*(sdata),*(sdata+1),*(sdata+2),
00147 (*ddata), *(ddata+1), *(ddata+2));
00148 sdata+=3;
00149 ddata+=3;
00150 }
00151 }
00152 }
00153
00154
00155
00156
00157
00158
00159
00160 void RGBtoHSV( unsigned char r, unsigned char g, unsigned char b,
00161 unsigned char& h, unsigned char& s, unsigned char& v ) {
00162 unsigned char min, max;
00163 float delta;
00164 float hue;
00165 min = MIN3( r, g, b );
00166 max = MAX3( r, g, b );
00167 v = max;
00168 delta = max - min;
00169 if( max != 0 ){
00170 s = 255.0*delta / max;
00171 }
00172 if( max == 0 || delta == 0){
00173
00174 s = 0;
00175 h = 255;
00176 return;
00177 }
00178
00179 if( r == max )
00180 hue = float( g - b ) / delta;
00181 else if( g == max )
00182 hue = 2.0 + float( b - r ) / delta;
00183 else
00184 hue = 4.0 + float( r - g ) / delta;
00185 hue *=30;
00186 if( hue < 0 )
00187 hue += 180;
00188 h = int(hue);
00189 }
00190 };
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201 struct ColorFilterImgProc : public StdImageProcessor {
00202 ColorFilterImgProc(bool show, float scale, int minhue, int maxhue,
00203 int sat_threshold=100, int val_threshold=50)
00204 : StdImageProcessor(show,scale),
00205 minhue(minhue), maxhue(maxhue), sat_threshold(sat_threshold), val_threshold(val_threshold) {
00206 }
00207
00208 virtual ~ColorFilterImgProc() {}
00209
00210 virtual void initDestImage(Camera::CameraImage& dest, const Camera::CameraImage& src){
00211 dest.img->allocateImage(src.img->s(), src.img->t(), 1, GL_LUMINANCE, GL_UNSIGNED_BYTE);
00212
00213 dest.name = "spots(" + src.name + ")";
00214 }
00215
00216 virtual void process(const osg::Image* src, osg::Image* dest){
00217
00218 assert(src && src->getPixelFormat()==GL_RGB && src->getDataType()==GL_UNSIGNED_BYTE);
00219 for(int r=0; r < src->t(); ++r) {
00220 const unsigned char* sdata = src->data(0, r);
00221 unsigned char* ddata = dest->data(0, r);
00222 for(int c=0; c < src->s(); ++c) {
00223 if(*(sdata) >= minhue && *(sdata) < maxhue
00224 && *(sdata+1) > sat_threshold && *(sdata+2) > val_threshold){
00225 (*ddata) = *(sdata+2);
00226 } else{
00227 (*ddata) = 0;
00228 }
00229 sdata+=3;
00230 ddata++;
00231 }
00232 }
00233 }
00234 int minhue;
00235 int maxhue;
00236 int sat_threshold;
00237 int val_threshold;
00238 };
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248 struct LineImgProc : public StdImageProcessor {
00249 LineImgProc(bool show, float scale, int num, double factor = 20.0)
00250 : StdImageProcessor(show,scale), num(num), factor(factor) {
00251 }
00252
00253 virtual ~LineImgProc() {}
00254
00255 virtual void initDestImage(Camera::CameraImage& dest, const Camera::CameraImage& src){
00256 dest.img->allocateImage(num, 1, 1, GL_LUMINANCE, GL_UNSIGNED_BYTE);
00257 dest.name = "line(" + src.name + ")";
00258 }
00259
00260 virtual void process(const osg::Image* src, osg::Image* dest){
00261
00262 assert(src && src->getPixelFormat()==GL_LUMINANCE && src->getDataType()==GL_UNSIGNED_BYTE);
00263
00264 int w = src->s();
00265 int h = src->t();
00266 int size = w/num;
00267 int numpixel_per_segm = size*h;
00268 int segmentvalue;
00269 unsigned char* destdata = dest->data();
00270 for(int k=0; k<num; k++){
00271 int sum = 0;
00272 for(int j=0; j<h; j++){
00273 const unsigned char* pixel = src->data(k*size, j);
00274 for(int i=0; i< size; i++){
00275 sum += *pixel;
00276 pixel++;
00277 }
00278 }
00279 segmentvalue = (double)sum*factor/(double)numpixel_per_segm;
00280 destdata[k] = std::min(segmentvalue,255);
00281 }
00282 }
00283 int num;
00284 double factor;
00285 };
00286
00287
00288
00289
00290 struct AvgImgProc : public StdImageProcessor {
00291
00292
00293 AvgImgProc(bool show, float scale, int time)
00294 : StdImageProcessor(show,scale), time(time) {
00295 if(time<1) time =1;
00296 factor = 1.0/(float)time;
00297 }
00298
00299 virtual ~AvgImgProc() {}
00300
00301 virtual void initDestImage(Camera::CameraImage& dest, const Camera::CameraImage& src){
00302 assert(src.img && src.img->getDataType()==GL_UNSIGNED_BYTE);
00303 dest.img->allocateImage(src.img->s(), src.img->t(), 1, src.img->getPixelFormat(),
00304 GL_UNSIGNED_BYTE);
00305 dest.name = "avg(" + std::itos(time) + "," + src.name + ")";
00306 }
00307
00308 virtual void process(const osg::Image* src, osg::Image* dest){
00309 for(int r=0; r < src->t(); ++r) {
00310 const unsigned char* sdata = src->data(0, r);
00311 unsigned char* ddata = dest->data(0, r);
00312 for(unsigned int c=0; c < src->getRowSizeInBytes(); ++c) {
00313 *ddata = ((float)*sdata)*factor + ((float)*ddata)*(1-factor);
00314 sdata++;
00315 ddata++;
00316 }
00317 }
00318 }
00319
00320 int time;
00321 float factor;
00322 };
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366 }
00367
00368 #endif