00001
00002
00003
00004
00005
00006
00007
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},
00034 {1.0, 0.7, 0.7},
00035 {0.7, 1.0, 0.7},
00036 {0.7, 0.7, 1.0},
00037 {1.0, 1.0, 0.0},
00038 {1.0, 0.0, 1.0},
00039 {0.0, 1.0, 1.0},
00040 {1.0, 0.0, 0.0},
00041 {0.0, 1.0, 0.0},
00042 {0.0, 0.0, 1.0},
00043 {0.5, 1.0, 1.0},
00044 {1.0, 1.0, 1.0},
00045 };
00046
00047
00048
00049
00050
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
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
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
00091 unsigned char mask_flag[256];
00092 unsigned char mask_values[256];
00093
00094 for (int i=0; i<256; i++)
00095 mask_flag[i] = 0;
00096
00097
00098 if (mdims == 2) {
00099
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
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
00112
00113 mask_flag[0] = 1;
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
00121 }
00122
00123
00124
00125
00126
00127
00128 Mat bgr[3];
00129 for (int i=0; i<3; i++) {
00130 if (idims == 2)
00131 bgr[i].create(img.rows, img.cols, CV_8UC1);
00132 else
00133 bgr[i] = MatVid::create(img.size[0], img.size[1], img.size[2], CV_8UC1);
00134 }
00135
00136
00137 if (idims == 2) {
00138
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
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)];
00156 else
00157 m = mask_values[mask.at<unsigned char>(z,y,x)];
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
00166 if (border>0) {
00167 if (mdims == 2) {
00168
00169 Mat bord = mask2Border(mask, border, mask_flag);
00170 if (idims == 2) {
00171
00172 for (int i=0; i<3; i++)
00173 bitwise_or(bgr[i], bord, bgr[i]);
00174
00175 } else {
00176
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
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
00198 merge(bgr, 3, oimg);
00199 }
00200
00201
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
00220 maskc = (mask == c);
00221 dilate(maskc, maskcd, el);
00222 bitwise_xor(maskcd, maskc, maskcd);
00223 bitwise_or(out, maskcd, out);
00224 }
00225 }
00226
00227 return out;
00228 }
00229
00230
00231
00232
00233
00234
00235
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
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
00264 Mat mont(montrows, montcols, mtype);
00265 mont = fill;
00266
00267
00268 int ix = 0;
00269 int iy = 0;
00270 for (int i=0; i<(int)imgs.size(); i++) {
00271
00272 int curx = border + ix*(mcols+spacing);
00273 int cury = border + iy*(mrows+spacing);
00274
00275
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
00281 ix++;
00282 if (ix >= sizex) {
00283 ix = 0;
00284 iy++;
00285 }
00286 }
00287
00288 return mont;
00289 }