Lire une image ECW avec Delphi

Version imprimable

25/07/2007, 14h24
geocad

Lire une image ECW avec Delphi

Bonjour, je suis tout neuf ici et je cherche à interfacer le SDK-ECW de ERMapper avec Delphi. Est-ce que quelqu'un a des tuyaux ou désire collaborer?
La SDK est écrite pour du C et je ne sais pas comment la transposer. Sans compter que pour l'accès aux dll, il va falloir utiliser la convention d'appel CDECL (enfin je cois)
help please
25/07/2007, 15h28
Dirk-Pitt

Le cdecl ne doit pas poser de problème.
25/07/2007, 16h58
geocad

Mon pb est que je na sais pas lire le C. Comment faire pour toute la partie déclaration ?
25/07/2007, 17h37
Dirk-Pitt

C'est gros ? Combien de .h ? Combien de lignes ?
25/07/2007, 18h46
geocad

J'ai 89 H de 5 ko chacun. Mais je ne veux que savoir lire le ecw. La sdk propose plein de fonctions qui touchent à l'écriture et je n"en ai pas besoin.
Mais pour le coup, j'ai l'impression d'abuser...:oops:
25/07/2007, 19h03
Dirk-Pitt

89 bigre ! Jette un oeil ici http://delphi-jedi.org/api-howto.html et là http://www.drbob42.com/delphi/headconv.htm ces outils peuvent t'aider.

Bon courage.
26/07/2007, 09h12
geocad

En fait je m'apprétais à accepter la traduction de un ou deux H pour prendre la suite moi-même, mais je viens de m'aperçevoir que j'ai des outils de traduction sur mon CD "companions tools".
Merci de m'y avoir fait penser! je vais les essayer tout de suite...
Je laisse la discussion ouverte pour l'instant, au cas ou...
26/07/2007, 09h28
Dirk-Pitt

Tu verras, les outil c'est bien mais il faut peaufiner à la main.

J'ai l'impression que mes outils font un peu n'importe quoi.
Est-ce que quelqu'un peut me traduire ça en Delphi pour vérifier:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
--------------------------------------------------------------------------
 
#ifndef NCSARRAY_H
#define NCSARRAY_H
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
 
#ifndef NCSMALLOC_H
#include "NCSMalloc.h"
#endif
 
#define NCS_ARRAY_GRANULAR
 
#ifdef NCS_ARRAY_GRANULAR
 
#define NCS_ARRAY_GRANULARITY 16
 
#define NCSArrayInsertElement(pArray, nElements, nIndex, pElement)    \
    if(nElements % NCS_ARRAY_GRANULARITY == 0) {            \
        void *pData = (void *)NCSRealloc((void *)(pArray),    \
            ((nElements) + NCS_ARRAY_GRANULARITY) *        \
            sizeof(*(pArray)),                \
            FALSE);                        \
        pArray = pData;                        \
    }                                \
    if((nIndex) < (nElements)) {                    \
        memmove(&((pArray)[(nIndex) + 1]),            \
            &((pArray)[(nIndex)]),                \
            ((nElements) - (nIndex)) * sizeof(*(pArray)));    \
    }                                \
    if(pElement) {                            \
        (pArray)[(nIndex)] = *(pElement);            \
    } else {                            \
        memset(&((pArray)[(nIndex)]), 0, sizeof(*pArray));    \
    }                                \
    (nElements) += 1
 
#define NCSArrayAppendElement(pArray, nElements, pElement)        \
    NCSArrayInsertElement(pArray, nElements, nElements, pElement)
 
#define NCSArrayRemoveElement(pArray, nElements, nIndex)        \
    if((nIndex) < (nElements) - 1) {                \
        memmove(&((pArray)[(nIndex)]),                \
            &((pArray)[(nIndex) + 1]),            \
            ((nElements) - (nIndex) - 1) * sizeof(*(pArray)));    \
    }                                \
    (nElements) -= 1;                        \
    if(nElements % NCS_ARRAY_GRANULARITY == 0) {            \
        if((nElements) > 0) {                    \
            void *pData = (void *)NCSRealloc((pArray),    \
                (nElements) * sizeof(*(pArray)),    \
                FALSE);                    \
            pArray = pData;                    \
        } else {                        \
            NCSFree((pArray));                \
            pArray = (void*)NULL;                \
        }                            \
    }
 
#else /* NCS_ARRAY_GRANULAR */
 
#define NCSArrayInsertElement(pArray, nElements, nIndex, pElement)    \
                (pArray) = NCSRealloc((pArray),                                        \
                                      (nElements + 1) * sizeof(*(pArray)),            \
                                      TRUE);                                        \
                if((nIndex) < (nElements)) {                                        \
                    memmove(&((pArray)[(nIndex) + 1]),                                \
                            &((pArray)[(nIndex)]),                                    \
                            ((nElements) - (nIndex)) * sizeof(*(pArray)));            \
                }                                                                    \
                if(pElement) {                                                        \
                    (pArray)[(nIndex)] = *(pElement);                                \
                }                                                                    \
                (nElements) += 1
 
#define NCSArrayAppendElement(pArray, nElements, pElement)                            \
                NCSArrayInsertElement(pArray, nElements, nElements, pElement)
 
#define NCSArrayRemoveElement(pArray, nElements, nIndex)                            \
                if((nIndex) < (nElements) - 1) {                                    \
                    memmove(&((pArray)[(nIndex)]),                                    \
                            &((pArray)[(nIndex) + 1]),                                \
                            ((nElements) - (nIndex) - 1) * sizeof(*(pArray)));        \
                }                                                                    \
                (nElements) -= 1;                                                    \
                if((nElements) > 0) {                                                \
                    (pArray) = NCSRealloc((pArray),                                    \
                                          (nElements) * sizeof(*(pArray)),            \
                                          FALSE);                                    \
                } else {                                                            \
                    NCSFree((pArray));                                                \
                    (pArray) = (void*)NULL;                                            \
                }
 
#endif /* NCS_ARRAY_GRANULAR */
 
#ifdef __cplusplus
}
#endif
 
#endif /* NCSARRAY_H */
 
--------------------------------------------------------------------------

26/07/2007, 14h07
Dirk-Pitt

Ce sont des macros, il faut les transcrire en routines Delphi.
26/07/2007, 15h50
geocad

Est-ce que quelqu'un peut m'aider à le faire, car je n'y comprends que dale.
26/07/2007, 15h54
Dirk-Pitt

Ooops, ça va être coton sans se plonger dans la totalité, par exemple NCSMalloc.h ... Cela m'ennuie de te laisser dans la panade, mais je n'ai pas trop le temps là, désolé.
26/07/2007, 17h07
geocad

Bon, ben peut-être que quelqu'un d'autre qui connait le C et Dephi peut maider...
C"est pour faire du freeware, et je n'ai donc pas un euro à dépenser sur le sujet...