penguingV Enhancement

Good ol' C++ and Image Processing

    The issue that was listed in penguinV's repository asks for a slight improvement on their already implemented EdgeDetection() algorithm, which currently works with double values. The improvement must template the algorithm so the work can be done with 'float's as well.
    Well, templating the class with all of its methods is not that hard, separating headers (.h) from implementation (.cpp) of a templated class is not that tricky (by the way, I have recently found a beautiful tutorial on how it can bee done in 3(!) different ways), but making sure that at the time of comparison/assignment of a double to int (and vise-versa) the data won't be truncated because of differences in bit sizes - that can be a bit time-consuming. As of now, the algorithm uses uint32_t (unsigned 32-bit integer) as its integer type to be able to hold/pass data from/to double variables (truncating decimals, obviously), but with switch to float, the uint16_t will need to be used.
    The coding-side of problem gets introduced here in desire to provide flexibility to a user of the EdgeDetection, when the user would only pick either double or float, and integer component would be chosen automatically at the run-time. Yet, as I recently found out, there is no such a thing as run-time function's types declaration, so the following is not possible: 
template<typename T = double>
class EdgeDetection
{
private:
...
typedef  std::conditional<std::is_same<T, double>::value, uint32_t, uint16_t>::type  _UINT;
}

This part std::is_same<T, double> would return inline constexpr bool value and so we would be able to determine if  uint32_t or uint16_t should be used, but std::is_same<> will be able to return something only at the run-time, so we cannot declare an object of type _UINT before the std::is_same<> is done.
    The solution to this can probably be the implementation of so-called "visitor pattern", which, basically, separates the object structure from its algorithm, allowing us to use "double dispach" to split the run-time flow in two different streams (for doubles and floats in or example). I will try to apply the pattern and see if it is something we can do the workaround with.


Comments

Post a Comment

Popular posts from this blog

Two Different Frames of Same VidioCapture

Image
OpenCV Challenge     I believe, this bug is going to be one of the most challenging I have worked on. Not because of complexity of the work, not because of the scale involved, but because the part of the code is brand new to me. STDMETHODIMP SourceReaderCB::OnReadSample(HRESULT hrStatus, DWORD dwStreamIndex, DWORD dwStreamFlags, LONGLONG llTimestamp, IMFSample *pSample) {     CV_UNUSED(llTimestamp);     HRESULT hr = 0;     cv::AutoLock lock(m_mutex);     if (SUCCEEDED(hrStatus))     {         if (pSample)                     CV_LOG_DEBUG(NULL, "videoio(MSMF): got frame at " << llTimestamp);             IMFSample* prev = m_lastSample.Get();             if (prev)             {                 CV_LOG_DEBUG(NULL, "videoio(MSMF): drop frame (not processed)");             }             m_lastSample = pSample;         }     }     else     {         CV_LOG_WARNING(NULL, "videoio(MSMF): OnReadSample() is called with error status: "
Read more

Node.js: fs.open()

    Today, I would like to take a look at one of the widely used functions of Node.js ' fs  library -  open() , and its synchronous version -  openSync() .     The function's purpose is to open a file, specified by a path (the first mandatory parameter of the function). The code of the function is following ( source ): function open(path, flags, mode, callback) {   path = toPathIfFileURL(path);   validatePath(path);   if (arguments.length < 3) {     callback = flags;     flags = 'r';     mode = 0o666;   } else if (typeof mode === 'function') {     callback = mode;     mode = 0o666;   }   const flagsNumber = stringToFlags(flags);   if (arguments.length >= 4) {     mode = validateMode(mode, 'mode', 0o666);   }   callback = makeCallback(callback);   const req = new FSReqCallback();   req.oncomplete = callback;   binding.open(pathModule.toNamespacedPath(path),                flagsNumber,                mode,                re
Read more

Good friend penguinV

Two birds with one "Pull"     As previously said, I was working on OpenCV bug (you can find some details here ). The bug was not something to spend more than 2-3 days on, but the problem that was there - compilation time. OpenCV project is a set of C/C++ files (and CUDA ;-) ), which is supposed to be compiled with "cmake" to generate library(ies), containing compiled code. Everything sounded pretty decent, until the moment when I realized that I would need to compile the entire folder with a bit more than a lot of different modules of different shapes and colours to make any changes to the existing code and test it. And just because the modules with reference one-another, creating a web of dependencies, I would need to compile the whole thing every time, not some of the modules independently ("video" module, "java", "core" etc.). It'd be okay if not the fact that every compilation would take 20 minutes. Not nice. So, I switched
Read more