cv.dll in Delphi benutzen

[meg91]

Hi
wie der Titel schon sagt versuche ich die Funktionen von "cv.dll" in Delphi zu benutzen.
Die DLL gehört zu dem OpenCV Projekt und ich würde gerne einiger dieser Funktionen in Delphi nutzen wie zB die Gesichtserkennung.
Leider funktioniert das mit dem Funktionsaufruf bei mir überhaupt nicht.
Kann mir jemand vllt einen Tipp geben und vor allem wie man die Parameter in Delphi übersetzen muss
oder hat jemand schon mal mit OpenCV in Delphi gearbeitet und kann ein Programmbeispiel posten

Markus

[SirThornberry]

wie sehen denn deine versuche aus und wie sehen die original-header aus?

[meg91]

so steht es im header

Delphi-Quellcode:

/*F///////////////////////////////////////////////////////////////////////////////////////
//    Name:    cvCreateImage
//    Purpose: creates header and allocates data
//    Context:
//    Parameters:
//      size - image size(width and height)
//      depth- image depth
//      channels - number of channels.
//    Returns:
//      this call is short form of
//         header = cvCreateImageHeader(size,depth,channels);
//         cvCreateImageData(header);
//F*/
OPENCVAPI  IplImage*  cvCreateImage( CvSize size, int depth, int channels );

und ich habe das ganze mit folgendem versucht:

Delphi-Quellcode:

function cvCreateImage(size: CvSize; depth: integer; channels: integer;):? external 'CV.DLL';

nur leider weis ich weder wie ich "size" in Delphi übertragen soll, noch wie das ganze mit dem Rückgabewert aussehen soll

[Tiuri]

müsste nicht noch eine Aufrufkonvention, also stdcall oder ähnliches, dazu, da die DLL nicht mit Delphi erstellt worden ist?

[ste_ett]

Code:

OPENCVAPI  IplImage*  cvCreateImage( CvSize size, int depth, int channels );

Wie ist "OPENCVAPI" definiert?

[meg91]

ich habe leider keine Ahnung, dass einzige was ich sehen konnte war das OPENCVAPI vor jeder definierten Funktion steht
hier ist der Link zu dem gesamten Package

[DGL-luke]

hallo, sowohl cvSize als auch OPENCVAPI sind wahrscheinlcih in cvtypes.h definiert.

[meg91]

du hast völlig recht, es sind tatsächliche beide da.
das steht für Cvsize:

Code:

CV_INLINE CvSize cvSize( int width, int height )
{
    CvSize s;

    s.width = width;
    s.height = height;

    return s;
}

für mich stellt sich aber immernoch die Frage wie man das nun richitg in Delphi aufruft und die Funktion mit der man "Face Recognition" druchführen kann, was ja eigentlich mein Anliegen ist, habe ich noch immer nicht gefunden

weis da jemand weiter, oder gibts irgendwo Beispiele für sowas?

[DGL-luke]

hallo, das ist keine typedef.

[meg91]

aber ich weis jetzt zumindest, dass das 2 Integers sind und nix anderes

[Robert Marquardt]

Ich habe vorhin mal einen Blick auf die Sourcen geworfen. Die Calling Convention ist explizit als cdecl anfgegeben.
Ein recht sauberes API. Ich empfehle C/C++ zu benutzen. Den Headern nach wird Borland unterstuetzt.

Die Konversion nach Delphi ist relativ einfach, aber ich habe keine Zeit dafuer. Ich bin mit mehreren Versprechen dieser Art im Rueckstand.

[DGL-luke]

as kann ich ja übernehmen. Bitte poste den Quellcode oder sagr was genau(!) ich downloaden muss.

[meg91]

wäre echt klasse wenn du das hinbekommen würdest :-D

[Robert Marquardt]

Na in bewaehrter SourceForge-Manier wuerde ich ueber http://opencv.sf.net einsteigen. Die homepage enthaelt alles was man braucht einschliesslich Download-Links. Der oben angegebene Link auf coreb1-5 erscheint mir veraltet. Aktuell ist 1.0. OpenCV hat mehrere Teil APIs. cxcore, cv, cvaux und highgui. cxcore und cv sind die APIs die erst mal uebersetzt werden muessen.

[DGL-luke]

*brrrr*

Bin schon auf einige schlimme Makros gestoßen...

[Robert Marquardt]

Die Makros erschienen mir harmlos. Man braucht sie ja auch nicht unbedingt alle. Im Zweifel hier posten oder mich direkt fragen.

[DGL-luke]

Dann hätt ich mal ne Frage: In der cvtypes.h wird auf Sachen zugegriffen, die weder deklariert noch eingebunden sind. Anscheinend wird cvtypes.h also nur als include genutztm nicht wie in Delphi eine unit, in der alles anständig eingebunden sein muss. Soll ich aus der cvtypes.h also eine cvtypes.inc machen?

und noch was: stimmt das hier:

Delphi-Quellcode:

(*

#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)
*)
const
  CV_SUBDIV2D_VIRTUAL_POINT_FLAG = (1 shl 30);

[Robert Marquardt]

cvtypes.h muss ich mir nochmal ansehen (morgen).
Ja die Konversion ist richtig. Die Klamemrn kann man weglassen.

[meg91]

ich wollte mal hörn wie der aktuelle Stand ist
ich bräuchte nämlich langsam die Libary

Gruß
markus

[Robert Marquardt]

Nicht so ungeduldig. So schnell kann das nicht gehen. Selbst wenn die Konversion schon fertig waere so muesste man noch pruefen ob sie korrekt ist. Da sind doch ein paar trickreiche Sachen dabei.

[DGL-luke]

Hallo,

ich hab auch einige unwichtige Nebenbeschäftigungen zum Open-Source-programmieren (Schule, Job, Führerschein, Baustelle daheim... alles nix wichtiges, aber muss halt auch gemacht werden ;) ). Ich hab bis jetzt die cvtypes.pas zu 50% übersetzt, sonst noch nix.

Eigentlich ist es auch nicht schwierig, das selbst zu machen: auf "typedef struct xyz {}" wird eben "xyz = record ... end;".

Ich poste hier mal was ich schon hab:

Delphi-Quellcode:

unit cvtypes;

interface

{
#ifndef _CVTYPES_H_
#define _CVTYPES_H_
}

{$IFNDEF _CVTYPES_H_}
  {$DEFINE _CVTYPES_H_}
{$ENDIF}

{
#ifndef SKIP_INCLUDES
  #include <assert.h>
  #include <stdlib.h>
#endif
}
//no translation

type
(*
/* spatial and central moments */
typedef struct CvMoments
{
    double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */
    double  mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */
    double  inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */
}
CvMoments;
*)

// spatial and central moments
  CvMoments = record
    m00, m10, m01, m20, m11, m02, m30, m21, m12, m03: Double; ///* spatial moments */
    enmu20, mu11, mu02, mu30, mu21, mu12, mu03: Double; ///* central moments */d;
    inv_sqrt_m00: Double; ///* m00 != 0 ? 1/sqrt(m00) : 0 */
  end;

(*
/* Hu invariants */
typedef struct CvHuMoments
{
    double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /* Hu invariants */
}
CvHuMoments;
*)

// Hu invariants
  CvHuMoment = record
    hu1, hu2, hu3, hu4, hu5, hu6, hu7: Double; ///* Hu invariants */
  end;

//**************************** Connected Component  **************************//

(*typedef struct CvConnectedComp
{
    double area;    /* area of the connected component  */
    CvScalar value; /* average color of the connected component */
    CvRect rect;    /* ROI of the component  */
    CvSeq* contour; /* optional component boundary
                      (the contour might have child contours corresponding to the holes)*/
}
CvConnectedComp;
*)
  CvConnectedComp = record
    Area: Double;
    value: CvScalar;
    rect: CvRect;
    contour: ^CvSeq;
  end;
(*

/*
Internal structure that is used for sequental retrieving contours from the image.
It supports both hierarchical and plane variants of Suzuki algorithm.
*/
typedef struct _CvContourScanner* CvContourScanner;
*)
  CvContourScanner = ^_CvCountourScanner;
(*

/* contour retrieval mode */
#define CV_RETR_EXTERNAL 0
#define CV_RETR_LIST     1
#define CV_RETR_CCOMP    2
#define CV_RETR_TREE     3
*)

const
  CV_RETR_EXTERNAL = 0;
  CV_RETR_LIST     = 1;
  CV_RETR_CCOMP    = 2;
  CV_RETR_TREE     = 3;
(*
/* contour approximation method */
#define CV_CHAIN_CODE               0
#define CV_CHAIN_APPROX_NONE        1
#define CV_CHAIN_APPROX_SIMPLE      2
#define CV_CHAIN_APPROX_TC89_L1     3
#define CV_CHAIN_APPROX_TC89_KCOS   4
#define CV_LINK_RUNS                5
*)
  CV_CHAIN_CODE               = 0;
  CV_CHAIN_APPROX_NONE        = 1;
  CV_CHAIN_APPROX_SIMPLE      = 2;
  CV_CHAIN_APPROX_TC89_L1     = 3;
  CV_CHAIN_APPROX_TC89_KCOS   = 4;
  CV_LINK_RUNS                = 5;
(*

/* Freeman chain reader state */
typedef struct CvChainPtReader
{
    CV_SEQ_READER_FIELDS()
    char      code;
    CvPoint   pt;
    char      deltas[8][2];
}
CvChainPtReader;
*)
type
  CvChainPtReader = record
    //CV_SEQ_READER_FIELDS() //Makro/#define - muss ersetzt werden
    Code:   Char;
    pt:     CvPoint;
    deltas: array[0..7,0..1] of Char;
  end;
(*

/* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */
#define  CV_INIT_3X3_DELTAS( deltas, step, nch )            \
    ((deltas)[0] =  (nch),  (deltas)[1] = -(step) + (nch),  \
     (deltas)[2] = -(step), (deltas)[3] = -(step) - (nch),  \
     (deltas)[4] = -(nch),  (deltas)[5] =  (step) - (nch),  \
     (deltas)[6] =  (step), (deltas)[7] =  (step) + (nch))
*)

//moved to implementation

(*

/* Contour tree header */
typedef struct CvContourTree
{
    CV_SEQUENCE_FIELDS()
    CvPoint p1;            /* the first point of the binary tree root segment */
    CvPoint p2;            /* the last point of the binary tree root segment */
}
CvContourTree;

*)
  CvContourTree = record
    //CV_SEQUENCE_FIELDS()  //macro! has to be included
    p1: CvPoint;            ///* the first point of the binary tree root segment */
    p2: CvPoint;            ///* the last point of the binary tree root segment */
  end;

(*

/* Finds a sequence of convexity defects of given contour */
typedef struct CvConvexityDefect
{
    CvPoint* start; /* point of the contour where the defect begins */
    CvPoint* end; /* point of the contour where the defect ends */
    CvPoint* depth_point; /* the farthest from the convex hull point within the defect */
    float depth; /* distance between the farthest point and the convex hull */
}
CvConvexityDefect;

*)
  CvConvexityDefect = record
    start: ^CvPoint;
    _end: ^CvPoint;
    depth_point: CvPoint;
    depth: float;
  end;
(*

/************ Data structures and related enumerations for Planar Subdivisions ************/

typedef size_t CvSubdiv2DEdge;
*)
  CvSubdiv2DEdge = size_t;
(*

#define CV_QUADEDGE2D_FIELDS()     \
    int flags;                     \
    struct CvSubdiv2DPoint* pt[4]; \
    CvSubdiv2DEdge  next[4];

#define CV_SUBDIV2D_POINT_FIELDS()\
    int            flags;      \
    CvSubdiv2DEdge first;      \
    CvPoint2D32f   pt;

*)
//will need to directly include these
(*

#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)
*)
const
  CV_SUBDIV2D_VIRTUAL_POINT_FLAG = (1 shl 30);
(*

typedef struct CvQuadEdge2D
{
    CV_QUADEDGE2D_FIELDS()
}
CvQuadEdge2D;

*)

type
  CvQuadEdge2D = record
    //CV_QUADEDGE2D_FIELDS:
    flags: Integer;
    pt: array[0..3] of ^CvSubdiv2DPoint;
    next: array[0..3] of CvSubdiv2DEdge;
  end;

type
  CV_INIT_DELTAS = array[0..7] of Integer;

procedure CV_INIT_3X3_DELTAS(var CV_INIT_DELTAS; step, nch: Integer);

implementation
(*
/* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */
#define  CV_INIT_3X3_DELTAS( deltas, step, nch )            \
    ((deltas)[0] =  (nch),  (deltas)[1] = -(step) + (nch),  \
     (deltas)[2] = -(step), (deltas)[3] = -(step) - (nch),  \
     (deltas)[4] = -(nch),  (deltas)[5] =  (step) - (nch),  \
     (deltas)[6] =  (step), (deltas)[7] =  (step) + (nch))
*)

procedure CV_INIT_3X3_DELTAS(var CV_INIT_DELTAS; step, nch: Integer);
begin
  deltas[0] := nch;
  deltas[1] := -step+nch;
  deltas[2] := -step;
  deltas[3] := -step-nch;
  deltas[4] := -nch;
  deltas[5] := step-nch;
  deltas[6] := step;
  deltas[7] := step+nch;
end;

end.

PS: Hoffe, das faltet sich ordentlich zusammen.

[meg91]

das sollte jetzt nich ungeduldig wirken, ich wollte einfach nur den Stand der Dinge wissen.
ich bin euch ja sehr dankbar, dass ihr euch die Arbeit für mich macht