/*Class: Blog.cpp*/

while(!Myself->is_full_knowledge()) Myself->learn(Myself->enjoy);

Sunday, May 13, 2007

QT fucking Hell

Qt4 with Visual Studio

From qtnode

Contrary to popular belief, you can use Qt4 with Visual Studio to create Open Source software. These instructions are for Qt 4.2.3

[NEW] unable to compile any Qt4 app ? see how to fix the bug that appears after installing service pack1 or .NET Framwork 3.0 click here ( trolltech post http://lists.trolltech.com/qt-intere...ad00584-0.html )

Contents

[hide]

[edit]

Building Qt

[edit]

Obtain and install the Qt source

  1. To start, download the source package: Download Qt (Be sure to download the source package, not the package that installs MinGW. The source package is a .zip file, whereas the binary package for use with MinGW is an executable.)

  2. Unzip your Qt source to a logical location.
    Here are some suggestions:
    C:\Qt\4.2\
    C:\Qt\4.2-msvc2005\ (<-- if for instance you plan on using Visual Studio 2005)

[edit]

Download and install the patch allowing Qt to be compiled with Visual Studio compilers

  1. Download acs-4.2.3-patch1.zip from sourceforge.net.

  2. Unzip the contents of acs-4.2.3-patch1.zip into the directory that you have unzipped the Qt sources.

[edit]

Open a command prompt in the Qt source directory

Run cmd.exe however you prefer, but you must make sure that the Visual Studio compiler files are in your path.

  • If you want to build Qt as a 64-bit library under Windows, all you need to do is use the 64-bit Command Prompt supplied with the Visual Studio Tools.
  • If you are using Microsoft Visual Studio 6.0, try running vcvars32.bat from the command-line.
  • If you are using Microsoft Visual Studio .NET or 2005, go into the program group called 'Visual Studio Tools' and run the command prompt shortcut.
    • Note for Visual C++ 2005 Express users (this may also apply to the non-express version) : make sure you installed the Platform SDK. Step 3 of the Platform SDK installation describes how to add paths to Visual C++. However, you also have to manually add those paths in your environment in order to compile Qt. Here is what you can do before launching the command prompt:
      • Add the three paths (LIB, INCLUDE and PATH) to your vsvars32.bat file, normally found under C:\Program Files\Microsoft Visual Studio 8\Common7\Tools. For example:
@set INCLUDE=C:\Program Files\Microsoft Visual Studio 8\VC\INCLUDE;%INCLUDE%
would become
@set INCLUDE=C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include;
C:\Program Files\Microsoft Visual Studio 8\VC\INCLUDE;%INCLUDE%


A simple way to ensure your environment is setup properly is to see if nmake.exe is in your path:
C:\Qt\4.2> nmake /?

Microsoft (R) Program Maintenance Utility Version 8.00.50727.42
Copyright (C) Microsoft Corporation.  All rights reserved.

Usage:  NMAKE @commandfile
       NMAKE [options] [/f makefile] [/x stderrfile] [macrodefs] [targets]

Options:

....

Once you are sure that you have the Visual Studio compiler in your path and you're at the command prompt in the Qt source directory, you are ready to proceed.

[edit]

Patching the Qt sources

If you have installed the patch files from acs-4.2.2-patch1.zip correctly, then you should be able to patch the Qt sources by running:
C:\Qt\4.2> installpatch42.bat
You should see a lot of action, which is normal, which shows all of the files that are being patched:
C:\Qt\4.2> installpatch42.bat
patching file qconfigure.bat
patching file examples/threads/waitconditions/waitconditions.pro
patching file misc/bcc32pch/Makefile.win32-borland
patching file misc/bcc32pch/bcc32pch.cpp
patching file misc/bcc32pch/bcc32pch.pri
patching file misc/bcc32pch/bcc32pch.pro
patching file mkspecs/win32-bccx/qmake.conf

   [snip]

patching file tools/porting/src/rpptreeevaluator.cpp
patching file tools/porting/src/rpptreewalker.cpp
patching file tools/porting/src/src.pro
Press any key to continue . . .
Now run qconfigure.bat

You are now ready for the next step: configuring your Qt install.

[edit]

Configuring your Qt install (and building qmake)

We will not use the standard configure.exe that ships with Qt. We will use qconfigure.bat, included with the acs-4.2.2-patch1.zip file.

But, if you are not sure about which options you want, run configure.exe with the --help option: 
configure.exe  --help

A list of options will be displayed. Take note of any options that you are interested in. Note that by default, static and debug versions of the library are built - this is usually the appropriate choice for most developers.

Once you have written down (or mentally noted) which options you will use, we will run qconfigure.bat. It will in turn call configure.exe with your chosen options.

qconfigure.bat requires as the first parameter, one of the following compiler choices:

  • msvc <- if you are using Visual Studio 6.0
  • msvc.net <- if you are using Visual Studio .NET (2003)
  • msvc2005 <- if you are using Visual Studio 2005


After the first option, you can pass qconfigure.bat any of the configure.exe you had previously noted. For instance you might type:
C:\Qt\4.2> qconfigure.bat msvc.net -release -no-stl

(This command would produce only the release libraries and would exclude STL support in Qt.)

(Note that if you want to build static libraries instead of shared, see Building static)

You will be prompted 3 times while running qconfigure.bat:

  1. You will be asked to accept the GPL license. Type 'y' followed by to continue.
  2. You will then be informed that qmake is about to be built. Type 'y' followed by to continue. This will take a few moments.
  3. You will then be informed that the Makefiles will be generated. Type 'y' followed by to continue. This will be a short operation.
Once qconfigure.bat has finished, you will be presented with the following message: 
====================================================

You are now ready to build Qt (msvc2005)

If you specified -static, type 'nmake sub-src'
              otherwise, type 'nmake'

To start over, type 'nmake distclean'
and then re-run qconfigure.bat

====================================================

You may run into this bug if you're using Visual Studio 2005 SP1.

[edit]

Building the Qt library

Once configuration and building qmake are completed, you are now ready to build the library. Simply run nmake:
C:\Qt\4.2> nmake

Qt takes a long time to compile. Now is a good time to brew a pot of coffee.

(If you have specified -static as one of your configuration options, see Building static)

[edit]

Setting up your environment

There are multiple approaches to this, but this is a foolproof way to ensure that your newly create Qt libs are usable.

Prepend the Qt bin directory to your PATH. Depending on where you installed your Qt sources, the full path may be similar to:

  • C:\Qt\4.2\bin
  • C:\Qt\4.2-msvc2005\bin
  • C:\Qt\4.2-visual-studio\bin

Ensure that the QMAKESPEC environment variable is set to the appropriate value.

  • If you use Visual Studio 6.0, then win32-msvc is the correct value.
  • If you use Visual Studio .NET (2003), then win32-msvc.net is the correct value.
  • If you use Visual Studio 2005, then win32-msvc2005 is the correct value.

(Note: this is the recommended practice from qtnode. You can use Qt in other ways with different settings, but this way is foolproof.)

To set your environment variables in Windows, please see http://www.cs.usask.ca/grads/wew036/latex/env.html

Note that you may have to re-open a command window before your settings are changed.

To check that your PATH is set correctly:
C:\> qmake -v
QMake version: 2.01a
Using Qt version 4.2 in C:\Qt\4.2\lib
To see if QMAKESPEC is set correctly:
C:\> echo %QMAKESPEC%
win32-msvc2005
[edit]

Testing your install

Please test your install from the command-line first. Follow the Hello World instructions.

[edit]

Creating Visual Studio projects

{Note: The following works with MS Visual Studio 2005 and 2003, and has not been tested on other versions - look for an expanded section of this section later}


To create a project, use the -t and -o options.

Normally, (as in the Hello World example), you would simply type: 

prompt> qmake -project
prompt> qmake

To create a .vcproj which will be used by Visual Studio, we will type: 

prompt> qmake -project -t vcapp -o projectname.pro

In this command, projectname.pro is the desired name of your project file. Be sure to include the extension .pro with your project file name.

From here, you can modify the projectname.pro file if needed. For example, in order to compile an OpenGL project, you should open the file and add QT += opengl at the beginning of the file. You can then continue with: 

prompt> qmake

If the above command is executed as written in a directory that includes source files (either in that directory or in a subdirectory of that directory), a new Visual Studio project file is created:

projectname.vcproj

You can double-click on this vcproj file, or simply type its name in the command window and Visual Studio will create an associated .sln file.

The -t option was used to specify the templates used by qmake. By default, the template is app. The app template creates Makefiles which can be used on the command-line when running nmake. But since we are interest in using the Visual Studio IDE, we want a vcapp which will give us a .vcproj instead of a regular Makefile.

Note that you can also use the -tp vc option instead of -t vcapp. This will prepend vc to the default template (which is normally app).
[edit]

Notes on Creating Visual Studio projects

{Note: This may only apply to static builds. If so move this to Qt4_with_Visual_Studio_and_static_C_runtime, or else remove this note}

You can create the Visual Studio project file with your standard .pro file, using: "qmake -t vcapp".

With Qt 4.2.2 "qmake -t vcapp" forgets about the standard libraries like gdi32.lib comdlg32.lib... The best way to fix this is: you generate the Makefiles using "qmake". You look for the LIBS line in Makefile.* and add the lacking libs with "win32:LIBS +=" to the .pro file. This also applies to the method described above.

[edit]

Maintaining Visual Studio Projects

To add files to your project, you can edit your .pro file and re-run qmake. The only problem is that any customizations to your .vcproj will be lost. However, changes made to the .sln are kept and you can simply reopen the solution file after updating the .vcproj.

Can someone see if there is a better way to deal with both .pros and .slns?

[edit]

Another way for creating and maintaining Visual Studio Projects

This should be a little better way to deal with Qt and Visual Studio: You only have to maintain a .pro File, and you can use the normal build buttons in Visual Studio, and you get errors and so on shown in VS. This is written for Visual Studio.Net 2003, but should also work with Visual Studio 2005 (may somebody try please? - yes it does)

First you create a new Makefile Project in a empty solution. Then go to the project Property Pages (right click project->Properties). Make sure that Debug is the current Configuration and choose "NMake" in the left menu. Then open the Window for "Build command Line" by clicking the "..." Button. Here you enter: 

%QTDIR%\bin\qmake
nmake debug

In "Rebuild Command Line" you enter: 

%QTDIR%\bin\qmake
nmake debug-clean
nmake debug

And in "Clean Command Line": 

%QTDIR%\bin\qmake
nmake debug-clean

Now the last change, in "Output" enter: 

debug\[you app Name].exe

Now do the same thing for release Configuration, but substitute "debug" with "release" ( also in Output Path!)

Now confirm this dialog with OK and create a new File. To do so right click your project and choose Add->Add new Files. Here choose "Text File (.txt)" and as name enter "src.pro", or something similar. In this file enter: 

TEMPLATE = app
CONFIG  += qt [do you config here, mine would be: "qt warn_on"]
QT  += [do you qt-config here]
SOURCES  = main.cpp
HEADERS  =
TARGET  = [your App Name]

win32:debug:CONFIG += console [->if you want to receive qDebug() messages on Windows...]

Save this file and add another file to your project: main.cpp, do it as you did it with the pro File, but choose "C++ File (.cpp)" as file type.

If you want to add another source file to your project, just add it with the add menu, and don't forget to add the files to the right section in your pro-File. This pro file can be used like any normal pro-File, without any problems.

To give you a better start-off here is a little example solution: Image:Visual studio example project 1.zip


[edit]

Buildproblems with Visual Studio 2005 and service pack 1

After installing service pack 1 for Visual Studio 2005 you will get compiler errors like this one: 

c:\qt\4.1.4\include\qtcore\../../src/corelib/tools/qhash.h(805) : error C2244: 'QMultiHash::replace' : unable to match function definition to an existing declaration
       c:\qt\4.1.4\include\qtcore\../../src/corelib/tools/qhash.h(790) : see declaration of 'QMultiHash::replace'
       definition
       'QHash::iterator QMultiHash::replace(const Key &,const T &)'
       existing declarations
       'QHash::iterator QMultiHash::replace(const Key &,const T &)'

This is because of a regression in the compiler and can not be solved by Trolltech.

There are two ways to solve the problem:

  • (NEW) you can download the fix by going to [1] and then English>Visual Studio 2005>VS80sp1-KB930859-X86-ENU.exe for more information you can look at the post on the Qt forum [2] (This fix work perfectly !)
  • (Not recommended) you can patch the Qt libray

The patch for the QMap sourcecode: 

==== //depot/qt/4.2/src/corelib/tools/qmap.h#3 - f:\depot_vs2005\qt-4.2\src\corelib\tools\qmap.h ====
302a303,304
>    
>     typedef typename QMap::iterator DummyMapIterator;
883,884c885,886
<>::iterator replace(const Key &key, const T &value);
<>::iterator insert(const Key &key, const T &value);
---
>     inline typename DummyMapIterator replace(const Key &key, const T &value);
>     inline typename DummyMapIterator insert(const Key &key, const T &value);

And the patch for the QHash sourcecode: 

==== //depot/qt/4.2/src/corelib/tools/qhash.h#2 - f:\depot_vs2005\qt-4.2\src\corelib\tools\qhash.h ====
386a387,388
>     typedef typename QHash::iterator DummyHashIterator;
>    
841,842c843,844
<>::iterator replace(const Key &key, const T &value);
<>::iterator insert(const Key &key, const T &value);
---
>     inline typename DummyHashIterator replace(const Key &key, const T &value);
>     inline typename DummyHashIterator insert(const Key &key, const T &value);

This patch works for Qt 4.2.2 but you'll need these for Qt 4.2.3: 

==== //depot/qt/4.2.3/src/corelib/tools/qmap.h#3 - f:\depot_vs2005\qt-4.2.3\src\corelib\tools\qmap.h ====
244a245,246
>     typedef typename QMap::iterator DummyMapIterator;
>
893,894c896,897
<>::iterator replace(const Key &key, const T &value);
<>::iterator insert(const Key &key, const T &value);
---
>     inline typename DummyMapIterator replace(const Key &key, const T &value);
>     inline typename DummyMapIterator insert(const Key &key, const T &value);

and 

=== //depot/qt/4.2.3/src/corelib/tools/qhash.h#2 - f:\depot_vs2005\qt-4.2.3\src\corelib\tools\qhash.h ====
329a330,331
>     typedef typename QHash::iterator DummyHashIterator;
>
851,852c853,854
<>::iterator replace(const Key &key, const T &value);
<>::iterator insert(const Key &key, const T &value);
---
>     inline typename DummyHashIterator replace(const Key &key, const T &value);
>     inline typename DummyHashIterator insert(const Key &key, const T &value);

If you're trying to apply this manually, the trick is to put the typedef for the dummy iterator right after the friend declaration for the iterator in QMap or QHash.

Retrieved from "http://qtnode.net/wiki/Qt4_with_Visual_Studio"
Posted by at 1 comment:

Wednesday, May 09, 2007

Relationships Among MFC Objects


To help put the document/view creation process in perspective, consider a running program: a document, the frame window used to contain the view, and the view associated with the document.

  • A document keeps a list of the views of that document and a pointer to the document template that created the document.

  • A view keeps a pointer to its document and is a child of its parent frame window.

  • A document frame window keeps a pointer to its current active view.

  • A document template keeps a list of its open documents.

  • The application keeps a list of its document templates.

  • Windows keeps track of all open windows so it can send messages to them.

These relationships are established during document/view creation. The following table shows how objects in a running program can access other objects. Any object can obtain a pointer to the application object by calling the global function AfxGetApp.

Gaining Access to Other Objects in Your Application
From object How to access other objects

Document

Use GetFirstViewPosition and GetNextView to access the document's view list.

Call GetDocTemplate to get the document template.

View

Call GetDocument to get the document.

Call GetParentFrame to get the frame window.

Document frame window

Call GetActiveView to get the current view.

Call GetActiveDocument to get the document attached to the current view.

MDI frame window

Call MDIGetActive to get the currently active CMDIChildWnd.

Typically, a frame window has one view, but sometimes, as in splitter windows, the same frame window contains multiple views. The frame window keeps a pointer to the currently active view; the pointer is updated any time another view is activated.

NoteNote

A pointer to the main frame window is stored in the m_pMainWnd member variable of the application object. A call to OnFileNew in your override of the InitInstance member function of CWinApp sets m_pMainWnd for you. If you do not call OnFileNew, you must set the variable's value in InitInstance yourself. (SDI COM component (server) applications may not set the variable if /Embedding is on the command line.) Note that m_pMainWnd is now a member of class CWinThread rather than CWinApp.

Posted by at No comments:

Monday, May 07, 2007

How to: Convert Between Various String Types

Converting from char *

Example

This example demonstrates how to convert from a char * to the other string types listed above.

// convert_from_char.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

using namespace std;
using namespace System;

int main()
{
   char *orig = "Hello, World!";
   cout << orig << " (char *)" << endl;

   // Convert to a wchar_t*
   size_t origsize = strlen(orig) + 1;
   const size_t newsize = 100;
   size_t convertedChars = 0;
   wchar_t wcstring[newsize];
   mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE);
   wcscat_s(wcstring, L" (wchar_t *)");
   wcout << wcstring << endl;

   // Convert to a _bstr_t
   _bstr_t bstrt(orig);
   bstrt += " (_bstr_t)";
   cout << bstrt << endl;

   // Convert to a CComBSTR
   CComBSTR ccombstr(orig);
   if (ccombstr.Append(L" (CComBSTR)") == S_OK)
   {
       CW2A printstr(ccombstr);
       cout << printstr << endl;
   }

   // Convert to a CString
   CString cstring(orig);
   cstring += " (CString)";
   cout << cstring << endl;

   // Convert to a basic_string
   string basicstring(orig);
   basicstring += " (basic_string)";
   cout << basicstring << endl;

   // Convert to a System::String
   String ^systemstring = gcnew String(orig);
   systemstring += " (System::String)";
   Console::WriteLine("{0}", systemstring);
   delete systemstring;
}

Output

Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)

Converting from wchar_t *

Example

This example demonstrates how to convert from a wchar_t * to the other string types listed above.

// convert_from_wchar_t.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

using namespace std;
using namespace System;

int main()
{
   wchar_t *orig = L"Hello, World!";
   wcout << orig << L" (wchar_t *)" << endl;

   // Convert to a char*
   size_t origsize = wcslen(orig) + 1;
   const size_t newsize = 100;
   size_t convertedChars = 0;
   char nstring[newsize];
   wcstombs_s(&convertedChars, nstring, origsize, orig, _TRUNCATE);
   strcat_s(nstring, " (char *)");
   cout << nstring << endl;

   // Convert to a _bstr_t
   _bstr_t bstrt(orig);
   bstrt += " (_bstr_t)";
   cout << bstrt << endl;

   // Convert to a CComBSTR
   CComBSTR ccombstr(orig);
   if (ccombstr.Append(L" (CComBSTR)") == S_OK)
   {
       CW2A printstr(ccombstr);
       cout << printstr << endl;
   }

   // Convert to a CString
   CString cstring(orig);
   cstring += " (CString)";
   cout << cstring << endl;

   // Convert to a basic_string
   wstring basicstring(orig);
   basicstring += L" (basic_string)";
   wcout << basicstring << endl;

   // Convert to a System::String
   String ^systemstring = gcnew String(orig);
   systemstring += " (System::String)";
   Console::WriteLine("{0}", systemstring);
   delete systemstring;
}

Output

Hello, World! (wchar_t *)
Hello, World! (char *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)

Converting from _bstr_t

Example

This example demonstrates how to convert from a _bstr_t to the other string types listed above.

// convert_from_bstr_t.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

using namespace std;
using namespace System;

int main()
{
   _bstr_t orig("Hello, World!");
   wcout << orig << " (_bstr_t)" << endl;

   // Convert to a char*
   const size_t newsize = 100;
   char nstring[newsize];
   strcpy_s(nstring, (char *)orig);
   strcat_s(nstring, " (char *)");
   cout << nstring << endl;

   // Convert to a wchar_t*
   wchar_t wcstring[newsize];
   wcscpy_s(wcstring, (wchar_t *)orig);
   wcscat_s(wcstring, L" (wchar_t *)");
   wcout << wcstring << endl;

   // Convert to a CComBSTR
   CComBSTR ccombstr((char *)orig);
   if (ccombstr.Append(L" (CComBSTR)") == S_OK)
   {
       CW2A printstr(ccombstr);
       cout << printstr << endl;
   }

   // Convert to a CString
   CString cstring((char *)orig);
   cstring += " (CString)";
   cout << cstring << endl;

   // Convert to a basic_string
   string basicstring((char *)orig);
   basicstring += " (basic_string)";
   cout << basicstring << endl;

   // Convert to a System::String
   String ^systemstring = gcnew String((char *)orig);
   systemstring += " (System::String)";
   Console::WriteLine("{0}", systemstring);
   delete systemstring;
}

Output

Hello, World! (_bstr_t)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)

Converting from CComBSTR

Example

This example demonstrates how to convert from a CComBSTR to the other string types listed above.

// convert_from_ccombstr.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

int main()
{
   CComBSTR orig("Hello, World!");
   CW2A printstr(orig);
   cout << printstr << " (CComBSTR)" << endl;

   // Convert to a char*
   const size_t newsize = 100;
   char nstring[newsize];
   CW2A tmpstr1(orig);
   strcpy_s(nstring, tmpstr1);
   strcat_s(nstring, " (char *)");
   cout << nstring << endl;

   // Convert to a wchar_t*
   wchar_t wcstring[newsize];
   wcscpy_s(wcstring, orig);
   wcscat_s(wcstring, L" (wchar_t *)");
   wcout << wcstring << endl;

   // Convert to a _bstr_t
   _bstr_t bstrt(orig);
   bstrt += " (_bstr_t)";
   cout << bstrt << endl;

   // Convert to a CString
   CString cstring(orig);
   cstring += " (CString)";
   cout << cstring << endl;

   // Convert to a basic_string
   wstring basicstring(orig);
   basicstring += L" (basic_string)";
   wcout << basicstring << endl;

   // Convert to a System::String
   String ^systemstring = gcnew String(orig);
   systemstring += " (System::String)";
   Console::WriteLine("{0}", systemstring);
   delete systemstring;
}

Output

Hello, World! (CComBSTR)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)

Converting from CString

Example

This example demonstrates how to convert from a CString to the other string types listed above.

// convert_from_cstring.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

using namespace std;
using namespace System;

int main()
{
   CString orig("Hello, World!");
   wcout << orig << " (CString)" << endl;

   // Convert to a char*
   const size_t newsize = 100;
   char nstring[newsize];
   strcpy_s(nstring, orig);
   strcat_s(nstring, " (char *)");
   cout << nstring << endl;

   // Convert to a wchar_t*
   // You must first convert to a char * for this to work.
   size_t origsize = strlen(orig) + 1;
   size_t convertedChars = 0;
   wchar_t wcstring[newsize];
   mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE);
   wcscat_s(wcstring, L" (wchar_t *)");
   wcout << wcstring << endl;

   // Convert to a _bstr_t
   _bstr_t bstrt(orig);
   bstrt += " (_bstr_t)";
   cout << bstrt << endl;

   // Convert to a CComBSTR
   CComBSTR ccombstr(orig);
   if (ccombstr.Append(L" (CComBSTR)") == S_OK)
   {
       CW2A printstr(ccombstr);
       cout << printstr << endl;
   }

   // Convert to a basic_string
   string basicstring(orig);
   basicstring += " (basic_string)";
   cout << basicstring << endl;

   // Convert to a System::String
   String ^systemstring = gcnew String(orig);
   systemstring += " (System::String)";
   Console::WriteLine("{0}", systemstring);
   delete systemstring;
}

Output

Hello, World! (CString)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (basic_string)
Hello, World! (System::String)

Converting from basic_string

Example

This example demonstrates how to convert from a basic_string to the other string types listed above.

// convert_from_basic_string.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"

using namespace std;
using namespace System;

int main()
{
   string orig("Hello, World!");
   cout << orig << " (basic_string)" << endl;

   // Convert to a char*
   const size_t newsize = 100;
   char nstring[newsize];
   strcpy_s(nstring, orig.c_str());
   strcat_s(nstring, " (char *)");
   cout << nstring << endl;

   // Convert to a wchar_t*
   // You must first convert to a char * for this to work.
   size_t origsize = strlen(orig.c_str()) + 1;
   size_t convertedChars = 0;
   wchar_t wcstring[newsize];
   mbstowcs_s(&convertedChars, wcstring, origsize, orig.c_str(), _TRUNCATE);
   wcscat_s(wcstring, L" (wchar_t *)");
   wcout << wcstring << endl;

   // Convert to a _bstr_t
   _bstr_t bstrt(orig.c_str());
   bstrt += " (_bstr_t)";
   cout << bstrt << endl;

   // Convert to a CComBSTR
   CComBSTR ccombstr(orig.c_str());
   if (ccombstr.Append(L" (CComBSTR)") == S_OK)
   {
       CW2A printstr(ccombstr);
       cout << printstr << endl;
   }

   // Convert to a CString
   CString cstring(orig.c_str());
   cstring += " (CString)";
   cout << cstring << endl;

   // Convert to a System::String
   String ^systemstring = gcnew String(orig.c_str());
   systemstring += " (System::String)";
   Console::WriteLine("{0}", systemstring);
   delete systemstring;
}

Output

Hello, World! (basic_string)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (System::String)

Converting from System::String

Example

This example demonstrates how to convert from a System.String to the other string types listed above.

// convert_from_system_string.cpp
// compile with: /clr /link comsuppw.lib

#include 
#include 
#include 

#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

int main()
{
   String ^orig = gcnew String("Hello, World!");
   Console::WriteLine("{0} (System::String)", orig);

   pin_ptr wch = PtrToStringChars(orig);

   // Convert to a char*
   size_t origsize = wcslen(wch) + 1;
   const size_t newsize = 100;
   size_t convertedChars = 0;
   char nstring[newsize];
   wcstombs_s(&convertedChars, nstring, origsize, wch, _TRUNCATE);
   strcat_s(nstring, " (char *)");
   cout << nstring << endl;

   // Convert to a wchar_t*
   wchar_t wcstring[newsize];
   wcscpy_s(wcstring, wch);
   wcscat_s(wcstring, L" (wchar_t *)");
   wcout << wcstring << endl;

   // Convert to a _bstr_t
   _bstr_t bstrt(wch);
   bstrt += " (_bstr_t)";
   cout << bstrt << endl;

   // Convert to a CComBSTR
   CComBSTR ccombstr(wch);
   if (ccombstr.Append(L" (CComBSTR)") == S_OK)
   {
       CW2A printstr(ccombstr);
       cout << printstr << endl;
   }

   // Convert to a CString
   CString cstring(wch);
   cstring += " (CString)";
   cout << cstring << endl;

   // Convert to a basic_string
   wstring basicstring(wch);
   basicstring += L" (basic_string)";
   wcout << basicstring << endl;

   delete orig;
}

Output

Hello, World! (System::String)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Posted by at No comments:

Sunday, May 06, 2007

Computer Vision Software

The Software is grouped into the following categories 3D, contours, display tools, features, ocr, mathematical toolkits, pattern recognition, stereo, synthetic data generators, texture, toolkits, tracking, misc.

3D

Contours

  • Segmentation of Skin-Cancer Images Implementation of an algorithm for segmenting images of skin cancer and other pigmented lesions (see Image and Vision Computing, January 1999, pp. 65-74).
    An automatic method for segmention of images of skin cancer and other pigmented lesions is implemented. This method first reduces a color image into an intensity image and approximately segments the image by intensity thresholding. Then, it refines the segmentation using image edges. Double thresholding is used to focus on an image area where a lesion boundary potentially exists. Image edges are then used to localize the boundary in that area. A closed elastic curve is fitted to the initial boundary and is locally shrunk or expanded to approximate edges in its neighborhood in the area of focus. Segmentation results from twenty randomly selected images show an average error that is about the same as that obtained by four experts manually segmenting the images. (by L. Xu, M. Jackowski, A. Goshtasby, C. Yu, D. Roseman, S. Bines, A. Dhawan, A. Huntley / Intelligent Systems Laboratory / Wright State University)

Display Tools

  • The FreeImage Library at Sourceforge
  • 3DViewnix - Demo of a commercial package.
  • FP Image - View/Process Floating Point and integer images in Windows 95/98/NT. Formats include DICOM and user defined formats. Includes a image processing scripting language.
  • FP Image for Windows - Scientific/Medical imaging software. Formats include floating point, integer and DICOM. Built-in image processing scripting language, batch processing, 3D solid modeling. ( FP Image)
  • FreeImage - FreeImage is an Open Source project for developers who would like to support popular graphics image formats like BMP, JPEG, TIFF, PNG, RAS, PNM, PCX, TGA in their C++ applications for Windows. (by Floris van den Berg, Hervé Drolon)
  • GD - a graphics library for GIF creation - provides GIF read/write code in a C library. It also provides minimal image manipulation functions (lines, arcs, text, colors). Includes versions for Unix and Windows systems. (by Thomas Boutell / Boutell.Com)
  • Ghostscript and ghostview - PostScript previewer and pretty user interface for X11.
    MSDOS Ghostscript and supplemental font files are also available.
  • GNU Image Manipulation Program (GIMP) - Photoshop-style image editor.
  • ImageMagick - Load, display, process, save, and convert images in many formats. Works on Unix, Linux, Windows, and Mac. Includes a display program, a converter, screen capture, animator, and more.
  • Imaging Primer - Interactive and comprehensive images analysis and processing software for windows95 (commercial product). (by Pepi Cima / Rio Grande Software)
  • JPEG - Library source code and simple display tools.
  • Mesa - OpenGL implementation.
  • MPEG-1 player and encoder
    Also: FAQ and fancy VCR-like interface using Motif.
  • NIH Image - for Macintosh
  • TIFF - Library source code and tools
  • Volumetric Image Display and Analysis (VIDA) - Demo of a commercial package.
  • XAnim - X11 display tool.
    Supports many animation and image formats ("everything" except mpeg). Notes on integrating xanim with Web clients/MIME are also available.
  • XLI - X11 display tool.
    Not as featureful as xv but it understands nearly all the same formats and displays images much more quickly. Source archive is available.
  • XV - X11 Image Display tool.
    Provides an amazing assortment of image operators, reads and writes images in many different formats.
  • Ygl - Emulation of SGI GL library for X11.

Features

OCR

Mathematical Toolkits

  • CGAL - Computational Geometry Algorithms Library - C++ library of geometric primitives and standard data structures and algorithms used in computational geometry.
    The CGAL project is a collaborative effort to develop a robust, easy to use, and efficient C++ software library of geometric data structures and algorithms. The CGAL library contains: - Basic geometric primitives such as points, vectors, lines, predicates such as for relative positions of points, and operations such as intersections and distance calculation. - A collection of standard data structures and geometric algorithms, such as convex hull, (Delaunay) triangulation, planar map, polyhedron, smallest enclosing sphere, and multidimensional query structures. - Interfaces to other packages, e.g. for visualisation, and I/O, and other support facilities. For further information and for downloading the library and documentation, please visit the CGAL web page: http://www.cs.uu.nl/CGAL/ Should you have any questions or comments, please send a message to cgal@cs.uu.nl ( CGAL Consortium)
  • Netlib - Public domain collection of mathematical software, papers, and databases.
    Mostly in Fortran, but f2c (included in netlib) converts Fortran to C.
  • Numerical Recipies - Public Domain code for the famous book (only some of the code is public domain).
  • Reviver - A Practical Provable Surface Reconstructor - Free software that takes unorganised point clouds as input and produces 3D models automatically in various industry standard formats (runs on Unix and Windows)
  • StatLib - Statistical software, datasets, and information.

Pattern Recognition

Stereo

  • Camera Calibration Routines for calibrating using Roger Tsai's perspective projection camera model. (by Reg Willson / CMU)
  • Disparity Analysis of Images This java-based application estimates the disparity between two images. It works by first detecting remarkable points in both images and then finding the best possible match between the two sets of points. (by Lionel Le Briquer)
  • Maximum-Flow Stereo Algorithm Code for the maximum-flow formulation of the N camera stereo correspondence problem. (by Sebastien Roy / Université de Montréal)
  • Microsoft Easy Camera Calibration Tool a flexible camera calibration technique, which only requires the camera to observe a planar pattern shown at a few (at least two) different (unknown) orientations. (by Zhengyou Zhang / Vision Technology Group / Microsoft Corp.)
  • Projective Vision Toolkit PVT is a series of utilities that allows one to take an image sequence and compute the fundamental matrix and trilinear tensor.
    This can be used for such problems as camera self-calibration, structure from motion, camera motion annotation, image stabilization, 3D tracking and recognition, etc. (Computational Video Group of NRC)
  • SRI Stereo Engine Software - fast stereo software for PCs. It performs disparity calculations and filtering in real time on images up to 320x240 in size. ( SRI Artificial Intelligence Center / SRI International)
  • Uncalibrated Stereo by Singular Value Decomposition This stereo algorithm allows to match features across a pair of stereo images with unparalleled algorithmic simplicity and neatness. Results are comparable to complex relaxation methods. Its simple implementation has made it a good off-the-shelf solution for a number of researchers needing a fast a easy-to-integrate matching module. (by Maurizio Pilu / Hewlett Packard Research Laboratories)

Synthetic Data Generators

Texture

  • MeasTex A framework for quantitative measurement of image texture classification algorithms.

Toolkits

  • Gandalf Gandalf is a computer vision and numerical algorithm library, written in C, which allows you to develop new applications that will be portable and run FAST. Includes many useful vision routines, including camera calibration, homographies, fundamental matrix computation, and feature detectors (includes source code).
    Dynamically reconfigurable vector, matrix and image structures in Gandalf allow efficient use of memory. Gandalf has been used to develop the "MoKey" motion editing software, released at IBC'2001 in Amsterdam. MoKey performs automatic inpainting of moving objects over an image sequence, and can also be used to compute an accurate alpha matte or outline of an object. Gandalf currently contains four packages: 1) Common package of simple structures and routines used by the other packages, such as memory allocation, linked lists and error handling; 2) Linear algebra package with a large number of routines for matrix and vector manipulations; 3) Image package defining a general purpose image structure and low-level image manipulation routines; 4) Vision package containing a number of standard image processing, computer vision and numerical routines. The major design features of Gandalf are: (i) Efficient use of memory through dynamically reconfigurable structures; (ii) Emphasis on support of numerical algorithms, especially optimisation; (iii) A very flexible and efficient internal image representation, (iv) A comprehensive set of matrix/vector operations, incorporating implicit matrix transpose & inverse, and in-place computation where appropriate; Exploitation of the computational and compilation speed advantages of C over C++ in reducing the number of layers of abstraction over the raw data, an approach we believe is appropriate for simple objects such as matrices, vectors and images. The documentation for Gandalf comes in two parts. There is a LaTex tutorial with examples available also in HTML (via Latex2html). Reference documentation for Gandalf has also been generated using ObjectOutline, ( by Philip McLauchlan)
  • Intel Open Source Computer Vision Library Computer vision routines, applications and tutorials. Open Source, FREE for academic AND commercial use. Assembly language optimized on Intel's processor line. Areas covered are Geometric Methods, Recognition, Image Pyramids Camera Calibration, Tracking, and Fitting. (by Vadim Pisarevsky, Dmitry Abrosimov , Jean-Yves Bouguet , Gary R. Bradski , Valery Cherepennikov , Michael Chu , Boris Chudinovich , Prof. Trevor , Bob Davies , Prof. James Davis , Victor Eroukhimov , Prof. Irfan Essa , Radek Grzeszczuk , Mark Holler , Prof. Jitendra Malik , Sergey Molinov , Valery Mosyagin , Ara Nefian , Sergey Oblomov , Prof. Pietro Perona , Vadim Pisarevsky, Alexander Pleskov, Chuck Richards, Prof. Stan Scarloff, Stewart Taylor, Prof. Carlo Tomasi / Visual Interactivity Lab / Intel Corporation)
  • University of Calgary vision software Includes chain code, Hough transform, and others.
  • VXL - C++ libraries for Computer Vision The Vision-something-Libraries are a collection of C++ libraries designed for computer vision research. It was created from TargetJr and the Image Understanding Environment (IUE) with the aim of making a lighter, faster and more consistent system. VXL is written in ANSI/ISO C++ and is designed to be portable over many platforms. It is developed and used by a consortium including groups from the Universities of Leuven, Oxford, Manchester, and RPI, GE CRD. ( VXL Consortium)
  • AcquireNow - A real-time image acquisition and processing product. (Commercial product $$).
    The product includes a COM (Component Object Model) component, which allows developers to create powerful imaging applications quickly and easily using COM supported languages such as C++ and Visual Basic. The AcquireNow package include the AcquireNowClient application. AcquireNowClient is a stand-alone application, which can be used to acquire, display, and save images to disk. The AcquireNowClient application also allows the user to perform real time image averaging, scaling and flat fielding. Source code for the AcquireNowClient application is included, and can be used by customers as a base for their own imaging applications. ( Boulder Imaging, Inc.)
  • AdOculos - PC-based image processing without the need of extensive programming knowledge
    The following image processing functions are realized as DLLs. The complete C source code of these DLLs is part of the standard pack. Point, local and global, morphological operations Texture, image sequence Histograms procedures Hough and color transformations Automatic counting and interactive measuring Pattern recognition, graylevel profile General purpose and display functions ( The Imaging Source)
  • Aphelion - Commercial image processing and understanding package for Windows. Features a rapid prototyping environment, image processing and object recognition libraries, and a vision tutorial.
    Aphelion is a commercial software product which can be used to quickly develop vertical imaging applications. It is a comprehensive and powerful development environment and a delivery vehicle for image-based applications, including a Graphical User Interface, Image Processing libraries available as DLLs or ActiveX components, a Visual Basic compatible scripting language, a chart server, etc. Aphelion provides the very latest developments in mathematical morphology and symbolic representation/recognition, as well as effective tools for quantitative analysis, microscopy, pattern recognition, and classification. (by Bruno Lay / Amerinex Applied Imaging Inc.)
  • AutoTrace - AutoTrace converts bitmap to vector graphics (by Martin Weber)
  • Bersoft Image Measurement - Measure length, angle, segments, perimeter and area in digital images. Commercial package for windows.
    Bersoft Image Measurement runs under Windows 9.x/NT and it is intended to measure length, angle, segments, perimeter and area in digital images. It can be used in multiple scientific disciplines, such as Biology, Ecology, Geography, Agronomy, and Natural Sciences. It also can export matrixes (Exporting RGB values) with the decimal or hexadecimal values of the image pixels. The DEMO version can realize all the functions, but only over images saved in a propietary format: Image Bersoft Bitmap (bim extension). ( Bersoft)
  • Clemex Vision - Commercial software for analysis of images from microscopes.
  • Color Reduction and Multithresholding - Free image processing software for color reduction and quantization, multithresholding, Hough Transform etc. (Image and Multimedia Laboratory / Democritus University of Thrace, Greece)
  • Common Vision Blox - A modular and open software development platform to solve image processing and machine vision applications (Windows, Commercial product) ( Stemmer Imaging GmbH)
  • Computer Vision Workshop - An image analysis tool based on the Vista software environment
  • CppIma - C++ image processing library.
  • CVIPtools - GUI-based computer vision and image processing tools, ANSI-C source code and libraries for Windows95/NT and UNIX, extended computer imaging TCL shell.
    Also contains an extended Tcl shell with all the computer imaging functions. ANSI-C source code and libraries for image analysis, image compression, image enhancement, image restoration, and many imaging utilities. Used for both research and education, as well as applications development. (by Scott E Umbaugh, Greg Hance, Arve Kjoelen, Kun Luo, Mark Zuke, Yansheng Wei and others / CVIP Group / Southern Illinois University at Edwardsville)
  • DTU Image Viewer and Analyser - The DIVA consists of a number of image analysis functions collected in C++ template image classes and a windows interface, which handles a wide variety of different image file formats and pixel types. Everything is available as source code. (Section for Image Analysis / Technical University of Denmark)
  • eVision - Commercial image processing and analysis toolkit for use in industrial applications on Windows platforms. There is also a rapid prototyping development environment called EasyAccess.
    eVision provides all familiar tools in image processing such as image linear and morphological filtering, projections, profiles, geometric transforms, color conversions, blob analysis, pattern matching as well as application libraries such as OCR, matrix code reading, mark inspection. These tools are provided in a form well suited for rapid application development and are extremely fast. ( Euresys)
  • Exbem: Scientific Image Processing & Analysis - Exbem is a software for scientific image processing & analysis under MacOS. Exbem handles images, QuickTime movies, and live-video. Multiple operators can be assigned to multiple ROIs. ( Pixlock e.K. (company))
  • Graphics Gems - Generally useful graphics and image processing subroutines from the similarly-named books.
  • GRASS - Geographic Information System
  • HALCON - a commercial computer vision tool consisting of an image processing library, C and C++ interfaces, and a rapid prototyping tool called HDevelop.
    HALCON is manufactured by MVTec, which is a spin-off of the Technische Universität München and the Bavarian Research Center for Knowledge Based Systems (FORWISS). The company is specialized in software solutions for image processing using standard hardware and framegrabbers. HALCON covers a wide field of applications like factory automation, quality control, medical image analysis, aerial image analyis, surveillance, research, and education. ( MVTec Software GmbH)
  • HIPS - General Unix-based Image Processing System with C source code (Commercial package $$)
    HIPS is a software package for image processing that runs under the UNIX operating system. HIPS is modular and flexible, it provides automatic documentation of its actions, and is almost entirely independents of special equipment. It handles sequences of images (movies) in precisely the same manner as single frames. Over 200 such image transformation programs have been developed. HIPS is written in C, provided as source code, and is both a set of separate programs as well as a callable library. (by Michael S. Landy)
  • ILIB Imaging Libraries - commercial package of image processing libraries for the Windows environment (C/C++ interface). It also includes neural and genetic imaging capabilities. ( Inventions)
  • Image Processing Library - The main purpose of Image Processing Library (IPL) is to simplify image processing under Windows environment. ( Medical Imaging Lab)
  • Image Processing Library 98 - A platform independent image manipulating C/C++ library
    The purpose of the library is to be useful, for combining tailor-made image processing and interpretation with standard methods for acquisitions, processing, display and storage of image information. Emphasis is put on interactivity in projects made by students, as well as for advanced research and development. (by Ivar Balslev and René Dencker / The Maersk Mc-Kinney Moller Institute for Production Technology / University of Southern Denmark, Odense University)
  • Image-Pro Plus - Commercial image analysis software used in biological and industrial microscopy applications.
  • ImageLib - An Image Processing C++ Class Library (template based)
    ImageLib is a C++ class library providing image processing and related facilities. The main set of classes provides a variety of image and vector types, with additional modules supporting scalar and vector quantisation, wavelet transforms, DCT transforms, and simple histogram operations. (by Brendt Wohlberg / University of Cape Town)
  • IMAQ Vision - Adds machine vision and image processing functionality to LabVIEW and ActiveX containers (National Instruments)
  • ImgStar Image Processing Tools - Complements Pbmplus with edge detection, high/low/band-pass filters, thresholding, etc. (by Simon Winder)
  • ImLib3D - ImLib3D is an open source C++ library for 3D (volumetric) image processing. It comes with an optional viewer that features 3D (OpenGL) multiplanar.
    Templated: ImLib3D images are STL-like templated containers. This means you can create images of arbitrary types (examples: float, int, complex, 3D vectors for deformation fields, ...) Iterators: ImLib3D provides STL-like iterators for moving around images. This provides a much faster, more efficient and easier to use framework. This also provides a common simple syntax for moving around images in special ways, like in masked images or rectangular sub-zones in an image. Speed: ImLib3D is very fast. Iterators hide all the gory details of making it fast. Command line: All image processing operators can be called from the unix command line. This is, with the viewer, important for easy image processing experimentation. Fast BSpline interpolation (thanks to Unser et all.) Rigid, affine, deformable registration (thanks to O.Musse) Very fast fft (thanks to fftw) Image processing (arithmetic,convolution,morphological operations...) 3D image viewer. (by Marcel Bosc, Torbjorn Vik / LSIIT/IPB ULP Strasbourg France)
  • Intel Image Processing Library - Optimized assembly MMX code for image processing, pattern recognition, signal processing, and matrix manipulation (no source - but still free) ( Performance Library Suite / Intel Corporation)
  • Interactive Data Language (IDL) - IDL is a development environment for data visualization, 2D and 3D graphics, and image processing.
  • IPTool - Freeware image processing toolkit for Windows
  • Khoros - An integrated software environment for data exploration and visualization, visual programming and simulation, and sofware development.
  • LEADTOOLS Imaging Development Toolkit - commercial toolkit that supports loading, saving, converting, and processing of color, greyscale, and document images - Windows-based
    commercial toolkit that ( LEAD Technologies, Inc.)
  • LookingGlass Real-time ImageProcessing System - multithreaded PC-based image proccessing environment that supports realtime video processing.
    LookingGlass is an Image Processing Environment for developing imaging applications and for research and development of new image system. LookingGlass supports real-time live video processing from VideoForWindow compatible device, and also supports BMP, JPG, GIF89 and AVI or user can write a dll to support other vdo format or image acquisition device. LookingGlass can produce AVI file, sequence of BMP or JPG files, or just display images to screen, or users can write a dll to do what ever output they want. LookingGlass is derived from RobotVision2(http://www.ccs.neu.edu/home/psksvp/rv2.htm), so LookingGlass uses the pipeline idea and support using the same IP-DLL as RobotVision2. (by PongSuvan)
  • Matlab Pyramid Tools - MatLab tools for multi-scale (pyramid) image decomposition.
    This includes Laplacian pyramids, QMFs/wavelets, and steerable pyramids as well as fast convolution routines, histogram tools, and synthetic image generation.
  • Matrox Imaging - Matrox Imaging Library (MIL) is a development toolkit for machine vision, medical imaging and image analysis. ActiveMIL, a collection of ActiveX controls for managing image capture, transfer, processing, analysis and display is bundled with MIL. Additional software includes Matrox Inspector, an interactive Microsoft® Windows®-based prototyping tool and an intelligent camera interface utility.
  • Microsoft Vision SDK - Visual C++ library for vision which defines an image object and supports digitizer independent image acquisition.
  • Multi-Threaded Image Processing - commercial Image Processing Environment with ISO12087 based "drag and drop" modules and a powerful API for C,C++ programming of own modules. ( Dynamic Imaging AS)
  • NeatVision: An Image Analysis & Software Development Environment - NeatVision is a Java based image analysis and software development environment. It provides high level access to a wide range of machine vision algorithms through a well defined and easy to use graphical interface. NeatVision is distributed as a shareware product.
    NeatVision contains over 200 image and general data processing algorithms. Users can extend the core NeatVision library using the developers interface, a plug-in which features, automatic source code generation, compilation with full error feedback and dynamic algorithm updates. The Developers interface supports algorithm development based on Java AWT Imaging, Java 2D Imaging and Java Advanced Imaging. NeatVision is primarily an image processing application and offers an extensive range of image analysis and visualisation tools (these include zoom, pseudo colour, intensity scan, histogram and 3D profile mesh). In addition, the ability to read and write a wide range of image file formats is supported. ( Vision Systems Laboratory / Dublin City University)
  • NeuroCheck - Commercial Windows-based image processing system for automatic presence verification, bar and DataMatrix code reading, character and pattern recognition, robot guidance and gauging.
    NeuroCheck® is the complete framework for configuring and operating industrial visual quality control systems. Its powerful graphical tools enable the user to easily develop solutions within a familiar Windows - based environment to achieve rapid system integration into production line processes. ( DS GmbH)
  • Nuages - A 3-D shape from contour package.
  • Optimas: Analytical Imaging - Complete commercial image-analysis program for Windows used in biological and industrial measurement environments.
    Optimas implements hundreds of measurement, image processing, and image management operations, all available from the graphical user interface. Optimas is designed for the imaging professional who needs the ability to prototype and quickly develop custom imaging solutions, and therefore includes an integrated development environment enabling one to record, edit, and debug macros. It is being used the world over to develop cutting-edge solutions to imaging problems. An Automation Server and Client (formerly known as "OLE Automation") Optimas also allows itself to be controlled via VB or any Automation Client, and conversely can control Excel or any Automation Server via an elegant syntax. Help is richly linked and context-sensitive. ( Media Cybernetics)
  • PBMPlus - Image manipulation toolkit.
    This is the standard toolkit for Unix, it converts between dozens of formats. A version with many more features called NetPBM is also available, but may not be as easy to install. Some NetPBM patches are available.
  • Perl Data Language - An extension to perl that implements fast, compact manipulation of large, N-dimensional data arrays for scientific computing and image processing.
  • PiXCL and geoPiXCL - A commercial image processing scripting language and Win9x/NT/2000 EXE builder for TWAIN scanner and digital camera image sources. geoPiXCL adds geographic imagery extensions. IP and geo library APIs are available. (by Stewart DIBBS)
  • RobotVision2 - real-time image processing software that uses any VideoForWindow(VFW) compatible camera as the image source (by Pong Suvan / Northeastern University)
  • RobotVisionCAD - RobotVisionCAD(RvCAD) is an Image Processing Environment for developing imaging applications and for research and development of new image system.
    RobotVisionCAD(RvCAD) is an Image Processing Environment for developing imaging applications and for research and development of new image system. RvCAD supports real-time live video processing from VideoForWindow compatible device, and also supports BMP, JPG, GIF89 and AVI or user can write a dll to support other vdo format or image acquisition device. RvCAD can also produce AVI file, sequence of BMP or JPG files, or just display images to screen, or users can write a dll to output images to whatever device they'd like. RvCAD is similar to an electonic logic gate simulation Program. Users drag and drop RvCadProcessor components from the left tree view then connect them together to build an ImageProcessing pipeline. (by pong suvan)
  • SDC Morphology Toolbox for Matlab - Matlab add-on: Gray-scale morphological tools for image segmentation, non-linear filtering, pattern recognition and image analysis: watershed, Euclidean distance transform, top-hat, reconstruction. (many real-life demonstrations)
  • SpikeNet Technology - (Company) Vendor of SpikeNet, a biologically-inspired computer vision system for object detection, recognition, and related applications. (by Simon Thorpe / Centre de Recherche Cerveau & Cognition)
  • The Delft Scientific Image Processing Library - DIPlib is a scientific image processing library written in C. It contains a large number of functions for processing and analysing multi dimensional image data.
    The library provides functions for performing transforms, filter operations, object generation, and statistical analysis of images. (by Michael van Ginkel, Geert van Kempen, Cris Luengo Hendriks, Lucas van Vliet Geert van Kempen Cris Luengo Hendriks Lucas van Vliet / Pattern Recognition Group / Delft University of Technology)
  • The Image Processing Tool Kit - Comprehensive set of image processing and analysis routines in the form of Photoshop-compatible plug-ins for Mac and PC, with extensive tutorial. (commercial package $$) (by Chris Russ, John Russ)
  • TINA - A set of vision algorithm development libraries written in C
    TINA is the result of over 50 man years of vision research. It is a set of libraries providing many levels of infrastructure for people wishing to develop vision algorithms. It contains a vast array of code from image reading and writing to depth estimation from stereo pairs. TINA is used as an on-going research tool by several vision research groups in the UK. It is written in C and has been compiled on many UNIX platforms including Sun workstations, HP workstations and PCs running Linux flavours. It requires only the basic UNIX system, a current gcc compiler and the X graphics libraries.
  • USB camera driver toolkit for LabVIEW - USB cameras and video capture devices are now included in the LabVIEW programming world.
    INVENTvisionVFW 1.0 gives you the power to view and capture any VFW (Video For Windows) video devices in any programming language that can interface to activex technology. INVENTvisionVFW can be implemented in VB, VC++, G (LabVIEW) programming environments. This mean that USB cameras and video capture devices are now included in the LabVIEW programming world. This product integrates and works with LabVIEW Picture Control and IMAQ. A real-time overlay is display on the activex control placed on the LabVIEW front Panel. Images can be captured to a 2D Array[U32], Visual Basic Picturebox, LabVIEW Picture Control or IMAQ Image. Images can be loaded from and saved to disk in BMP and JPG formats. (by George Miles / INVENTeering)
  • Utah Raster Toolkit - UNIX commands and C libraries for an 8 bits/pixel, 1-255 channel image format.
    Contains a nice display tool for X11; it's fast, supports animation and zooms in on any image. Wes Barris' URT extensions are quite useful too.
  • UTHSCSA ImageTool - free image processing and analysis program for windows.
  • VASARI Image Processing Software - An optimised library in C/C++ running on Unix. Its strengths are handling high-resolution images and colour spaces. Automatically parallel on SMP systems. ( Intelligence Agents and Multimedia Research Group (IAM) / University of Southampton, UK)
  • Video OCX - Windows-based interface for easy integration of video capture into your applications. It supports VFW video devices (USB cameras or framegrabber) AND AVI sequences as image sources. ( vision pearls GbR)
  • Vista - A flexible library of C-routines, command-line filters, and Motif widgets for image representation and manipulation.
  • VISU - Tcl/Tk toolkit for visualization and interactive segmentation of 2D gray-scale images
  • Visus Imaging - Image analysis toolkit and complete systems aimed at researchers and microscopists in Biomedical and Material Sciences. (commercial product $$) (Foresthill Products)
  • WiT - Visual programming environment for image processing (demo).
  • XCaliper - Commercial Windows NT software toolkit for machine vision and thermal imaging applications. ( FSI Automation)
  • XMegaWave, an Image Processing Environment - a freeware graphical windows environment oriented towards image processing, where the user can create his own function in a very easy way.
    Some european universities have developed a freeware image processing environment, named XMegaWave (XMW). It runs on Unix workstations or Linux machines, running Motif and X11 windows libraries. XMW includes some classical procedures for image processing (edge detection, segmentation, morphological filters). But the important thing is that XMW is also a programming library, where the user can implement his own image processing algorythm in C in a very very very easy way. The time needed to write the code and debug it is very short, so you can obtain results rapidly. Besides, XMW is a pedagogic tool suitable for using in image processing classes. It can be explained in just one class, and the students can easily implement any kind of image filter. (Image Mathematical Analysys Group (AMI) / University Las Palmas )

Tracking

Miscellaneous

Posted by at No comments:
Subscribe to: Posts (Atom)