C FaceTracking DLL in Delphi nutzen

**Cylence**

Hallo,

ich habe hier:

http://chenlab.ece.cornell.edu/projects/FaceTracking/

eine dll gefunden mit der man Facetracking ermöglichen kann/naja oder könnte *g* dabei ist ein .h Header File, was ich testweise mal mit dem
HEADCONV.EXE in einen Delphi Header versucht hab umzuschreiben, aber das Tool hat das nicht richtig gemacht leider.

Dies ist der Header

zusammenfalten · markieren

Delphi-Quellcode:

			#ifndef _FACE_TRACK_H

#define _FACE_TRACK_H

#define TWOPI_THREE_HALVES   15.749609946

#define EPSILON            1e-10

#define MIN_FLOAT         1e-20

#define LN_MIN_FLOAT      -46

#define MINFEATURESIZE      5

#define LARGENUM         1000000

#define PACKRGB(r,g,b) ((((unsigned int) r) & 0xfc) << 10) | ((((unsigned int) g) & 0xfc) << 4) | ((((unsigned int) b) & 0xfc) >> 2)

#define UNPACKR(x) (((unsigned int) x) & 0x3f000) >> 10

#define UNPACKG(x) (((unsigned int) x) & 0x00fc0) >> 4

#define UNPACKB(x) (((unsigned int) x) & 0x0003f) << 2

enum TEMPLATE_TYPE

{

   Ft_RECTANGLE,

   Ft_ELLIPSE,

   Ft_PARABOLA

};

typedef struct tagTEMPLATE

{

   int x1;         //left

   int y1;         //top

   int x2;         //right

   int y2;         //bottom

   int center;      //vertical center

}FACE_RECT;

typedef struct tagGAUSS

{

   double c;

   double c_acc;                  //acumulate

   double mean[3], mean_acc[3];

   double cov[3][3], covinv[3][3];

   double cov_acc[3][3];

   double gconst;

}GAUSS;

typedef struct tagSTATE

{

   int nels;

   GAUSS mix[2];

}STATE;

//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

class AFX_EXT_CLASS CFaceTrack

{

public:

   double *FtGetTemplate() const

   {

      return (double*)m_fTemplate;

   }

public:

   //constructor

   CFaceTrack();

   //destructor

   virtual ~CFaceTrack();

public:

   //high level member functions

   BOOL FtInitialization (int ImgWidth, int ImgHeight, BOOL RestrictAspectRatio=TRUE,

                     TEMPLATE_TYPE TemplateType=Ft_ELLIPSE);

   BOOL FtTraining (RECT FaceLocation, unsigned char *ImgData);

   BOOL FtTrackNextFrame (RECT &FaceRect, unsigned char *ImgData);

   //low level member functions

   //fill the mask with current template shape

   void FtFillMask (int ImgWidth, int ImgHeight, unsigned char *pMask, double *Template, 

                  FACE_RECT FaceRect, int flag);

   //calculate the template shape parameters

   void FtFillTemplateParabola();

   void FtFillTemplateEllipse();

   void FtFillTemplateRectangle();

   //split the color channels

   void FtSplitColorChannel (int ImgWidth, int ImgHeight, unsigned char *pImgData, unsigned char *pRGBSplitImg[3]);

   //train the Gaussian Mixture Model

   void FtTrainGMM (unsigned char *pRGBSplitImg[3], unsigned char *pMask);

   void FtInitMixMean (unsigned char *pRGBSplitImg[3], unsigned char *pMask);

   void FtInitMixVar (unsigned char *pRGBSplitImg[3], unsigned char *pMask);

   void FtFillMixAcc (unsigned char *pRGBSplitImage[3], unsigned char *pMask);

   void FtFillMixConvinv (GAUSS *tmix);

   void FtZeroMixAcc ();

   //fill the look-up table with the training result

   void FtFillLUTTable();

   double FtGetProbability (int rin, int gin, int bin, GAUSS *mix);

   //track the face in the current frame

   void FtUpdateTemplate (FACE_RECT &CurFaceRect, FACE_RECT &PreFaceRect, int iStep, int flag);

   //given each pixel in current frame, calculate its likelihood value

   void FtUpdateLikelihoodMap (unsigned char *ImgData, int ImgWidth, int ImgHeight);

   //search strategy

   double FtTargetFunction(int *FaceRect, int *delta, int scale, int flag);

protected:

   int m_nImgWidth;            //the width of the image

   int m_nImgHeight;            //the height of the image

   DWORD m_nTableSize;            //the sampling rate of the color space

                           //note here m_nTableSize is the byte size of the LUT table

   BOOL m_bRestrictAspectRatio;   //whether restrict the aspect ratio of the tracking result

   BOOL m_bIsInitialized;         //indicates whether the internal variables have been allocated

   unsigned char *m_pRGBSplitImg[3];   //the image stored in RGB plane format

   unsigned char *m_pMask;            //the pointer of the mask which indicates the foreground and background region

   float *m_pLUT;                  //the pointer of probability look up table (LUT)

   double *m_pLikelihoodMap;         //the pointer of the likelihood map

   double *m_pom[2];

   double *m_pmo[2];

   double *m_po;

   TEMPLATE_TYPE m_TemplateType;   //the shape of the template to fit the face region

   FACE_RECT m_CurFaceRect;

   FACE_RECT m_PreFaceRect;

   double m_fTemplate[101];      //template equation

   STATE m_StateInfo[2];

};

#endif   //ifndef _FACE_TRACK_H

das ist was das tool übersetzt hat daraus

zusammenfalten · markieren

Delphi-Quellcode:

			unit FACETRACK;

{**************************************************************************}

{                                                                          }

{    This C DLL header file first (automatic) conversion generated by:     }

{    HeadConv 4.0 (c) 2000 by Bob Swart (aka Dr.Bob - www.drbob42.com)     }

{      Final Delphi-Jedi (Darth) command-line units edition                }

{                                                                          }

{    Generated Date: 09.09.2010                                            }

{    Generated Time: 10:15:18                                              }

{                                                                          }

{**************************************************************************}

interface

uses

{$IFDEF WIN32}

  Windows;

{$ELSE}

  Wintypes, WinProcs;

{$ENDIF}

{=> d:\workspace\facetrackingdll\FACETRACK.H <=}

{$IFNDEF _FACE_TRACK_H}

{$DEFINE _FACE_TRACK_H}

const

  TWOPI_THREE_HALVES = 15.749609946;

const

  EPSILON = 1e-10;

const

  MIN_FLOAT = 1e-20;

const

  LN_MIN_FLOAT = -46;

const

  MINFEATURESIZE = 5;

const

  LARGENUM = 1000000;

const

  PACKRGB(r,g,b) = ((((unsigned int) r) & 0xfc) << 10) | ((((unsigned int) g) & 0xfc) << 4) | ((((unsigned int) b) & 0xfc) >> 2);

const

  UNPACKR(x) = (((unsigned int) x) & 0x3f000) >> 10;

const

  UNPACKG(x) = (((unsigned int) x) & 0x00fc0) >> 4;

const

  UNPACKB(x) = (((unsigned int) x) & 0x0003f) << 2;

type

  TEMPLATE_TYPE = (

    Ft_RECTANGLE, 

    Ft_ELLIPSE, 

    Ft_PARABOLA  );

type

  tagTEMPLATE = record

    x1: Integer;

    y1: Integer;

    x2: Integer;

    y2: Integer;

    center: Integer;

  end {tagTEMPLATE};

type

  tagGAUSS = record

    c: Double;

    c_acc: Double;

    mean: Array[0..3-1] of, mean_acc: Array[0..3-1] of Double;

    cov: Array[0..3-1] of: Array[0..3-1] of, covinv: Array[0..3-1] of: Array[0..3-1] of Double;

    cov_acc: Array[0..3-1] of: Array[0..3-1] of Double;

    gconst: Double;

  end {tagGAUSS};

type

  tagSTATE = record

    nels: Integer;

    mix: Array[0..2-1] of GAUSS;

  end {tagSTATE};

{///&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& }

var

  FtGetTemplate: function: PPUBLIC: DOUBLE cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  return: function(var _1: Double): Integer cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  CFaceTrack: function: Integer cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///destructor }

var

  ~CFaceTrack: function: VIRTUAL cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtInitialization: function(ImgWidth: Integer; 

                             ImgHeight: Integer; 

                             RestrictAspectRatio=TRUE: Bool; 

                             TemplateType=Ft_ELLIPSE: TEMPLATE_TYPE): Bool cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtTraining: function(FaceLocation: RECT; 

                       var ImgData: Byte): Bool cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtTrackNextFrame: function(var FaceRect: RECT; 

                             var ImgData: Byte): Bool cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///low level member functions }

{///fill the mask with current template shape }

var

  FtFillMask: procedure(ImgWidth: Integer; 

                        ImgHeight: Integer; 

                        var pMask: Byte; 

                        var Template: Double; 

                        FaceRect: FACE_RECT; 

                        flag: Integer) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///calculate the template shape parameters }

var

  FtFillTemplateParabola: procedure cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtFillTemplateEllipse: procedure cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtFillTemplateRectangle: procedure cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///split the color channels }

var

  FtSplitColorChannel: procedure(ImgWidth: Integer; 

                                 ImgHeight: Integer; 

                                 var pImgData: Byte; 

                                 var pRGBSplitImg[3]: Byte) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///train the Gaussian Mixture Model }

var

  FtTrainGMM: procedure(var pRGBSplitImg[3]: Byte; 

                        var pMask: Byte) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtInitMixMean: procedure(var pRGBSplitImg[3]: Byte; 

                           var pMask: Byte) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtInitMixVar: procedure(var pRGBSplitImg[3]: Byte; 

                          var pMask: Byte) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtFillMixAcc: procedure(var pRGBSplitImage[3]: Byte; 

                          var pMask: Byte) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtFillMixConvinv: procedure(var tmix: GAUSS) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtZeroMixAcc: procedure cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///fill the look-up table with the training result }

var

  FtFillLUTTable: procedure cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

var

  FtGetProbability: function(rin: Integer; 

                             gin: Integer; 

                             bin: Integer; 

                             var mix: GAUSS): Double cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///track the face in the current frame }

var

  FtUpdateTemplate: procedure(var CurFaceRect: FACE_RECT; 

                              var PreFaceRect: FACE_RECT; 

                              iStep: Integer; 

                              flag: Integer) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///given each pixel in current frame, calculate its likelihood value }

var

  FtUpdateLikelihoodMap: procedure(var ImgData: Byte; 

                                   ImgWidth: Integer; 

                                   ImgHeight: Integer) cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///search strategy }

var

  FtTargetFunction: function(var FaceRect: Integer; 

                             var delta: Integer; 

                             scale: Integer; 

                             flag: Integer): Double cdecl  {$IFDEF WIN32} stdcall {$ENDIF}; 

{///note here m_nTableSize is the byte size of the LUT table }

{$ENDIF //ifndef _FACE_TRACK_H}

var

  DLLLoaded: Boolean { is DLL (dynamically) loaded already? }

    {$IFDEF WIN32} = False; {$ENDIF}

implementation

var

  SaveExit: pointer;

  DLLHandle: THandle;

{$IFNDEF MSDOS}

  ErrorMode: Integer;

{$ENDIF}

  procedure NewExit; far;

  begin

    ExitProc := SaveExit;

    FreeLibrary(DLLHandle)

  end {NewExit};

procedure LoadDLL;

begin

  if DLLLoaded then Exit;

{$IFNDEF MSDOS}

  ErrorMode := SetErrorMode($8000{SEM_NoOpenFileErrorBox});

{$ENDIF}

  DLLHandle := LoadLibrary('FACETRACK.DLL');

  if DLLHandle >= 32 then

  begin

    DLLLoaded := True;

    SaveExit := ExitProc;

    ExitProc := @NewExit;

    @FtGetTemplate := GetProcAddress(DLLHandle,'FtGetTemplate');

  {$IFDEF WIN32}

    Assert(@FtGetTemplate <> nil);

  {$ENDIF}

    @return := GetProcAddress(DLLHandle,'return');

  {$IFDEF WIN32}

    Assert(@return <> nil);

  {$ENDIF}

    @CFaceTrack := GetProcAddress(DLLHandle,'CFaceTrack');

  {$IFDEF WIN32}

    Assert(@CFaceTrack <> nil);

  {$ENDIF}

    @~CFaceTrack := GetProcAddress(DLLHandle,'~CFaceTrack');

  {$IFDEF WIN32}

    Assert(@~CFaceTrack <> nil);

  {$ENDIF}

    @FtInitialization := GetProcAddress(DLLHandle,'FtInitialization');

  {$IFDEF WIN32}

    Assert(@FtInitialization <> nil);

  {$ENDIF}

    @FtTraining := GetProcAddress(DLLHandle,'FtTraining');

  {$IFDEF WIN32}

    Assert(@FtTraining <> nil);

  {$ENDIF}

    @FtTrackNextFrame := GetProcAddress(DLLHandle,'FtTrackNextFrame');

  {$IFDEF WIN32}

    Assert(@FtTrackNextFrame <> nil);

  {$ENDIF}

    @FtFillMask := GetProcAddress(DLLHandle,'FtFillMask');

  {$IFDEF WIN32}

    Assert(@FtFillMask <> nil);

  {$ENDIF}

    @FtFillTemplateParabola := GetProcAddress(DLLHandle,'FtFillTemplateParabola');

  {$IFDEF WIN32}

    Assert(@FtFillTemplateParabola <> nil);

  {$ENDIF}

    @FtFillTemplateEllipse := GetProcAddress(DLLHandle,'FtFillTemplateEllipse');

  {$IFDEF WIN32}

    Assert(@FtFillTemplateEllipse <> nil);

  {$ENDIF}

    @FtFillTemplateRectangle := GetProcAddress(DLLHandle,'FtFillTemplateRectangle');

  {$IFDEF WIN32}

    Assert(@FtFillTemplateRectangle <> nil);

  {$ENDIF}

    @FtSplitColorChannel := GetProcAddress(DLLHandle,'FtSplitColorChannel');

  {$IFDEF WIN32}

    Assert(@FtSplitColorChannel <> nil);

  {$ENDIF}

    @FtTrainGMM := GetProcAddress(DLLHandle,'FtTrainGMM');

  {$IFDEF WIN32}

    Assert(@FtTrainGMM <> nil);

  {$ENDIF}

    @FtInitMixMean := GetProcAddress(DLLHandle,'FtInitMixMean');

  {$IFDEF WIN32}

    Assert(@FtInitMixMean <> nil);

  {$ENDIF}

    @FtInitMixVar := GetProcAddress(DLLHandle,'FtInitMixVar');

  {$IFDEF WIN32}

    Assert(@FtInitMixVar <> nil);

  {$ENDIF}

    @FtFillMixAcc := GetProcAddress(DLLHandle,'FtFillMixAcc');

  {$IFDEF WIN32}

    Assert(@FtFillMixAcc <> nil);

  {$ENDIF}

    @FtFillMixConvinv := GetProcAddress(DLLHandle,'FtFillMixConvinv');

  {$IFDEF WIN32}

    Assert(@FtFillMixConvinv <> nil);

  {$ENDIF}

    @FtZeroMixAcc := GetProcAddress(DLLHandle,'FtZeroMixAcc');

  {$IFDEF WIN32}

    Assert(@FtZeroMixAcc <> nil);

  {$ENDIF}

    @FtFillLUTTable := GetProcAddress(DLLHandle,'FtFillLUTTable');

  {$IFDEF WIN32}

    Assert(@FtFillLUTTable <> nil);

  {$ENDIF}

    @FtGetProbability := GetProcAddress(DLLHandle,'FtGetProbability');

  {$IFDEF WIN32}

    Assert(@FtGetProbability <> nil);

  {$ENDIF}

    @FtUpdateTemplate := GetProcAddress(DLLHandle,'FtUpdateTemplate');

  {$IFDEF WIN32}

    Assert(@FtUpdateTemplate <> nil);

  {$ENDIF}

    @FtUpdateLikelihoodMap := GetProcAddress(DLLHandle,'FtUpdateLikelihoodMap');

  {$IFDEF WIN32}

    Assert(@FtUpdateLikelihoodMap <> nil);

  {$ENDIF}

    @FtTargetFunction := GetProcAddress(DLLHandle,'FtTargetFunction');

  {$IFDEF WIN32}

    Assert(@FtTargetFunction <> nil);

  {$ENDIF}

  end

  else

  begin

    DLLLoaded := False;

    { Error: FACETRACK.DLL could not be loaded !! }

  end;

{$IFNDEF MSDOS}

  SetErrorMode(ErrorMode)

{$ENDIF}

end {LoadDLL};

begin

  LoadDLL;

end.

darin sind ohne ende fehler undefinierter bezeichner usw...
kennt sich jemand damit aus? Kann mir jemand helfen? Ich denke das die dll auch für andere interessant sein könnte.

Gruß

Cylence

**SirThornberry**

Bei was konkret kommst du nicht weiter? Es macht wenig Sinn dir das ganze richtig zu übersetzen denn dann weißt du beim nächsten mal wieder nicht wie es zu übersetzen ist.
Wenn du allerdings sagst woran du konkret scheiterst können wir dir sagen was das darstellt und entsprechend verständlicher ist dann das Delphi-Äquivalent.

Was mit "#define" anfängt sind übrigens Makros die es so in Delphi nicht gibt.
Beispiel:
[c]
#define UNPACKB(x) (((unsigned int) x) & 0x0003f) << 2
[/c]
überall wo UNPACKB(irgendwas) steht wird das vor dem compilieren ersetzt durch:
(((unsigned int) irgendwas) & 0x0003f) << 2

Das kannst du in Delphi so nur mit einem Funktionsaufruf übersetzen oder du schreibst es wirklich jedesmal hinn (wobei der Variablenname x dann angepasst werden muss).

Hallo,

ich fürchte das geht so gar nicht.

markieren

Code:

class AFX_EXT_CLASS CFaceTrack

Das stammt aus dem Header einer MFC-Erweiterungs-DLL.
Das ist so etwas ähnliches wie ein Delphi-Package, nur halt bei Microsofts MFC-Library.

Und die Funktionen sind Member von einer Klasse. Die kann man nicht mit GetProcAddress laden.

Grüße

**Cylence**

Hi,

naja der compiler hängt an mehreren ecken, zb hier

const
PACKRGB(r,g,b)
und hier
mix: Array[0..2-1] of GAUSS; //undefined GAUSS
und hier
var
FtGetTemplate: function: PPUBLIC: DOUBLE cdecl {$IFDEF WIN32} stdcall {$ENDIF};
undefinde PPUBLIC

also ich hab schon dlls genutzt aber mit den fertigen Delphi headerfiles dazu, daher hab ich das bisher noch nicht gemacht, sorry. Aber die Automatische Version von dem tool ist schonmal ein Anfang, ich dachte nur das evtl jemand hier sich besser auskennt damit.

Gruß

cylence

MFC-Erweiterungs-DLLs laufen nur mit der Visual C++ Version, mit der sie erstellt wurden.

http://msdn.microsoft.com/de-de/libr...8VS.80%29.aspx

Zitat:

Eine Erweiterungs-DLL kann ausschließlich von ausführbaren MFC-Dateien (entweder Anwendungen oder regulären DLLs) verwendet werden, die mit der gemeinsam genutzten MFC-Version erstellt wurden.

**Bernhard Geyer**

Mit VS C++ entweder eine C-Kompatible Wrapper-DLL schreiben oder einen COM-Wrapper erstllen lassen.
Dann klappt es auch mit Delphi

C FaceTracking DLL in Delphi nutzen

C FaceTracking DLL in Delphi nutzen

AW: C FaceTracking DLL in Delphi nutzen

AW: C FaceTracking DLL in Delphi nutzen

AW: C FaceTracking DLL in Delphi nutzen

AW: C FaceTracking DLL in Delphi nutzen

AW: C FaceTracking DLL in Delphi nutzen

Forumregeln

Bernhard Geyer Registriert seit: 13. Aug 2002 17.213 Beiträge Delphi 10.4 Sydney	#6 AW: C FaceTracking DLL in Delphi nutzen 9. Sep 2010, 11:40 Mit VS C++ entweder eine C-Kompatible Wrapper-DLL schreiben oder einen COM-Wrapper erstllen lassen. Dann klappt es auch mit Delphi Windows Vista - Eine neue Erfahrung in Fehlern.
	Zitat