Open CV Image editing library for windows 8 and windows phone 8

Question

Is there any support of OpenCV graphics library is available for Windows Phone 8 and Windows 8. I made a search on Google but didn't find any resource related with OpenCV to connect with Windows Phone 8 / Windows 8. If any of you know more about this please help me, and provide some link to reach the library.

Rakesh R Nair · Accepted Answer · 2013-03-22T06:54:41.920

This is the latest information what I get from OpenCV team.

OpenCV development team is working on port for Windows RT. Here is current development branch for WinRT(https://github.com/asmorkalov/opencv/tree/winrt). You can build it for ARM using Visual Studio Express for Windows 8 and Platform SDK.

      Open Visual Studio development console.
      Setup environment for cross compilation by command "C:\Program Files(x86)\Microsoft
      Visual Studio 11.0\VC\bin\x86_arm\vcvarsx86_arm.bat"
      cd <opencv_source_dir>/platforms/winrt/
      run scripts/cmake_winrt.cmd
      run ninja

Alternatively you can use nmake instead ninja. You need to edit cmake_winrt.cmd and change project generator fro -GNinja to -G "NMake Makefiles". Only algorithmic part of the library is supported now, no tbb, no UI, no video IO.

Please check the below given URL from more details. http://answers.opencv.org/question/9847/opencv-for-windows-8-tablet/?answer=9851#post-id-9851

@Stephan Ronald, did you succeed in building it ? – Jaydeep Solanki Mar 24 '13 at 17:19 — Jaydeep Solanki, Mar 24 '13 at 17:19

cedrou · Answer 2 · 2013-02-28T10:53:23.280

By windows-8, I guess you mean winRT ? AFAIK, there is no official port to winRT. You need to compile it by yourself as a Win8 Store DLL for instance, so that you can reference it from a Win8 Store Application.

Just start by opencv-core, then add the lib you need, one by one, because all the components will not be able to compile (for instance, opencv-highgui is highly dependant on Windows API which is not fully compatible with Win8 Store Apps).

You'll also need to code by yourself some Win32 methods used by OpenCV and not accessible from Win8 App like GetSystemInfo(), GetTempPathA(), GetTempFileNameA() and all methods related to thread local storage (TLS).

I've been able to use a small subset of OpenCV in WinRT by compiling opencv_core, opencv_imgproc and zlib, as 3 seperate static libs. I've added one another, called opencv_winrt, that contains only the two following files:

opencv_winrt.h

#pragma once

#include "combaseapi.h"

void WINAPI GetSystemInfo(
    _Out_  LPSYSTEM_INFO lpSystemInfo
);

DWORD WINAPI GetTempPathA(
  _In_   DWORD nBufferLength,
  _Out_  char* lpBuffer
);
UINT WINAPI GetTempFileNameA(
  _In_   const char* lpPathName,
  _In_   const char* lpPrefixString,
  _In_   UINT uUnique,
  _Out_  char* lpTempFileName
);

DWORD WINAPI TlsAlloc();
BOOL WINAPI TlsFree(
    _In_ DWORD dwTlsIndex
);
LPVOID WINAPI TlsGetValue(
    _In_ DWORD dwTlsIndex
);
BOOL WINAPI TlsSetValue(
    _In_ DWORD dwTlsIndex, 
    _In_opt_ LPVOID lpTlsValue
);

void WINAPI TlsShutdown();

# define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)

opencv_winrt.cpp

#include "opencv_winrt.h"
#include <vector>
#include <set>
#include <mutex>
#include "assert.h"


void WINAPI GetSystemInfo(LPSYSTEM_INFO lpSystemInfo)
{
    GetNativeSystemInfo(lpSystemInfo);
}

DWORD WINAPI GetTempPathA(DWORD nBufferLength, char* lpBuffer)
{
    return 0;
}

UINT WINAPI GetTempFileNameA(const char* lpPathName, const char* lpPrefixString, UINT uUnique, char* lpTempFileName)
{
    return 0;
}


// Thread local storage.
typedef std::vector<void*> ThreadLocalData;

static __declspec(thread) ThreadLocalData* currentThreadData = nullptr;
static std::set<ThreadLocalData*> allThreadData;
static DWORD nextTlsIndex = 0;
static std::vector<DWORD> freeTlsIndices;
static std::mutex tlsAllocationLock;

DWORD WINAPI TlsAlloc()
{
    std::lock_guard<std::mutex> lock(tlsAllocationLock);

    // Can we reuse a previously freed TLS slot?
    if (!freeTlsIndices.empty())
    {
        DWORD result = freeTlsIndices.back();
        freeTlsIndices.pop_back();
        return result;
    }

    // Allocate a new TLS slot.
    return nextTlsIndex++;
}


_Use_decl_annotations_ BOOL WINAPI TlsFree(DWORD dwTlsIndex)
{
    std::lock_guard<std::mutex> lock(tlsAllocationLock);

    assert(dwTlsIndex < nextTlsIndex);
    assert(find(freeTlsIndices.begin(), freeTlsIndices.end(), dwTlsIndex) == freeTlsIndices.end());

    // Store this slot for reuse by TlsAlloc.
    try
    {
        freeTlsIndices.push_back(dwTlsIndex);
    }
    catch (...)
    {
        return false;
    }

    // Zero the value for all threads that might be using this now freed slot.
    for each (auto threadData in allThreadData)
    {
        if (threadData->size() > dwTlsIndex)
        {
            threadData->at(dwTlsIndex) = nullptr;
        }
    }

    return true;
}


_Use_decl_annotations_ LPVOID WINAPI TlsGetValue(DWORD dwTlsIndex)
{
    ThreadLocalData* threadData = currentThreadData;

    if (threadData && threadData->size() > dwTlsIndex)
    {
        // Return the value of an allocated TLS slot.
        return threadData->at(dwTlsIndex);
    }
    else
    {
        // Default value for unallocated slots.
        return nullptr;
    }
}


_Use_decl_annotations_ BOOL WINAPI TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue)
{
    ThreadLocalData* threadData = currentThreadData;

    if (!threadData)
    {
        // First time allocation of TLS data for this thread.
        try
        {
            threadData = new ThreadLocalData(dwTlsIndex + 1, nullptr);

            std::lock_guard<std::mutex> lock(tlsAllocationLock);

            allThreadData.insert(threadData);

            currentThreadData = threadData;
        }
        catch (...)
        {
            if (threadData)
                delete threadData;

            return false;
        }
    }
    else if (threadData->size() <= dwTlsIndex)
    {
        // This thread already has a TLS data block, but it must be expanded to fit the specified slot.
        try
        {
            std::lock_guard<std::mutex> lock(tlsAllocationLock);

            threadData->resize(dwTlsIndex + 1, nullptr);
        }
        catch (...)
        {
            return false;
        }
    }

    // Store the new value for this slot.
    threadData->at(dwTlsIndex) = lpTlsValue;

    return true;
}


// Called at thread exit to clean up TLS allocations.
void WINAPI TlsShutdown()
{
    ThreadLocalData* threadData = currentThreadData;

    if (threadData)
    {
        {
            std::lock_guard<std::mutex> lock(tlsAllocationLock);

            allThreadData.erase(threadData);
        }

        currentThreadData = nullptr;

        delete threadData;
    }
}

And I modify the file cvconfig.h: I've commented out every #define, except PACKAGE* and VERSION, and I added #include "opencv_winrt.h" at the end.

score 2 · Answer 3 · answered Feb 28 '13 at 07:32

2

Just a hint - there is a C# wrapper for OpenCV called EmguCV (http://www.emgu.com/wiki/index.php/Main_Page), by looking at the forum posts I see that there is some activity towards using it on Windows 8 but it's hard to tell if it's now working since the posts claiming issues are quite old. I'd suggest you just give it a try and see if this C# wrapper is able to run on Windows Phone 8, I think it should definitely run on Windows 8.

answered Feb 28 '13 at 07:32

Rudolfs Bundulis

11,636
6
33
71

Is windows phone 8 supporting native code? the C# wrapper needs to call native code right? I think winphone 8 only supports managed code. – Min Lin Feb 28 '13 at 07:35
That is the thing i'm not 100% sure about, from what I've read and understood you should be able to run the natvie part of the code on Windows Phone 8 too not just the wrapper, but since I've only read and haven't done an actual project I can't elaborate on this. – Rudolfs Bundulis Feb 28 '13 at 08:00
Did you tried this in windows 8? If yes can you please describe the way i need to add this library to my windows 8 project. I download the source but it seems like a large project. And i don't know where to start and what to do with this code. :( – Stephan Ronald Feb 28 '13 at 09:44
After digging around I found thse - http://stackoverflow.com/questions/14065370/using-opencv-in-a-windows-8-store-app-with-visual-c-2012, http://stackoverflow.com/questions/14088917/using-a-c-library-built-using-visual-c-2010-in-a-windows-8-store-app, http://stackoverflow.com/questions/12831213/knowing-the-reason-of-dll-loading-failed-for-windows-store-app, so as @cedrou suggests you'll have to recompile the binary part of EmguCV as a Windows Runtime Component, so the question is if it's easier to do the same with OpenCV. – Rudolfs Bundulis Mar 01 '13 at 08:43

Open CV Image editing library for windows 8 and windows phone 8

3 Answers3