vidutils.cpp

00001 /**************************************************
00002 
00003   Video Utilities
00004 
00005   Antoni Chan,
00006   City University of Hong Kong, Copyright 2014
00007   libdt - OpenCV library for Dynamic Textures - version 1.0
00008 
00009   
00010 ***************************************************/
00011 
00012 #include <iostream>
00013 #include <string>
00014 #include<fstream>
00015 #include <ctime>
00016 
00017 #include "opencv/cv.h"
00018 #include "opencv/cxcore.h"
00019 #include "opencv/highgui.h"
00020 
00021 
00022 #include "options.h"
00023 #include "utils/libutils.h"
00024 #include "video/MatVid.hpp"
00025 #include "video/vidutils.hpp"
00026 
00027 using namespace cv;
00028 using namespace std;
00029 
00030 
00031 #define MAXCOL 12
00032 Mat g_mask_lut[MAXCOL][3];
00033 double g_rgbtable[MAXCOL][3] = { {1.0, 1.0, 1.0},  // 0: clear
00034                                  {1.0, 0.7, 0.7},  // 1: pink
00035                                  {0.7, 1.0, 0.7},  // 2: light green
00036                                  {0.7, 0.7, 1.0},  // 3: indigo
00037                                  {1.0, 1.0, 0.0},  // 4: yellow
00038                                  {1.0, 0.0, 1.0},  // 5: magenta
00039                                  {0.0, 1.0, 1.0},  // 6: cyan
00040                                  {1.0, 0.0, 0.0},  // 7: red
00041                                  {0.0, 1.0, 0.0},  // 8: green
00042                                  {0.0, 0.0, 1.0},  // 9: blue
00043                                  {0.5, 1.0, 1.0},  // 10: ?
00044                                  {1.0, 1.0, 1.0},  // 11: white
00045 };
00046 
00047 
00048 // colorize an image based on a segmentation mask
00049 // (same as colormask.m)
00050 // TODO: add option to stop reindexing the mask (useful for consistent colors in videos)
00051 void colorMask(const Mat & img, const Mat &mask, Mat &oimg, int border) {
00052   if (img.channels() != 1)
00053     CV_Error(-1, "too many channels");
00054   if (mask.type() != CV_8UC1)
00055     CV_Error(-1, "mask not 8-bit");
00056 
00057   int mdims = mask.dims;
00058   int idims = img.dims;
00059 
00060   // check compatability of dimensions
00061   if ((mdims == 2) && (idims == 2)) {
00062     CV_Assert(img.rows == mask.rows);
00063     CV_Assert(img.cols == mask.cols);
00064   } else if ((mdims == 2) && (idims == 3)) {
00065     CV_Assert(img.size[1] == mask.rows);
00066     CV_Assert(img.size[2] == mask.cols);  
00067   } else if ((mdims == 3) && (idims == 3)) {
00068     CV_Assert(img.size[0] == mask.size[0]);
00069     CV_Assert(img.size[1] == mask.size[1]);
00070     CV_Assert(img.size[2] == mask.size[2]);  
00071   } else {
00072     CV_Error(-1, "Bad inputs");
00073   }
00074 
00075 
00076   // build RGB tables (one time only)
00077   if (g_mask_lut[0][0].total() == 0) {
00078     cout << "\n** building RGB tables **\n";
00079     
00080     for (int i=0; i<MAXCOL; i++) {
00081       for (int c=0; c<3; c++) {
00082         g_mask_lut[i][c].create(1,256,CV_8UC1);
00083         for (int p=0; p<256; p++) {
00084           g_mask_lut[i][c].at<unsigned char>(p) = (unsigned char)(p*g_rgbtable[i][c]);
00085         }
00086       }
00087     }
00088   }
00089 
00090   // build list of mask values --> color
00091   unsigned char mask_flag[256];
00092   unsigned char mask_values[256];
00093   // initialize array
00094   for (int i=0; i<256; i++)
00095     mask_flag[i] = 0;
00096 
00097   // mark mask values
00098   if (mdims == 2) {
00099     // mask image
00100     for (int y=0; y<mask.rows; y++)
00101       for (int x=0; x<mask.cols; x++)
00102         mask_flag[mask.at<unsigned char>(y,x)] = 1;
00103   } else {
00104     // mask video
00105     for (int z=0; z<mask.size[0]; z++) 
00106       for (int y=0; y<mask.size[1]; y++)
00107         for (int x=0; x<mask.size[2]; x++)
00108           mask_flag[mask.at<unsigned char>(z,y,x)] = 1;  
00109   }
00110   
00111   // convert mask values to color index
00112   
00113   mask_flag[0] = 1;  //always one for the background
00114 
00115   int nummask = 0;
00116   
00117 
00118   for (int i=0; i<256; i++) {
00119     mask_values[i] = (mask_flag[i] ? (nummask++) % MAXCOL : 0);
00120     //cout << (int)(mask_values[i]) << " ";
00121   }
00122   
00123   //dumpMatSize(img);
00124   //dumpMatSize(mask);
00125   //cout << "nm = " << nummask << "\n";
00126 
00127   // allocate output video
00128   Mat bgr[3];
00129   for (int i=0; i<3; i++) {
00130     if (idims == 2)      // output image
00131       bgr[i].create(img.rows, img.cols, CV_8UC1);
00132     else       // output video
00133       bgr[i] = MatVid::create(img.size[0], img.size[1], img.size[2], CV_8UC1);  
00134   }
00135   
00136   // use lookup table  
00137   if (idims == 2) {
00138     // image
00139     for (int y=0; y<img.rows; y++) {
00140       for (int x=0; x<img.cols; x++) {
00141         int p = img.at<unsigned char>(y,x);
00142         int m = mask_values[mask.at<unsigned char>(y,x)];
00143         for (int i=0; i<3; i++)
00144           bgr[2-i].at<unsigned char>(y,x) = g_mask_lut[m][i].at<unsigned char>(p);
00145       }
00146     }
00147   } else {
00148     // video
00149     for (int z=0; z<img.size[0]; z++) {
00150       for (int y=0; y<img.size[1]; y++) {
00151         for (int x=0; x<img.size[2]; x++) {
00152           int p = img.at<unsigned char>(z,y,x);
00153           int m;
00154           if (mdims == 2)
00155             m = mask_values[mask.at<unsigned char>(y,x)];    // mask image
00156           else
00157             m = mask_values[mask.at<unsigned char>(z,y,x)];  // mask video
00158           for (int i=0; i<3; i++)
00159             bgr[2-i].at<unsigned char>(z,y,x) = g_mask_lut[m][i].at<unsigned char>(p);
00160         }
00161       }
00162     }
00163   }
00164   
00165   // make border
00166   if (border>0) {
00167     if (mdims == 2) {
00168       // mask image & ...
00169       Mat bord = mask2Border(mask, border, mask_flag);
00170       if (idims == 2) {
00171         // ...output image
00172         for (int i=0; i<3; i++)
00173           bitwise_or(bgr[i], bord, bgr[i]);
00174           
00175       } else {
00176         // ...output video
00177         for (int z=0; z<img.size[0]; z++) {
00178           for (int i=0; i<3; i++) {
00179             Mat tmp = MatVid::frame(bgr[i], z);
00180             bitwise_or(tmp, bord, tmp);
00181           }
00182         }
00183       }
00184         
00185     } else {
00186       // mask video
00187       for (int z=0; z<img.size[0]; z++) {
00188         Mat bord = mask2Border(MatVid::frame(mask, z), border, mask_flag);
00189         for (int i=0; i<3; i++) {
00190           Mat tmp = MatVid::frame(bgr[i], z);
00191           bitwise_or(tmp, bord, tmp);
00192         }        
00193       }
00194     }
00195   }
00196 
00197   // make color image
00198   merge(bgr, 3, oimg);
00199 }
00200 
00201 // mask_flag = unsigned char[256] w/ non-zero for present mask values
00202 Mat mask2Border(const Mat &mask, int border, unsigned char *mask_flag) {
00203   CV_Assert(border>0);
00204   
00205   Mat el;
00206   if (border == 1)
00207     el = Mat::ones(2,2,CV_8UC1);
00208   else
00209     el = getStructuringElement(MORPH_ELLIPSE, Size(2*border+1, 2*border+1));
00210   
00211   if (mask_flag == 0)
00212     CV_Error(-1, "should provide mask_values");
00213   
00214   Mat out = Mat::zeros(mask.rows, mask.cols, CV_8UC1);
00215   Mat maskc, maskcd;
00216   
00217   for (int c=0; c<256; c++) {
00218     if (mask_flag[c]) {      
00219       //cout << "mask=" << c << "; ";
00220       maskc = (mask == c);                // segment c
00221       dilate(maskc, maskcd, el);          // dilate slightly
00222       bitwise_xor(maskcd, maskc, maskcd); // take difference
00223       bitwise_or(out, maskcd, out);       // accumulate
00224     }
00225   }
00226 
00227   return out;
00228 }
00229 
00230 
00231 // make a montage image
00232 //   sizex = number of videos per row
00233 //   spacing = pixel spacing between videos
00234 //   fill = fill color between videos
00235 //   border = border size around montage
00236 Mat imgmontage(const vector<Mat> &imgs, int sizex, int spacing, const Scalar &fill, int border) {
00237   int sizey = (int)ceil(((double)imgs.size()) / sizex);
00238 
00239   
00240   // get the max dimensions of patches  
00241   int mrows   = 0;
00242   int mcols   = 0;
00243   int mtype   = -1;
00244   for (int i=0; i<(int)imgs.size(); i++) {
00245     if (!imgs[i].empty()) {
00246       CV_Assert(imgs[i].dims == 2);
00247       if (imgs[i].rows > mrows)    mrows   = imgs[i].rows;
00248       if (imgs[i].cols > mcols)    mcols   = imgs[i].cols;
00249       if (mtype == -1)
00250         mtype = imgs[i].type();
00251       else
00252         CV_Assert(mtype == imgs[i].type());
00253     }
00254   }
00255 
00256   int montcols = sizex*mcols + (sizex-1)*spacing + border*2;
00257   int montrows = sizey*mrows + (sizey-1)*spacing + border*2;
00258   
00259   cout << "montage: (" << sizex << "," << sizey << ") images; " <<
00260     "image dims=(" << mrows << "," << mcols << "); --> ";
00261   cout << "(" << montrows << "," << montcols << ");\n";
00262   
00263   // allocate montage  
00264   Mat mont(montrows, montcols, mtype);
00265   mont = fill;
00266   
00267   // fill montage
00268   int ix = 0;
00269   int iy = 0;
00270   for (int i=0; i<(int)imgs.size(); i++) {
00271     // get current locations
00272     int curx = border + ix*(mcols+spacing);
00273     int cury = border + iy*(mrows+spacing);
00274     
00275     // copy patch to montage
00276     Mat montpatch(mont, Range(cury, cury+imgs[i].rows), Range(curx, curx+imgs[i].cols));
00277     if (!imgs[i].empty())
00278       imgs[i].copyTo(montpatch);
00279     
00280     // update position
00281     ix++;
00282     if (ix >= sizex) {
00283       ix = 0;
00284       iy++;
00285     }      
00286   }
00287 
00288   return mont;  
00289 }

Generated on 18 Dec 2014 for libdt-OpenCV by  doxygen 1.6.1