DynamicArray<IplImage*> and IplImage** are not the same thing. DynamicArray<int> and int* are not the same thing.

Your C++Builder code can use DynamicArray variables for purposes of memory management, but DO NOT declare parameters of imported DLL functions as being DynamicArray on the C++Builder side. For interop purposes, you need to use the same (or at least equivalent) declarations in both compilers.

In fact, your C++Builder code shouldn't even compile, because the DLL's NumberCallerDraw() function only has 3 parameters, but you are trying to pass it 4 values in you C++Builder code.

Try something more like this on the C++Builder side:

typedef DynamicArray< IplImage* > ArrayOfImage;
typedef DynamicArray< int > ArrayOfInteger;
 
extern "C" __declspec(dllimport) void __stdcall NumberCallerDraw(const void* dcaller, IplImage** dimage, int* dnum);
extern "C" __declspec(dllimport) void __stdcall NumberCallerSave(const void* dcaller, char* filename );
 
void __fastcall TNumberCaller::save( const String &filename )
{
    NumberCallerSave( TnumberCaller::oPointer, AnsiString(filename).c_str() );
}
 
void __fastcall TNumberCaller::draw( ArrayOfImage &dimage, ArrayOfInteger &dnum )
{
    NumberCallerDraw( TnumberCaller::oPointer, (dimage.Length > 0) ? &dimage[0] : NULL, (dnum.Length > 0) ? &dnum[0] : NULL );
}
 
...
 
ArrayOfImage fimages;
ArrayOfInteger fnumbers;
 
fimages.Length = sqliteQuery->RecordCount;
fnumbers.Length = fimages.Length;
int ndex = 0;
 
try
{
    while (!sqliteQuery->Eof)
    { 
        imagedrawn = new TBitmap;
        try
        {
            //codes here...
            fimages[ndex] = Bitmap2IplImage(imagedrawn);
            fnumbers[ndex] = ndex;
            ++ndex;
        }
        __finally
        {
            delete imagedrawn;
        }
 
        xdbimage = new TBitmap;
        try
        {
            IplImage2Bitmap(fimages[ndex-1], xdbimage);
            imgCallerLocation->Picture->Assign(xdbimage);
        }
        __finally
        {
            delete xdbimage;
        }
 
        sqliteQuery->Next();
    }
 
    ...
 
    TNumberCaller *tcallerid = new TNumberCaller;
    try
    {
        tcallerid->createNumberCaller(1,100.1);
        tcallerid->save(_y_filename_);
        tcallerid->draw(fimages, fnumbers);
        ...
    }
    __finally
    {
        delete tcallerid;
    }
}
__finally
{
    for (int i = 0; i < ndex; ++i)
        cvReleaseImage(&fimages[ndex]);
}

Alternatively:

struct TIplImage
{
    IplImage *Image;
 
    TIplImage() : Image(NULL) {}
    ~TIplImage() { cvReleaseImage(&Image); }
};
 
typedef DynamicArray< TIplImage > ArrayOfImage;
 
extern "C" __declspec(dllimport) void __stdcall NumberCallerDraw(const void* dcaller, IplImage** dimage, int* dnum);
extern "C" __declspec(dllimport) void __stdcall NumberCallerSave(const void* dcaller, char* filename );
 
void __fastcall TNumberCaller::save( const String &filename )
{
    NumberCallerSave( TnumberCaller::oPointer, AnsiString(filename).c_str() );
}
 
void __fastcall TNumberCaller::draw( ArrayOfImage &dimages )
{
    DynamicArray<IplImage*> images;
    DynamicArray<int> nums;
 
    int count = dimages.Length;
    images.Length = count;
    nums.Length = count;
 
    for (int idx = 0; idx < count; ++idx)
    {
        images[idx] = dimages[idx].Image;
        nums[idx] = idx;
    }
 
    NumberCallerDraw( TnumberCaller::oPointer, (count > 0) ? &images[0] : NULL, (count > 0) ? &nums[0] : NULL );
}
 
...
 
ArrayOfImage fimages;
 
fimages.Length = sqliteQuery->RecordCount;
int ndex = 0;
 
while (!sqliteQuery->Eof)
{ 
    imagedrawn = new TBitmap;
    try
    {
        //codes here...
        fimages[ndex].Image = Bitmap2IplImage(imagedrawn);
        ++ndex;
    }
    __finally
    {
        delete imagedrawn;
    }
 
    xdbimage = new TBitmap;
    try
    {
        IplImage2Bitmap(fimages[ndex-1].Image, xdbimage);
        imgCallerLocation->Picture->Assign(xdbimage);
    }
    __finally
    {
        delete xdbimage;
    }
 
    sqliteQuery->Next();
}
 
...
 
TNumberCaller *tcallerid = new TNumberCaller;
try
{
    tcallerid->createNumberCaller(1,100.1);
    tcallerid->save(_y_filename_);
    tcallerid->draw(fimages);
    ...
}
__finally
{
    delete tcallerid;
}

That being said, how does NumberCallerDraw() in the DLL know how many items are being passed in the two arrays? The DLL code you showed does not allow for that. Clearly the array counts are dynamic, so more input parameters are needed so the DLL does not go out of bounds when accessing the arrays.

--
Remy Lebeau (TeamB)

roca robin wrote:


The DLL is still expecting only 3 parameters, but you are passing 4
values to it:

// 3 PARAMETERS!
extern "C" __declspec(dllimport) void __stdcall NumberCallerDraw(const
void* dcaller, ArrayOfImage dimage, ArrayOfInteger dnum);
 
...
 
// 4 PARAMETER VALUES!
NumberCallerDraw( /*TnumberCaller::oPointer*/ XDATA, dimage.Length,
dimage, dnum );

Spin it any way you want, this is still a mismatch that the compiler
should be complaining about.

--
Remy Lebeau (TeamB)

roca robin wrote:


Why did you remove the construct and destructor that I had in that
struct? They were there for a reason. Do you understand what RAII is?
If not, you need to learn it if you want to be proficient at C++.


Not true. fimages[ndex] returns a reference to a TIplImage object, and
Image is a public member of TIplImage.


There is no fnumbers array in the second example that I gave you. You
are mixing together the two examples I gave you. They are not meant to
be mixed.


Again, not true, for the same reason as above.


Then you need to lean how you use your debugger better so you can track
down EXACTLY where the error is coming from and why it is being raised.


No, it shouldn't. One, because you are passing in a useless parameter
(dnum) that the caller has no business passing in at all. Two, because
you should be passing arrays by reference, not by value. And three,
because of what I said earlier about you passing 4 parameters to a
function that only expects 3 parameters. Even if it did take 4
parameters, it doesn't make sense to pass 'dnum[0]' as a parameter
value, you probably meant to pass 'count' instead.


NO, NO, NO! I already told you earlier, DO NOT declare the imported
DLL function with DynamicArray parameters. The CORRECT signature,
based on your original posting, is:

extern "C" __declspec(dllimport) void __stdcall NumberCallerDraw(const
void* dcaller, IplImage** dimage, int* dnum);

Leave it like that.


Then you are not translating it to C++ corrctly. What does the Delphi
code look like?


No, it is not OK.

--
Remy Lebeau (TeamB)

roca robin wrote:


You are declaring the DLL's NumberCallerDraw() function incorrectly in both Delphi and C++.

When the Delphi code imports NumberCallerDraw() from the DLL, it is being imported as '_NumberCallerDraw@16'. The @16 means there are 16 bytes used for parameters on the call stack. But the parameters you have specified only account for 12 bytes (sizeof(Pointer) = 4, so 3 * 4 = 12). There is clearly a 4-byte parameter missing in your declarations (an integer for the numbr of elements in the arrays, perhaps?).

So, your claim that the Delphi code "RUNS very good" can't possibly be true, because it doesn't call NumberCallerDraw() correctly. I pointed this out to you earlier.

In any case, your translation of the Delphi code to C++ is not even close to being correct. Try something more like this instead:

unumbercaller.h

#ifndef unumbercallerH
#define unumbercallerH
 
#include <System.hpp>
#include "opencv2/imgproc/imgproc_c.h"
 
static const double dbldial = 1000.1;
static const String mycppdialdll = _D("mycppdialdll.dll");
 
typedef DynamicArray<IplImage*> ArrayOfImage;
typedef DynamicArray<int> ArrayOfInteger;
 
class xCommon : public TInterfacedObject
{
protected:
    void *creator;
public:
    __fastcall xCommon(void *xpointer);
};
 
__interface INumberCaller : public IInterface
{
public:
    virtual void __fastcall save(const String fn) = 0;
    virtual void __fastcall load(const String fn) = 0;
    virtual void __fastcall draw(ArrayOfImage dimage, ArrayOfInteger dnum) = 0;
};
 
class TNumberCaller : public xCommon, public INumberCaller
{
    INTFOBJECT_IMPL_IUNKNOWN(xCommon);
public:
    __fastcall TNumberCaller(int dial1 = 0, double dial2 = dbldial);
    __fastcall ~TNumberCaller();
 
    void __fastcall draw(ArrayOfImage dimage, ArrayOfInteger dnum);
    void __fastcall load(const String fn);
    void __fastcall save(const String fn);
};
 
#endif

unumbercaller.cpp

#include <vcl.h>
#pragma hdrstop
 
#include "unumbercaller.h"
 
__fastcall xCommon::xCommon(void *xpointer)
    : creator(xpointer)
{
}
 
extern "C"
{
    // also add the import .lib for mycppdial.dll to your project...
    __declspec(dllimport) void* __stdcall Create_NumberCaller(int dial1 = 1, double dial2 = dbldial);
    __declspec(dllimport) void __stdcall NumberCallerDraw(const void *x, int count, void *dimage, void *dnum);
    __declspec(dllimport) void __stdcall NumberCallerLoad(const void *x, const char *fn);
    __declspec(dllimport) void __stdcall NumberCallerSave(const void *x, const char *fn);
    __declspec(dllimport) void __stdcall DestroyNumberCaller(const void *x);
}
 
/* TNumberCaller */
 
__fastcall TNumberCaller::TNumberCaller(int dial1, double dial2)
    : xCommon(Create_NumberCaller(dial1, dial2))
{
}
 
__fastcall TNumberCaller::~TNumberCaller()
{
    if (creator)
    {
        DestroyNumberCaller(creator);
        creator = NULL;
    }
}
 
void __fastcall TNumberCaller::draw(ArrayOfImage dimage, ArrayOfInteger dnum)
{
    NumberCallerDraw(creator, dimage.Length, &dimage[0], &dnum[0]);
}
 
void __fastcall TNumberCaller::load(const String fn)
{
    NumberCallerLoad(creator, AnsiString(fn).c_str());
}
 
void __fastcall TNumberCaller::save(const String fn)
{
    NumberCallerSave(creator, AnsiString(fn).c_str());
}

Unit1.h

#ifndef Unit1H
#define Unit1H
 
#include <System.Classes.hpp>
#include <Vcl.Controls.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.Forms.hpp>
 
#inclue "unumbercaller.h"
 
class TForm1 : public TForm
{
__published:	// IDE-managed Components
private:	// User declarations
public:		// User declarations
    __fastcall TForm1(TComponent *Owner);
}
 
extern PACKAGE TForm1 *Form1;
extern DelphiInterface<INumberCaller> callerid; // I_Number_Caller
 
#endif

Unit1.cpp

#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.hpp"
 
#pragma package(smart_init)
#pragma resource "*.dfm"
 
TForm1 *Form1;
DelphiInterface<INumberCaller> callerid;
 
__fastcall TForm1::TForm1(TComponent *Owner)
    : TForm(Owner)
{
    callerid = (INumberCaller*) new TNumberCaller(1, 101.1);
    callerid->load(_D("callerfilenamebackup1.xlsx"));
    callerid->save(_D("callerfilenamebackup2.xlsx"));
    callerid->draw(fimages, fnumbers); // <-- where are those objects?
}

--
Remy Lebeau (TeamB)

roca robin wrote:


That is not what I meant. Where are the fimages and fnumbers variables
declared, and how are they populated? You didn't show that code.


There were a couple of typos in my last example. I have corrected
them, and tested the code to make sure it works now.

FYI, constructors in C++ MUST have the same name as the class, they
can't have user-defined names, like in Delphi. So it wonn't work if
you rename the constructor to Create().


Simply write another class and add the extra parameters you want. What
is so hard about that?

__interface INumberCaller2 : public INumberCaller
{
    // more methods here...
};
 
class TNumberCaller2 : public xCommon, public INumberCaller2
{
    INTFOBJECT_IMPL_IUNKNOWN(xCommon);
public:
    __fastcall TNumberCaller2(int dial1 = 0, double dial2 = dbldial,
const String &address3 = "", int param4 = 0);
    __fastcall ~TNumberCaller2();
 
    // INumberCaller methods...
    void __fastcall draw(ArrayOfImage dimage, ArrayOfInteger dnum);
    void __fastcall load(const String fn);
    void __fastcall save(const String fn);
 
    // INumberCaller2 methods...
    ...
};
 
__fastcall TNumberCaller2::TNumberCaller2(int dial1, double dial2,
const String &address3, int param4)
    : xCommon(Create_NumberCaller2(dial1, dial2,
AnsiString(address).c_str(), param4))
{
}
 
DelphiInterface<INumberCaller2> callerid2;
callerid2 = (INumberCaller2*) new TNumberCaller2(1, 101.1, "Mansion
Street, California", 1100);

--
Remy Lebeau (TeamB)

roca robin wrote:


That code has several memory leaks in it. You are leaking imagedrawn
and xdbimage on every loop iteration, and then after the loop finishes,
you free (incorrectly) only the 2 TBitmap objects that were created on
the last loop iteration.

You are also not protecting the code from exceptions.

Try this instead:

void __fastcall TForm1::LoadDatabase()
{
    int ndex;
    IplImage *dbimage;
    int id;
    String owner;
    Variant vimage;
    TBitmap *imagedrawn;
    TBitmap *xdbimage;
 
    ArrayOfImage fimages;
    ArrayOfInteger fnumbers;
    ArrayOfString fowners;
 
    size = cvSize(640, 480);
 
    if (sqliteconnect())
    {
        //
        //sql codes here...
        //
        sqliteQuery->Open();
        try
        {
            sqliteQuery->First();
            if (sqliteQuery->Eof)
                return;
 
            ndex = sqliteQuery->RecordCount;
 
            fowners.Length = ndex;
            fimages.Length = ndex;
            fnumbers.Length = ndex;
 
            ndex = 0;
 
            do
            {
                //..Test Fields Only
                id = sqliteQuery->FieldByName("id")->AsInteger;
                owner = sqliteQuery->FieldByName("owner")->AsString;
                vimage =
sqliteQuery->FieldByName("location")->AsVariant;
 
                imagedrawn = new TBitmap;
                try
                {
                    VariantToBMPViaJPEG(&vimage, imagedrawn);
 
                    fimages[ndex] = Bitmap2IplImage(imagedrawn);
                    fnumbers[ndex] = ndex;
                    fowners[ndex] = owner;
 
                    ++ndex;
                }
                __finally
                {
                    delete imagedrawn;
                }
 
                //..For Testing Only
                xdbimage = new TBitmap;
                try
                {
                    IplImage2Bitmap(fimages[ndex-1], xdbimage);
                    imgCallerLocation->Picture->Assign(xdbimage);
                }
                __finally
                {
                    delete xdbimage;
                }
 
                sqliteQuery->Next();
            }
            while (!sqliteQuery->Eof);
        }
        __finally
        {
            sqliteQuery->Close();
        }
    }
}

Then you did somthing wwrong in the declarations of TNumberCaller1 and
TNumberCaller2, because the TNumberCaller2 I showed you derives from
xCommon, so it is not an unambiguous base class.

--
Remy Lebeau (TeamB)