cinelerra-5.1/plugins/gaborobj/gaborobj.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 1997-2014 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "clip.h"
  22 #include "filexml.h"
  23 #include "gaborobj.h"
  24 #include "gaborobjwindow.h"
  25 #include "language.h"
  26 #include "mutex.h"
  27
  28 REGISTER_PLUGIN(GaborObj)
  29
  30
  31 GaborObjConfig::GaborObjConfig()
  32 {
  33 }
  34
  35 int GaborObjConfig::equivalent(GaborObjConfig &that)
  36 {
  37         return 1;
  38 }
  39
  40 void GaborObjConfig::copy_from(GaborObjConfig &that)
  41 {
  42 }
  43
  44 void GaborObjConfig::interpolate( GaborObjConfig &prev, GaborObjConfig &next,
  45         long prev_frame, long next_frame, long current_frame)
  46 {
  47         copy_from(next);
  48 }
  49
  50 void GaborObjConfig::limits()
  51 {
  52 }
  53
  54
  55 GaborObj::GaborObj(PluginServer *server)
  56  : PluginVClient(server)
  57 {
  58         int steps = 16;
  59         Size ksize(31, 31);
  60         for( int i=0; i<steps; ++i ) {
  61                 double theta = i * M_PI/steps;
  62                 Mat kern = getGaborKernel(ksize, 4.0, theta, 10.0, 0.5, 0, CV_32F);
  63                 float sum = 0;
  64                 for( int k=0; k<kern.rows; ++k ) {
  65                         float *kp = kern.ptr<float>(k);
  66                         for( int j=0; j<kern.cols; ++j ) sum += *kp++;
  67                 }
  68                 kern /= 1.5*sum;
  69                 filters.push_back(kern);
  70         }
  71         gabor_engine = 0;
  72         remap_lock = new ::Mutex("GaborObj::remap_lock");
  73 }
  74
  75 GaborObj::~GaborObj()
  76 {
  77         delete gabor_engine;
  78         delete remap_lock;
  79 }
  80
  81 const char* GaborObj::plugin_title() { return N_("GaborObj"); }
  82 int GaborObj::is_realtime() { return 1; }
  83
  84 NEW_WINDOW_MACRO(GaborObj, GaborObjWindow);
  85 LOAD_CONFIGURATION_MACRO(GaborObj, GaborObjConfig)
  86
  87 void GaborObj::save_data(KeyFrame *keyframe)
  88 {
  89         FileXML output;
  90
  91 // cause data to be stored directly in text
  92         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
  93         output.tag.set_title("GABOROBJ");
  94         output.append_tag();
  95         output.append_newline();
  96         output.tag.set_title("/GABOROBJ");
  97         output.append_tag();
  98         output.append_newline();
  99         output.terminate_string();
 100 }
 101
 102 void GaborObj::read_data(KeyFrame *keyframe)
 103 {
 104         FileXML input;
 105         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
 106
 107         int result = 0;
 108         while( !(result = input.read_tag()) ) {
 109                 if( input.tag.title_is("GABOROBJ") ) {
 110                         config.limits();
 111                 }
 112                 else if( input.tag.title_is("/GABOROBJ") )
 113                         result = 1;
 114         }
 115 }
 116
 117 void GaborObj::update_gui()
 118 {
 119         if( !thread ) return;
 120         if( !load_configuration() ) return;
 121         thread->window->lock_window("GaborObj::update_gui");
 122         GaborObjWindow *window = (GaborObjWindow*)thread->window;
 123         window->unlock_window();
 124 }
 125
 126 void GaborObj::to_mat(Mat &mat, int mcols, int mrows,
 127         VFrame *inp, int ix,int iy, int mcolor_model)
 128 {
 129         int mcomp = BC_CModels::components(mcolor_model);
 130         int mbpp = BC_CModels::calculate_pixelsize(mcolor_model);
 131         int psz = mbpp / mcomp;
 132         int mdepth = psz < 2 ? CV_8U : psz < 4 ? CV_16U : CV_32F;
 133         if( mat.dims != 2 || mat.depth() != mdepth || mat.channels() != mcomp ||
 134             mat.cols != mcols || mat.rows != mrows ) {
 135                 mat.release();
 136         }
 137         if( mat.empty() ) {
 138                 int type = CV_MAKETYPE(mdepth, mcomp);
 139                 mat.create(mrows, mcols, type);
 140         }
 141         uint8_t *mat_rows[mrows];
 142         for( int y=0; y<mrows; ++y ) mat_rows[y] = mat.ptr(y);
 143         uint8_t **inp_rows = inp->get_rows();
 144         int ibpl = inp->get_bytes_per_line(), mbpl = mcols * mbpp;
 145         int icolor_model = inp->get_color_model();
 146         BC_CModels::transfer(mat_rows, mcolor_model, 0,0, mcols,mrows, mbpl,
 147                 inp_rows, icolor_model, ix,iy, mcols,mrows, ibpl, 0);
 148 //      VFrame vfrm(mat_rows[0], -1, mcols,mrows, mcolor_model, mat_rows[1]-mat_rows[0]);
 149 //      static int vfrm_no = 0; char vfn[64]; sprintf(vfn,"/tmp/idat/%06d.png", vfrm_no++);
 150 //      vfrm.write_png(vfn);
 151 }
 152
 153 void GaborObj::from_mat(VFrame *out, int ox, int oy, int ow, int oh, Mat &mat, int mcolor_model)
 154 {
 155         int mbpp = BC_CModels::calculate_pixelsize(mcolor_model);
 156         int mrows = mat.rows, mcols = mat.cols;
 157         uint8_t *mat_rows[mrows];
 158         for( int y=0; y<mrows; ++y ) mat_rows[y] = mat.ptr(y);
 159         uint8_t **out_rows = out->get_rows();
 160         int obpl = out->get_bytes_per_line(), mbpl = mcols * mbpp;
 161         int ocolor_model = out->get_color_model();
 162         BC_CModels::transfer(out_rows, ocolor_model, ox,oy, ow,oh, obpl,
 163                 mat_rows, mcolor_model, 0,0, mcols,mrows, mbpl,  0);
 164 //      static int vfrm_no = 0; char vfn[64]; sprintf(vfn,"/tmp/odat/%06d.png", vfrm_no++);
 165 //      out->write_png(vfn);
 166 }
 167
 168
 169 int GaborObj::process_buffer(VFrame *frame, int64_t start_position, double frame_rate)
 170 {
 171
 172         //int need_reconfigure =
 173         load_configuration();
 174         input = get_input(0);
 175         output = get_output(0);
 176         width = input->get_w();
 177         height = input->get_h();
 178         color_model = input->get_color_model();
 179
 180 // load next image
 181         VFrame *iframe = new_temp(width,height, color_model);
 182         read_frame(iframe, 0, start_position, frame_rate, 0);
 183         input = iframe;
 184         to_mat(next_img, width,height, iframe, 0,0, color_model);
 185         if( !gabor_engine )
 186                 gabor_engine = new GaborObjFilterEngine(this, PluginClient::smp + 1);
 187
 188         output->clear_frame();
 189         gabor_engine->process_packages();
 190         return 0;
 191 }
 192
 193
 194 GaborObjFilterPackage::GaborObjFilterPackage()
 195  : LoadPackage()
 196 {
 197 }
 198
 199 GaborObjFilterUnit::GaborObjFilterUnit(GaborObjFilterEngine *engine, GaborObj *plugin)
 200  : LoadClient(engine)
 201 {
 202         this->plugin = plugin;
 203 }
 204
 205 GaborObjFilterUnit::~GaborObjFilterUnit()
 206 {
 207 }
 208
 209 void GaborObjFilterUnit::process_package(LoadPackage *package)
 210 {
 211         GaborObjFilterPackage *pkg = (GaborObjFilterPackage*)package;
 212         process_filter(pkg);
 213 }
 214
 215 void GaborObjFilterUnit::process_filter(GaborObjFilterPackage *pkg)
 216 {
 217         int color_model = plugin->color_model;
 218         int w = plugin->output->get_w(), h = plugin->output->get_h();
 219         int ddepth = CV_8UC3;
 220
 221         switch( color_model ) {
 222         case BC_RGB888:     ddepth = CV_8UC3;   break;
 223         case BC_RGBA8888:   ddepth = CV_8UC4;   break;
 224         case BC_RGB_FLOAT:  ddepth = CV_32FC3;  break;
 225         case BC_RGBA_FLOAT: ddepth = CV_32FC4;  break;
 226         case BC_YUV888:     ddepth = CV_8UC3;   break;
 227         case BC_YUVA8888:   ddepth = CV_8UC4;   break;
 228         }
 229
 230         Mat &src = plugin->next_img, dst;
 231         Mat &kern = plugin->filters[pkg->i];
 232         filter2D(src, dst, ddepth, kern);
 233
 234 #define GABOR_OBJ_REMAP(type, components) { \
 235         type **out_rows = (type**)plugin->output->get_rows(); \
 236  \
 237         for( int y=0; y<h; ++y ) { \
 238                 type *out_row = out_rows[y]; \
 239                 type *dst_row = (type *)dst.ptr<type>(y); \
 240                 for( int x=0; x<w; ++x ) { \
 241                         for( int i=0; i<components; ++i ) { \
 242                                 *out_row = bmax(*out_row, *dst_row); \
 243                                 ++out_row;  ++dst_row; \
 244                         } \
 245                 } \
 246         } \
 247 }
 248 // technically, this is needed... but it really can slow it down.
 249 //      plugin->remap_lock->lock("GaborObjFilterUnit::process_filter");
 250         switch( color_model ) {
 251         case BC_RGB888:     GABOR_OBJ_REMAP(unsigned char, 3);  break;
 252         case BC_RGBA8888:   GABOR_OBJ_REMAP(unsigned char, 4);  break;
 253         case BC_RGB_FLOAT:  GABOR_OBJ_REMAP(float, 3);          break;
 254         case BC_RGBA_FLOAT: GABOR_OBJ_REMAP(float, 4);          break;
 255         case BC_YUV888:     GABOR_OBJ_REMAP(unsigned char, 3);  break;
 256         case BC_YUVA8888:   GABOR_OBJ_REMAP(unsigned char, 4);  break;
 257         }
 258 //      plugin->remap_lock->unlock();
 259 }
 260
 261
 262 GaborObjFilterEngine::GaborObjFilterEngine(GaborObj *plugin, int cpus)
 263  : LoadServer(cpus+1, plugin->filters.size())
 264 {
 265         this->plugin = plugin;
 266 }
 267
 268 GaborObjFilterEngine::~GaborObjFilterEngine()
 269 {
 270 }
 271
 272 void GaborObjFilterEngine::init_packages()
 273 {
 274         int n = LoadServer::get_total_packages();
 275         for( int i=0; i<n; ++i ) {
 276                 GaborObjFilterPackage *pkg = (GaborObjFilterPackage*)LoadServer::get_package(i);
 277                 pkg->i = i;
 278         }
 279 }
 280
 281 LoadClient* GaborObjFilterEngine::new_client()
 282 {
 283         return new GaborObjFilterUnit(this, plugin);
 284 }
 285
 286 LoadPackage* GaborObjFilterEngine::new_package()
 287 {
 288         return new GaborObjFilterPackage();
 289 }
 290