/*M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to this license. // If you do not agree to this license, do not download, install, // copy or use the software. // // // License Agreement // For Open Source Computer Vision Library // // Copyright (C) 2000, Intel Corporation, all rights reserved. // Copyright (C) 2013, OpenCV Foundation, all rights reserved. // Third party copyrights are property of their respective owners. // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // // * Redistribution's of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // * Redistribution's in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // * The name of the copyright holders may not be used to endorse or promote products // derived from this software without specific prior written permission. // // This software is provided by the copyright holders and contributors "as is" and // any express or implied warranties, including, but not limited to, the implied // warranties of merchantability and fitness for a particular purpose are disclaimed. // In no event shall the Intel Corporation or contributors be liable for any direct, // indirect, incidental, special, exemplary, or consequential damages // (including, but not limited to, procurement of substitute goods or services; // loss of use, data, or profits; or business interruption) however caused // and on any theory of liability, whether in contract, strict liability, // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. // //M*/ /** * @file synthetic_seq.cpp * @author Vladislav Samsonov <vvladxx@gmail.com> * @brief Synthetic frame sequence generator for testing background subtraction algorithms. * */ #include "precomp.hpp" namespace cv { namespace bgsegm { namespace { inline int clamp(int x, int l, int u) { return ((x) < (l)) ? (l) : (((x) > (u)) ? (u) : (x)); } inline int within(int a, int b, int c) { return (((a) <= (b)) && ((b) <= (c))) ? 1 : 0; } void bilinearInterp(uchar* dest, double x, double y, unsigned bpp, const uchar** values) { x = std::fmod(x, 1.0); y = std::fmod(y, 1.0); if (x < 0.0) x += 1.0; if (y < 0.0) y += 1.0; for (unsigned i = 0; i < bpp; i++) { double m0 = (1.0 - x) * values[0][i] + x * values[1][i]; double m1 = (1.0 - x) * values[2][i] + x * values[3][i]; dest[i] = (uchar) ((1.0 - y) * m0 + y * m1); } } // Static background is a way too easy test. We will add distortion to it. void waveDistortion(const uchar* src, uchar* dst, int width, int height, int bypp, double amplitude, double wavelength, double phase) { const uchar zeroes[4] = {0, 0, 0, 0}; const long rowsiz = width * bypp; const double xhsiz = (double) width / 2.0; const double yhsiz = (double) height / 2.0; double xscale, yscale; if (xhsiz < yhsiz) { xscale = yhsiz / xhsiz; yscale = 1.0; } else if (xhsiz > yhsiz) { xscale = 1.0; yscale = xhsiz / yhsiz; } else { xscale = 1.0; yscale = 1.0; } wavelength *= 2; for (int y = 0; y < height; y++) { uchar* dest = dst; for (int x = 0; x < width; x++) { const double dx = x * xscale; const double dy = y * yscale; const double d = sqrt (dx * dx + dy * dy); const double amnt = amplitude * sin(((d / wavelength) * (2.0 * M_PI) + phase)); const double needx = (amnt + dx) / xscale; const double needy = (amnt + dy) / yscale; const int xi = clamp(int(needx), 0, width - 2); const int yi = clamp(int(needy), 0, height - 2); const uchar* p = src + rowsiz * yi + xi * bypp; const int x1_in = within(0, xi, width - 1); const int y1_in = within(0, yi, height - 1); const int x2_in = within(0, xi + 1, width - 1); const int y2_in = within(0, yi + 1, height - 1); const uchar* values[4]; if (x1_in && y1_in) values[0] = p; else values[0] = zeroes; if (x2_in && y1_in) values[1] = p + bypp; else values[1] = zeroes; if (x1_in && y2_in) values[2] = p + rowsiz; else values[2] = zeroes; if (x2_in && y2_in) values[3] = p + bypp + rowsiz; else values[3] = zeroes; bilinearInterp(dest, needx, needy, bypp, values); dest += bypp; } dst += rowsiz; } } } SyntheticSequenceGenerator::SyntheticSequenceGenerator(InputArray _background, InputArray _object, double _amplitude, double _wavelength, double _wavespeed, double _objspeed) : amplitude(_amplitude), wavelength(_wavelength), wavespeed(_wavespeed), objspeed(_objspeed), timeStep(0) { _background.getMat().copyTo(background); _object.getMat().copyTo(object); if (background.channels() == 1) { cvtColor(background, background, COLOR_GRAY2BGR); } if (object.channels() == 1) { cvtColor(object, object, COLOR_GRAY2BGR); } CV_Assert(background.channels() == 3); CV_Assert(object.channels() == 3); CV_Assert(background.size().width > object.size().width); CV_Assert(background.size().height > object.size().height); background.convertTo(background, CV_8U); object.convertTo(object, CV_8U); pos.x = (background.size().width - object.size().width) / 2; pos.y = (background.size().height - object.size().height) / 2; const double phi = rng.uniform(0.0, CV_2PI); dir.x = std::cos(phi); dir.y = std::sin(phi); } void SyntheticSequenceGenerator::getNextFrame(OutputArray _frame, OutputArray _gtMask) { CV_Assert(!background.empty() && !object.empty()); const Size sz = background.size(); _frame.create(sz, CV_8UC3); Mat frame = _frame.getMat(); CV_Assert(background.isContinuous() && frame.isContinuous()); waveDistortion(background.ptr(), frame.ptr(), sz.width, sz.height, 3, amplitude, wavelength, double(timeStep) * wavespeed); const Size objSz = object.size(); object.copyTo(frame(Rect(Point2i(pos), objSz))); while (pos.x + dir.x * objspeed < 0 || pos.x + dir.x * objspeed >= sz.width - objSz.width || pos.y + dir.y * objspeed < 0 || pos.y + dir.y * objspeed >= sz.height - objSz.height) { const double phi = rng.uniform(0.0, CV_2PI); dir.x = std::cos(phi); dir.y = std::sin(phi); } _gtMask.create(sz, CV_8U); Mat gtMask = _gtMask.getMat(); gtMask = 0; gtMask(Rect(Point2i(pos), objSz)) = 255; pos += dir * objspeed; ++timeStep; } Ptr<SyntheticSequenceGenerator> createSyntheticSequenceGenerator(InputArray background, InputArray object, double amplitude, double wavelength, double wavespeed, double objspeed) { return makePtr<SyntheticSequenceGenerator>(background, object, amplitude, wavelength, wavespeed, objspeed); } } }