s: declare struct! [
   a   [integer!]
   b   [c-string!]
]

image: declare IplImage! ; on déclare une structure et on réserve l'espace mémoire
image: cvCreateImage 640 480 IPL_DEPTH_32F 3 ; image est maintenant un pointeur
sur la structure IplImage! et on peut accéder aux membres de la structure en
utilisant la "path notation"

image/widh = 640
image/height = 480
.... 

cvZero as byte-ptr! image; met tous les pixels de l'image à zéro
[code]

Si maintenant on besoin de passer la structure par valeur à la fonction de la dll,
les choses se compliquent un peu. Les structures ne sont rien d'autre qu'une façon
de réserver un espace en mémoire pour stocker les données. Comme l'espace mémoire
de la dll et celui du code en Red/System n'est pas partagé et qu'implicitement
Red/System fournit une adresse vers la structure, la dll ne connaitra pas la taille
de la structure et la façon de stocker les valeurs associées à chaque membre.
La solution consiste simplement à passer par valeur chacun des membres de la structure. 

exemple
[code]
size: declare CvSize2D32f! (une structure avec 2 membres de type float32!)
size/width: 100.00
size/height: 200.00  
On peut donc écrire 
image: cvCreateImage size/width size/height IPL_DEPTH_32F 3

CvBox2D!: alias struct! [
    center      [CvPoint2D32f!] ;center of the box 
    size        [CvSize2D32f!]	;box width and length
    angle       [float32!]	;angle between the horizontal axis and the first side (i.e. length) in degrees
]

CvBox2D!: alias struct! [
    x		[float32!] ;center of the box
    y		[float32!] 
    width   [float32!]	;box width and length
    height	[float32!]	
    angle   [float32!]	;angle between the horizontal axis and the first side (i.e. length) in degrees
]

#system [
	; OpenCV functions we need
	#include %../../libs/red/types_r.reds           ; some specific structures for Red/S 
	#include %../../libs/core/types_c.reds          ; basic OpenCV types and structures`
	#include %../../libs/core/core.reds             ; OpenCV core functions
	#include %../../libs/highgui/highgui.reds       ; highgui functions
	#include %../../libs/videoio/videoio.reds       ; to play with camera
]

createImage: routine [ name [string!]
	] [
	cvInitFont font CV_FONT_HERSHEY_SIMPLEX 2.0 2.0 0.0 1 CV_AA
	image: cvCreateImage width height IPL_DEPTH_32F 3
	cvNamedWindow as c-string! string/rs-head name CV_WINDOW_AUTOSIZE
	cvZero as byte-ptr! image
	cvGetTextSize "Any key to start" font text_size as int-ptr! ymin
	pt1/x: (width - text_size/width) / 2
	pt1/y: (height + text_size/height) / 2
	cvPutText as byte-ptr! image "Any key to start" pt1/x pt1/y font 0.0 56.0 -56.0 0.0
	cvShowImage as c-string! string/rs-head name as byte-ptr! image
	cvwaitKey 0
]

Red []
inc: func [n [integer!]][random n]
#system [
   #call [inc 255]
   int: as red-integer! stack/arguments
   print int/value                     ;-- will print a random number
]

getSize: func [arr [CvArr!] return: [CvSize!]][
	sz: declare CvSize!
        cvGetSize arr
	sz/width: system/cpu/eax
	cvGetSize arr
	sz/height: system/cpu/edx
	sz
]

#ifndef CAMERALIB_H
#define CAMERALIB_H

#include "cameralib_global.h"
#include <opencv2/opencv.hpp>

using namespace cv;



class CAMERALIBSHARED_EXPORT CameraLib
{

public:
    CameraLib();
};

extern "C"
{
    VideoCapture cam;
    bool openCamera(int index);
    void releaseCamera();
    double getCameraProperty(int propId);
    bool setCameraProperty(int propId, double value);
    bool readCamera(OutputArray image);
}


#endif // CAMERALIB_H

#include "cameralib.h"

CameraLib::CameraLib()
{
}

bool openCamera(int index)
{
    return cam.open(index);
}

void releaseCamera()
{
    cam.release();
}

bool setCameraProperty(int propId, double value)
{
    return cam.set(propId,value);
}

double getCameraProperty(int propId)
{
    return cam.get(propId);
}

bool readCamera(OutputArray image)
{
    return cam.read(image);
}

CAMERALIBSHARED_EXPORT bool readCamera(Mat image)
{
    return (CameraLib::readCamera(image));
}

CAMERALIBSHARED_EXPORT bool readCamera(Mat image)
{
    return (readCamera(image));
}

; get memory as binary! string
getBinaryValue: routine [dataAddress [integer!] dataSize [integer!] return: [binary!] /local src p] [
"Get RBG values from OpenCV Image"
	src: as byte-ptr! dataAddress
	p:  allocate dataSize
	copy-memory p src dataSize
	stack/set-last as red-value! binary/load p dataSize
	binary/load p dataSize
]

; get memory as binary! string
; Thanks to Qtxie for the optimization!
getBinaryValue: routine [dataAddress [integer!] dataSize [integer!] return: [binary!]] [
	as red-binary! stack/set-last as red-value! binary/load as byte-ptr! dataAddress dataSize
]