diff options
| -rw-r--r-- | CMakeLists.txt | 2 | ||||
| -rw-r--r-- | cmake/FindPylon.cmake | 47 | ||||
| -rw-r--r-- | cmake/FindYAT.cmake | 6 | ||||
| -rw-r--r-- | src/CMakeLists.txt | 21 | ||||
| -rw-r--r-- | src/cameras/pylon_camera.cpp | 232 | ||||
| -rw-r--r-- | src/cameras/pylon_camera.h | 26 | ||||
| -rw-r--r-- | src/cameras/uca-pylon-camera.c | 288 | ||||
| -rw-r--r-- | src/cameras/uca-pylon-camera.h | 75 | ||||
| -rw-r--r-- | src/config.h.in | 1 | ||||
| -rw-r--r-- | src/uca-camera.c | 11 | ||||
| -rw-r--r-- | test/CMakeLists.txt | 12 | ||||
| -rw-r--r-- | test/grab.c | 3 | ||||
| -rw-r--r-- | test/grab_pylon.c | 95 |
13 files changed, 814 insertions, 5 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 109b7a6..91f0d14 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required(VERSION 2.8) -project(uca C) +project(uca) set(TARNAME "libuca") set(UCA_VERSION_MAJOR "0") diff --git a/cmake/FindPylon.cmake b/cmake/FindPylon.cmake new file mode 100644 index 0000000..f446df2 --- /dev/null +++ b/cmake/FindPylon.cmake @@ -0,0 +1,47 @@ + +# Try to find libpco.so +# +# Defines +# +# PCO_FOUND - system has libpco +# PCO_INCLUDE_DIRS - libpco include directory +# PCO_LIBRARIES - pco library + +find_package(YAT) + +find_package(PackageHandleStandardArgs) + +find_path(PYLON_DIRS include/pylon/PylonBase.h HINTS /opt/pylon ENV PYLON_ROOT) +set(GENICAM_ROOT ${PYLON_DIRS}/genicam) +set(PYLON_INCLUDE_DIRS ${PYLON_DIRS}/include ${GENICAM_ROOT}/library/CPP/include) + +# check for 32/64 bit +if (CMAKE_SIZEOF_VOID_P EQUAL 8) + set(PYLON_LIB_DIRS ${PYLON_DIRS}/lib64 ${PYLON_DIRS}/bin ${GENICAM_ROOT}/bin/Linux64_x64 + ${GENICAM_ROOT}/bin/Linux64_x64/GenApi/Generic) +else() + set(PYLON_LIB_DIRS ${PYLON_DIRS}/lib64 ${PYLON_DIRS}/bin ${GENICAM_ROOT}/bin/Linux32_i86 + ${GENICAM_ROOT}/bin/Linux32_i86/GenApi/Generic) +endif() + +find_library(PYLONBASE_LIB pylonbase PATHS ${PYLON_LIB_DIRS}) +find_library(PYLONUTILITY_LIB pylonutility PATHS ${PYLON_LIB_DIRS}) +find_library(PYLONGIGESUPP_LIB pylongigesupp PATHS ${PYLON_LIB_DIRS}) +find_library(GENAPI_LIB GenApi_gcc40_v2_1 PATHS ${PYLON_LIB_DIRS}) +find_library(GCBASE_LIB GCBase_gcc40_v2_1 PATHS ${PYLON_LIB_DIRS}) +set (PYLON_LIBS ${PYLONBASE_LIB} + ${PYLONUTILITY_LIB} + ${PYLONGIGESUPP_LIB} + ${GENAPI_LIB} + ${GCBASE_LIB} + ${YAT_LIB}) + +find_package_handle_standard_args(PYLON DEFAULT_MSG PYLON_LIBS PYLON_INCLUDE_DIRS) + +find_package(PkgConfig) +pkg_check_modules(BASLER_PYLON baslerpylon>=0.1.0 REQUIRED) +MESSAGE(LIBRARY_DIRS ${BASLER_PYLON_LIBRARY_DIRS}) +find_library(BASLERPYLON_LIB baslerpylon PATHS ${BASLER_PYLON_LIBRARY_DIRS}) + +#set (PYLON_LIBS ${PYLON_LIBS} ${BASLERPYLON_LIB}) + diff --git a/cmake/FindYAT.cmake b/cmake/FindYAT.cmake new file mode 100644 index 0000000..92da3c8 --- /dev/null +++ b/cmake/FindYAT.cmake @@ -0,0 +1,6 @@ + +find_package(PkgConfig) +pkg_check_modules(YAT yat>=1.7.7 REQUIRED) + +find_library(YAT_LIB yat ${YAT_LIBRARY_DIRS}) + diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 02a1005..5a3c014 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,4 +1,5 @@ cmake_minimum_required(VERSION 2.8) +set(CMAKE_VERBOSE_MAKEFILE TRUE) # --- Set sources ------------------------------------------------------------- set(uca_SRCS @@ -14,13 +15,14 @@ set(cameras) set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake) # --- Find camera interfaces -find_package(PCO) +#find_package(PCO) find_package(PF) find_package(IPE) +find_package(Pylon) # --- Find frame grabber interfaces -find_package(FgLib5) -find_package(ClSerMe4) +#find_package(FgLib5) +#find_package(ClSerMe4) # --- Miscellanous packages find_package(PkgConfig) @@ -90,6 +92,19 @@ if (IPE_FOUND) endif() endif() +if (PYLON_FOUND) + option(HAVE_PYLON_CAMERA "Camera: Pylon based (Basler)" ON) + + if (HAVE_PYLON_CAMERA) + set(uca_SRCS ${uca_SRCS} cameras/uca-pylon-camera.c cameras/pylon_camera.cpp) + set(uca_HDRS ${uca_HDRS} cameras/uca-pylon-camera.h) + set(uca_LIBS ${uca_LIBS} ${PYLON_LIBS}) + + include_directories(${PYLON_INCLUDE_DIRS}) + endif() + +endif() + if (HAVE_MOCK_CAMERA) list(APPEND uca_SRCS cameras/uca-mock-camera.c) list(APPEND uca_HDRS cameras/uca-mock-camera.h) diff --git a/src/cameras/pylon_camera.cpp b/src/cameras/pylon_camera.cpp new file mode 100644 index 0000000..eafcf06 --- /dev/null +++ b/src/cameras/pylon_camera.cpp @@ -0,0 +1,232 @@ + +#include "pylon_camera.h" +#include <yat/plugin/PlugInManager.h> +#include <yat/threading/Condition.h> +#include <baslerpylon/IGrabber.h> +#include <iostream> + +namespace { + + GrabAPI::IGrabber* pGrabber = 0; + //yat::Mutex* pImageMutex = NULL; + //yat::Condition* pImageCondition = NULL; + //yat::Mutex pImageMutex; + //yat::Condition pImageCondition(pImageMutex); + guint imageCounter = 0; + guint currentImage = 0; + GrabAPI::Image* image = NULL; + + void handle_image(GrabAPI::Image* newImage) + { + //g_assert(pImageMutex); + //g_assert(pImageCondition); + //yat::MutexLock lock(pImageMutex); + delete image; + image = newImage; + imageCounter++; + std::cerr << "signal next image ready " << std::endl; + //pImageCondition.signal(); + } + + void yat_exception_to_gerror(const yat::Exception& e, GError** error) + { + if (e.errors.size() == 2) + { + g_set_error(error, 0, 0, + "%s : %s : %s\n%s : %s : %s", + e.errors[0].reason.c_str(), + e.errors[0].desc.c_str(), + e.errors[0].origin.c_str(), + e.errors[1].reason.c_str(), + e.errors[1].desc.c_str(), + e.errors[1].origin.c_str()); + return; + } + if (e.errors.size() == 3) + { + g_set_error(error, 0, 0, + "%s : %s : %s\n%s : %s : %s\n%s : %s : %s", + e.errors[0].reason.c_str(), + e.errors[0].desc.c_str(), + e.errors[0].origin.c_str(), + e.errors[1].reason.c_str(), + e.errors[1].desc.c_str(), + e.errors[1].origin.c_str(), + e.errors[2].reason.c_str(), + e.errors[2].desc.c_str(), + e.errors[2].origin.c_str()); + return; + } + + g_set_error(error, 0, 0, + "%s : %s : %s", + e.errors[0].reason.c_str(), + e.errors[0].desc.c_str(), + e.errors[0].origin.c_str()); + } + +} + + +void pylon_camera_new(const char* lib_path, const char* camera_ip, GError** error) +{ + + g_assert(!pGrabber); + try { + + //pImageMutex = new yat::Mutex; + //pImageCondition = new yat::Condition(*pImageMutex); + + yat::PlugInManager pm; + std::pair<yat::IPlugInInfo*, yat::IPlugInFactory*> pp = + pm.load((std::string(lib_path) + "/libbaslerpylon.so").c_str()); + + yat::IPlugInObject* plugin_obj = 0; + pp.second->create(plugin_obj); + pGrabber = static_cast<GrabAPI::IGrabber*>(plugin_obj); + + yat::PlugInPropValues values; + values["CameraIP"] = yat::Any(std::string(camera_ip)); + pGrabber->set_properties(values); + pGrabber->initialize(); + pGrabber->set_image_handler(GrabAPI::ImageHandlerCallback::instanciate(handle_image)); + pGrabber->open(); + + } + catch (const yat::Exception& e) { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_set_exposure_time(gdouble exp_time, GError** error) +{ + g_assert(pGrabber); + try + { + pGrabber->set_exposure_time(yat::Any(exp_time)); + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_get_exposure_time(gdouble* exp_time, GError** error) +{ + g_assert(pGrabber); + try + { + yat::Any exp_time_result; + pGrabber->get_exposure_time(exp_time_result); + *exp_time = yat::any_cast<gdouble>(exp_time_result); + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + + +void pylon_camera_get_sensor_size(guint* width, guint* height, GError** error) +{ + g_assert(pGrabber); + try + { + yat::Any w, h; + pGrabber->get_sensor_width(w); + pGrabber->get_sensor_height(h); + *width = yat::any_cast<yat_int32_t>(w); + *height = yat::any_cast<yat_int32_t>(h); + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_get_bit_depth(guint* depth, GError** error) +{ + g_assert(pGrabber); + try + { + yat::Any bit_depth_result; + pGrabber->get_bit_depth(bit_depth_result); + *depth = yat::any_cast<yat_int32_t>(bit_depth_result); + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_start_acquision(GError** error) +{ + g_assert(pGrabber); + //g_assert(pImageMutex); + try + { + { + //yat::MutexLock lock(pImageMutex); + imageCounter = 0; + currentImage = 0; + } + pGrabber->start(); + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_stop_acquision(GError** error) +{ + g_assert(pGrabber); + try + { + pGrabber->stop(); + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_grab(gpointer *data, GError** error) +{ + g_assert(pGrabber); + //g_assert(pImageMutex); + //g_assert(pImageCondition); + sleep(1); + try + { + //yat::MutexLock lock(pImageMutex); + g_assert(currentImage <= imageCounter); + + while (currentImage == imageCounter) + { + std::cerr << "wait for next image... " << currentImage << std::endl; + //pImageCondition.wait(); + } + + std::cerr << "grab next image " << currentImage << ", " << imageCounter << std::endl; + g_assert(currentImage < imageCounter); + currentImage = imageCounter; + //memcpy(*data, image->base(), image->width() * image->height() * 2); + + } + catch (const yat::Exception& e) + { + yat_exception_to_gerror(e, error); + } +} + +void pylon_camera_delete() +{ + if (!pGrabber) + return; + + pGrabber->close(); + pGrabber->uninitialize(); + delete pGrabber; +} + diff --git a/src/cameras/pylon_camera.h b/src/cameras/pylon_camera.h new file mode 100644 index 0000000..8a474aa --- /dev/null +++ b/src/cameras/pylon_camera.h @@ -0,0 +1,26 @@ + +#ifndef _PYLON_CAMERA_H_ +#define _PYLON_CAMERA_H_ + +#include <glib.h> + +G_BEGIN_DECLS + +void pylon_camera_new(const gchar* lib_path, const gchar* camera_ip, GError** error); + +void pylon_camera_set_exposure_time(gdouble exp_time, GError** error); +void pylon_camera_get_exposure_time(gdouble* exp_time, GError** error); + +void pylon_camera_get_sensor_size(guint* width, guint* height, GError** error); +void pylon_camera_get_bit_depth(guint* depth, GError** error); + +void pylon_camera_start_acquision(GError** error); +void pylon_camera_stop_acquision(GError** error); +void pylon_camera_grab(gpointer *data, GError** error); + +void pylon_camera_delete(); + +G_END_DECLS + +#endif + diff --git a/src/cameras/uca-pylon-camera.c b/src/cameras/uca-pylon-camera.c new file mode 100644 index 0000000..82380bc --- /dev/null +++ b/src/cameras/uca-pylon-camera.c @@ -0,0 +1,288 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang <matthias.vogelgesang@kit.edu> + (Karlsruhe Institute of Technology) + + This library is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by the + Free Software Foundation; either version 2.1 of the License, or (at your + option) any later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + details. + + You should have received a copy of the GNU Lesser General Public License along + with this library; if not, write to the Free Software Foundation, Inc., 51 + Franklin St, Fifth Floor, Boston, MA 02110, USA */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include "uca-camera.h" +#include "uca-pylon-camera.h" +#include "pylon_camera.h" + + +/*#define HANDLE_PYLON_ERROR(err) \ + if ((err) != PYLON_NOERROR) { \ + g_set_error(error, UCA_PYLON_CAMERA_ERROR, \ + UCA_PYLON_CAMERA_ERROR_LIBPYLON_GENERAL,\ + "libpylon error %i", err); \ + return; \ + }*/ + +#define UCA_PYLON_CAMERA_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), UCA_TYPE_PYLON_CAMERA, UcaPylonCameraPrivate)) + +G_DEFINE_TYPE(UcaPylonCamera, uca_pylon_camera, UCA_TYPE_CAMERA) + +/** + * UcapylonCameraError: + * @UCA_PYLON_CAMERA_ERROR_LIBPYLON_INIT: Initializing libpylon failed + * @UCA_PYLON_CAMERA_ERROR_LIBPYLON_GENERAL: General libpylon error + * @UCA_PYLON_CAMERA_ERROR_UNSUPPORTED: Camera type is not supported + * @UCA_PYLON_CAMERA_ERROR_FG_INIT: Framegrabber initialization failed + * @UCA_PYLON_CAMERA_ERROR_FG_GENERAL: General framegrabber error + * @UCA_PYLON_CAMERA_ERROR_FG_ACQUISITION: Framegrabber acquisition error + */ +GQuark uca_pylon_camera_error_quark() +{ + return g_quark_from_static_string("uca-pylon-camera-error-quark"); +} + +enum { + PROP_NAME = N_BASE_PROPERTIES, + N_PROPERTIES +}; + +static gint base_overrideables[] = { + PROP_SENSOR_WIDTH, + PROP_SENSOR_HEIGHT, + PROP_SENSOR_BITDEPTH, +// PROP_SENSOR_HORIZONTAL_BINNING, +// PROP_SENSOR_HORIZONTAL_BINNINGS, +// PROP_SENSOR_VERTICAL_BINNING, +// PROP_SENSOR_VERTICAL_BINNINGS, +// PROP_SENSOR_MAX_FRAME_RATE, +// PROP_ROI_X, +// PROP_ROI_Y, +// PROP_ROI_WIDTH, +// PROP_ROI_HEIGHT, +// PROP_HAS_STREAMING, +// PROP_HAS_CAMRAM_RECORDING, + 0 +}; + + +static GParamSpec *pylon_properties[N_PROPERTIES] = { NULL, }; + + +struct _UcaPylonCameraPrivate { + guint frame_width; + guint frame_height; + guint bit_depth; + gsize num_bytes; + + guint width; + guint height; +}; + + + +UcaPylonCamera *uca_pylon_camera_new(GError **error) +{ + UcaPylonCamera *camera = g_object_new(UCA_TYPE_PYLON_CAMERA, NULL); + UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(camera); + + pylon_camera_new("/usr/local/lib64", "141.52.111.110", error); + if (*error) { + g_print("Error when calling pylon_camera_new %s\n", (*error)->message); + return NULL; + } + + return camera; +} + +static void uca_pylon_camera_start_recording(UcaCamera *camera, GError **error) +{ + g_return_if_fail(UCA_IS_PYLON_CAMERA(camera)); + UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(camera); + + priv->num_bytes = 2; + pylon_camera_start_acquision(error); + +} + +static void uca_pylon_camera_stop_recording(UcaCamera *camera, GError **error) +{ + g_return_if_fail(UCA_IS_PYLON_CAMERA(camera)); + UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(camera); + pylon_camera_stop_acquision(error); +} + +static void uca_pylon_camera_grab(UcaCamera *camera, gpointer *data, GError **error) +{ + g_return_if_fail(UCA_IS_PYLON_CAMERA(camera)); + UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(camera); + + if (*data == NULL) { + *data = g_malloc0(priv->frame_width * priv->frame_height * priv->num_bytes); + } + pylon_camera_grab(data, error); +} + +static void uca_pylon_camera_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) +{ + UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(object); + + switch (property_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + return; + } +} + +static void uca_pylon_camera_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) +{ + printf("pylon_get_property\n"); + UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(object); + GError* error = NULL; + + switch (property_id) { + + case PROP_SENSOR_WIDTH: + pylon_camera_get_sensor_size(&priv->width, &priv->height, &error); + g_value_set_uint(value, priv->width); + printf("pylon_get_property sensor width %d\n", priv->width); + break; + + case PROP_SENSOR_HEIGHT: + pylon_camera_get_sensor_size(&priv->width, &priv->height, &error); + g_value_set_uint(value, priv->height); + printf("pylon_get_property sensor height %d\n", priv->height); + break; + + /* + case PROP_SENSOR_MAX_FRAME_RATE: + g_value_set_float(value, priv->camera_description->max_frame_rate); + break; + */ + + case PROP_SENSOR_BITDEPTH: + pylon_camera_get_bit_depth(&priv->bit_depth, &error); + g_value_set_uint(value, priv->bit_depth); + printf("pylon_get_property depth %d\n", priv->bit_depth); + break; + + /* + case PROP_HAS_STREAMING: + g_value_set_boolean(value, TRUE); + break; + + case PROP_HAS_CAMRAM_RECORDING: + g_value_set_boolean(value, priv->camera_description->has_camram); + break; + + case PROP_ROI_X: + { + guint16 roi[4] = {0}; + guint err = pylon_get_roi(priv->pylon, roi); + g_value_set_uint(value, roi[0]); + } + break; + + case PROP_ROI_Y: + { + guint16 roi[4] = {0}; + guint err = pylon_get_roi(priv->pylon, roi); + g_value_set_uint(value, roi[1]); + } + break; + + case PROP_ROI_WIDTH: + { + guint16 roi[4] = {0}; + guint err = pylon_get_roi(priv->pylon, roi); + g_value_set_uint(value, (roi[2] - roi[0])); + } + break; + + case PROP_ROI_HEIGHT: + { + guint16 roi[4] = {0}; + guint err = pylon_get_roi(priv->pylon, roi); + g_value_set_uint(value, (roi[3] - roi[1])); + } + break; +*/ + case PROP_NAME: + { + //char *name = NULL; + //pylon_get_name(priv->pylon, &name); + g_value_set_string(value, "TestName"); + //free(name); + } + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void uca_pylon_camera_finalize(GObject *object) +{ + /*UcaPylonCameraPrivate *priv = UCA_PYLON_CAMERA_GET_PRIVATE(object); + + if (priv->horizontal_binnings) + g_value_array_free(priv->horizontal_binnings); + + if (priv->vertical_binnings) + g_value_array_free(priv->vertical_binnings); + + if (priv->fg) { + if (priv->fg_mem) + Fg_FreeMem(priv->fg, priv->fg_port); + + Fg_FreeGrabber(priv->fg); + } + + if (priv->pylon) + pylon_destroy(priv->pylon); + */ + + G_OBJECT_CLASS(uca_pylon_camera_parent_class)->finalize(object); +} + +static void uca_pylon_camera_class_init(UcaPylonCameraClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS(klass); + gobject_class->set_property = uca_pylon_camera_set_property; + gobject_class->get_property = uca_pylon_camera_get_property; + gobject_class->finalize = uca_pylon_camera_finalize; + + UcaCameraClass *camera_class = UCA_CAMERA_CLASS(klass); + camera_class->start_recording = uca_pylon_camera_start_recording; + camera_class->stop_recording = uca_pylon_camera_stop_recording; + camera_class->grab = uca_pylon_camera_grab; + + for (guint i = 0; base_overrideables[i] != 0; i++) + g_object_class_override_property(gobject_class, base_overrideables[i], uca_camera_props[base_overrideables[i]]); + + pylon_properties[PROP_NAME] = + g_param_spec_string("name", + "Name of the camera", + "Name of the camera", + "", G_PARAM_READABLE); + + + for (guint id = N_BASE_PROPERTIES; id < N_PROPERTIES; id++) + g_object_class_install_property(gobject_class, id, pylon_properties[id]); + + g_type_class_add_private(klass, sizeof(UcaPylonCameraPrivate)); +} + +static void uca_pylon_camera_init(UcaPylonCamera *self) +{ + self->priv = UCA_PYLON_CAMERA_GET_PRIVATE(self); +} + diff --git a/src/cameras/uca-pylon-camera.h b/src/cameras/uca-pylon-camera.h new file mode 100644 index 0000000..2f441dc --- /dev/null +++ b/src/cameras/uca-pylon-camera.h @@ -0,0 +1,75 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang <matthias.vogelgesang@kit.edu> + (Karlsruhe Institute of Technology) + + This library is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by the + Free Software Foundation; either version 2.1 of the License, or (at your + option) any later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + details. + + You should have received a copy of the GNU Lesser General Public License along + with this library; if not, write to the Free Software Foundation, Inc., 51 + Franklin St, Fifth Floor, Boston, MA 02110, USA */ + +#ifndef __UCA_PYLON_CAMERA_H +#define __UCA_PYLON_CAMERA_H + +#include <glib-object.h> + +#include "uca-camera.h" + +G_BEGIN_DECLS + +#define UCA_TYPE_PYLON_CAMERA (uca_pylon_camera_get_type()) +#define UCA_PYLON_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), UCA_TYPE_PYLON_CAMERA, UcaPylonCamera)) +#define UCA_IS_PYLON_CAMERA(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), UCA_TYPE_PYLON_CAMERA)) +#define UCA_PYLON_CAMERA_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), UFO_TYPE_PYLON_CAMERA, UfoPylonCameraClass)) +#define UCA_IS_PYLON_CAMERA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), UCA_TYPE_PYLON_CAMERA)) +#define UCA_PYLON_CAMERA_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), UCA_TYPE_PYLON_CAMERA, UcaPylonCameraClass)) + +#define UCA_PYLON_CAMERA_ERROR uca_pylon_camera_error_quark() +typedef enum { + UCA_PYLON_CAMERA_ERROR_LIBPYLON_INIT, + UCA_PYLON_CAMERA_ERROR_LIBPYLON_GENERAL, + UCA_PYLON_CAMERA_ERROR_UNSUPPORTED, +} UcaPylonCameraError; + +typedef struct _UcaPylonCamera UcaPylonCamera; +typedef struct _UcaPylonCameraClass UcaPylonCameraClass; +typedef struct _UcaPylonCameraPrivate UcaPylonCameraPrivate; + +/** + * UcaPylonCamera: + * + * Creates #UcaPylonCamera instances by loading corresponding shared objects. The + * contents of the #UcaPylonCamera structure are private and should only be + * accessed via the provided API. + */ +struct _UcaPylonCamera { + /*< private >*/ + UcaCamera parent; + + UcaPylonCameraPrivate *priv; +}; + +/** + * UcaPylonCameraClass: + * + * #UcaPylonCamera class + */ +struct _UcaPylonCameraClass { + /*< private >*/ + UcaCameraClass parent; +}; + +UcaPylonCamera *uca_pylon_camera_new(GError **error); + +GType uca_pylon_camera_get_type(void); + +G_END_DECLS + +#endif diff --git a/src/config.h.in b/src/config.h.in index 0b1dde9..e3911a1 100644 --- a/src/config.h.in +++ b/src/config.h.in @@ -2,6 +2,7 @@ #cmakedefine HAVE_PHOTON_FOCUS #cmakedefine HAVE_PHOTRON_FASTCAM #cmakedefine HAVE_UFO_CAMERA +#cmakedefine HAVE_PYLON_CAMERA #cmakedefine HAVE_MOCK_CAMERA #define CONTROL_GLADE_PATH "${CMAKE_INSTALL_PREFIX}/share/libuca/control.glade" diff --git a/src/uca-camera.c b/src/uca-camera.c index 1584569..602a3c4 100644 --- a/src/uca-camera.c +++ b/src/uca-camera.c @@ -24,6 +24,10 @@ #include "cameras/uca-pco-camera.h" #endif +#ifdef HAVE_PYLON_CAMERA +#include "cameras/uca-pylon-camera.h" +#endif + #ifdef HAVE_MOCK_CAMERA #include "cameras/uca-mock-camera.h" #endif @@ -65,6 +69,9 @@ static gchar *uca_camera_types[] = { #ifdef HAVE_PCO_CL "pco", #endif +#ifdef HAVE_PYLON_CAMERA + "pylon", +#endif #ifdef HAVE_MOCK_CAMERA "mock", #endif @@ -418,6 +425,10 @@ UcaCamera *uca_camera_new(const gchar *type, GError **error) camera = uca_camera_new_from_type(type, &tmp_error); +#ifdef HAVE_PYLON_CAMERA + if (!g_strcmp0(type, "pylon")) + camera = UCA_CAMERA(uca_pylon_camera_new(&tmp_error)); +#endif if (tmp_error != NULL) { g_propagate_error(error, tmp_error); return NULL; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 9050ce5..f6ca865 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -16,6 +16,18 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/control.glade ${CMAKE_CURRENT_BINARY_ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/run.py ${CMAKE_CURRENT_BINARY_DIR}) # --- Build targets ----------------------------------------------------------- +#add_executable(enum enum.c) +add_executable(grab grab.c) +add_executable(grab_pylon grab_pylon.c) +#add_executable(grab-async grab-async.c) +#add_executable(benchmark benchmark.c) + +#target_link_libraries(enum uca) +target_link_libraries(grab uca-gobject ${GLIB2_LIBRARIES} ${GOBJECT2_LIBRARIES}) +target_link_libraries(grab_pylon uca-gobject ${GLIB2_LIBRARIES} ${GOBJECT2_LIBRARIES}) +#target_link_libraries(grab-async uca) +#target_link_libraries(benchmark uca) + include_directories( ${GLIB2_INCLUDE_DIRS} ${GOBJECT2_INCLUDE_DIRS} diff --git a/test/grab.c b/test/grab.c index a4d4aa3..41e6d88 100644 --- a/test/grab.c +++ b/test/grab.c @@ -114,7 +114,7 @@ int main(int argc, char *argv[]) uca_camera_start_recording(camera, &error); g_assert_no_error(error); - while (counter < 2) { + while (counter < 5) { g_print(" grab frame ... "); g_timer_start(timer); uca_camera_grab(camera, &buffer, &error); @@ -131,6 +131,7 @@ int main(int argc, char *argv[]) FILE *fp = fopen(filename, "wb"); fwrite(buffer, roi_width * roi_height, pixel_size, fp); fclose(fp); + g_usleep(2 * G_USEC_PER_SEC); } g_print("Stop recording\n"); diff --git a/test/grab_pylon.c b/test/grab_pylon.c new file mode 100644 index 0000000..cb1e534 --- /dev/null +++ b/test/grab_pylon.c @@ -0,0 +1,95 @@ +/* Copyright (C) 2011, 2012 Matthias Vogelgesang <matthias.vogelgesang@kit.edu> + (Karlsruhe Institute of Technology) + + This library is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by the + Free Software Foundation; either version 2.1 of the License, or (at your + option) any later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + details. + + You should have received a copy of the GNU Lesser General Public License along + with this library; if not, write to the Free Software Foundation, Inc., 51 + Franklin St, Fifth Floor, Boston, MA 02110, USA */ + +#include <glib-object.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include "uca-camera.h" + +#define handle_error(errno) {if ((errno) != UCA_NO_ERROR) printf("error at <%s:%i>\n", \ + __FILE__, __LINE__);} + +static UcaCamera *camera = NULL; + +void sigint_handler(int signal) +{ + printf("Closing down libuca\n"); + uca_camera_stop_recording(camera, NULL); + g_object_unref(camera); + exit(signal); +} + +int main(int argc, char *argv[]) +{ + GError *error = NULL; + (void) signal(SIGINT, sigint_handler); + + g_type_init(); + camera = uca_camera_new("pylon", &error); + + if (camera == NULL) { + g_print("Couldn't initialize camera\n"); + return 1; + } + + guint width, height, bits; + g_object_get(G_OBJECT(camera), + "sensor-width", &width, + "sensor-height", &height, + "sensor-bitdepth", &bits, + NULL); + + const int pixel_size = bits == 8 ? 1 : 2; + gpointer buffer = g_malloc0(width * height * pixel_size); + + gchar filename[FILENAME_MAX]; + + for (int i = 0; i < 2; i++) { + gint counter = 0; + g_print("Start recording\n"); + uca_camera_start_recording(camera, &error); + g_assert_no_error(error); + + while (counter < 50) { + g_print(" grab frame ... "); + uca_camera_grab(camera, &buffer, &error); + if (error != NULL) { + g_print("\nError: %s\n", error->message); + goto cleanup; + } + g_print("done\n"); + + snprintf(filename, FILENAME_MAX, "frame-%08i.raw", counter++); + FILE *fp = fopen(filename, "wb"); + fwrite(buffer, width*height, pixel_size, fp); + fclose(fp); + //g_usleep(2 * G_USEC_PER_SEC); + } + + g_print("Stop recording\n"); + uca_camera_stop_recording(camera, &error); + g_assert_no_error(error); + } + +cleanup: + uca_camera_stop_recording(camera, NULL); + g_object_unref(camera); + g_free(buffer); + + return error != NULL ? 1 : 0; +} |