Aravis

Chose promise, chose due

2 Comments

Here’s an example of the use of the ArvCamera API of Aravis:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include <arv.h>
#include <stdlib.h>
 
static gboolean cancel = FALSE;
 
static void
set_cancel (int signal)
{
    cancel = TRUE;
}
 
static char *arv_option_camera_name = NULL;
static char *arv_option_debug_domains = NULL;
static gboolean arv_option_snaphot = FALSE;
static gboolean arv_option_auto_buffer = FALSE;
static int arv_option_width = -1;
static int arv_option_height = -1;
static int arv_option_horizontal_binning = -1;
static int arv_option_vertical_binning = -1;
 
static const GOptionEntry arv_option_entries[] =
{
    { "name",       'n', 0, G_OPTION_ARG_STRING,
        &arv_option_camera_name,"Camera name", NULL},
    { "snapshot",       's', 0, G_OPTION_ARG_NONE,
        &arv_option_snaphot,    "Snapshot", NULL},
    { "auto",       'a', 0, G_OPTION_ARG_NONE,
        &arv_option_auto_buffer,    "AutoBufferSize", NULL},
    { "width",      'w', 0, G_OPTION_ARG_INT,
        &arv_option_width,      "Width", NULL },
    { "height",         'h', 0, G_OPTION_ARG_INT,
        &arv_option_height,         "Height", NULL },
    { "h-binning",      '\0', 0, G_OPTION_ARG_INT,
        &arv_option_horizontal_binning,"Horizontal binning", NULL },
    { "v-binning",      '\0', 0, G_OPTION_ARG_INT,
        &arv_option_vertical_binning,   "Vertical binning", NULL },
    { "debug",      'd', 0, G_OPTION_ARG_STRING,
        &arv_option_debug_domains,  "Debug mode", NULL },
    { NULL }
};
 
int
main (int argc, char **argv)
{
    ArvCamera *camera;
    ArvStream *stream;
    ArvBuffer *buffer;
    GOptionContext *context;
    GError *error = NULL;
    int i;
 
    g_thread_init (NULL);
    g_type_init ();
 
    context = g_option_context_new (NULL);
    g_option_context_add_main_entries (context, arv_option_entries, NULL);
 
    if (!g_option_context_parse (context, &argc, &argv, &error)) {
        g_option_context_free (context);
        g_print ("Option parsing failed: %s\n", error->message);
        g_error_free (error);
        return EXIT_FAILURE;
    }
 
    g_option_context_free (context);
 
    arv_debug_enable (arv_option_debug_domains);
 
    if (arv_option_camera_name == NULL)
        g_print ("Looking for the first available camera\n");
    else
        g_print ("Looking for camera '%s'\n", arv_option_camera_name);
 
    camera = arv_camera_new (arv_option_camera_name);
    if (camera != NULL) {
        gint payload;
        gint x, y, width, height;
        gint dx, dy;
        double exposure;
        guint64 n_processed_buffers;
        guint64 n_failures;
        guint64 n_underruns;
 
        arv_camera_set_region (camera, 0, 0, arv_option_width, arv_option_height);
        arv_camera_set_binning (camera, arv_option_horizontal_binning, arv_option_vertical_binning);
 
        arv_camera_get_region (camera, &x, &y, &width, &height);
        arv_camera_get_binning (camera, &dx, &dy);
        exposure = arv_camera_get_exposure_time (camera);
        payload = arv_camera_get_payload (camera);
 
        g_print ("image width         = %d\n", width);
        g_print ("image height        = %d\n", height);
        g_print ("horizontal binning  = %d\n", dx);
        g_print ("vertical binning    = %d\n", dy);
        g_print ("exposure            = %g µs\n", exposure);
 
        stream = arv_camera_new_stream (camera);
        if (arv_option_auto_buffer)
            arv_gv_stream_set_option (ARV_GV_STREAM (stream),
                          ARV_GV_STREAM_OPTION_SOCKET_BUFFER_AUTO,
                          0);
 
        for (i = 0; i < 30; i++)
            arv_stream_push_buffer (stream, arv_buffer_new (payload, NULL));
 
        arv_camera_start_acquisition (camera);
 
        signal (SIGINT, set_cancel);
 
        do {
            g_usleep (100000);
 
            do  {
                buffer = arv_stream_pop_buffer (stream);
                if (buffer != NULL) {
                    /* Image processing here */
                    arv_stream_push_buffer (stream, buffer);
                }
            } while (buffer != NULL);
        } while (!cancel);
 
        arv_stream_get_statistics (stream, &n_processed_buffers, &n_failures, &n_underruns);
 
        g_print ("Processed buffers = %Ld\n", n_processed_buffers);
        g_print ("Failures          = %Ld\n", n_failures);
        g_print ("Underruns         = %Ld\n", n_underruns);
 
        arv_camera_stop_acquisition (camera);
 
        g_object_unref (stream);
        g_object_unref (camera);
    } else
        g_print ("No camera found\n");
 
    return 0;
}

A direct use of the Genicam API is shown in the arv-test.c file in the git repository:
http://git.gnome.org/browse/aravis/tree/src/arvtest.c

2 thoughts on “Chose promise, chose due”

  1. I was looking for the GigE Vision Control Protocol and GigE Vision Stream Protocol standard a while ago but it looks like they are not freely available.
    You have to become a member of AIA.

    Do you have the protocols specification or did you reverse engineer it?

    Just curious.

  2. The GigE Vision protocol itself is quite simple and was reverse engineered. It’s not possible to use the protocol specification for an open source software.

Leave a Reply

Your email address will not be published. Required fields are marked *