Créer un SDK de caméra Python et l'utiliser pour la numérisation de plusieurs codes-barres

Maintenant que le SDK léger de la caméra C est complet pour Windows, Linux et macOS, nous pouvons l'intégrer dans d'autres langages de programmation de haut niveau. Dans cet article, nous explorerons comment créer un SDK de caméra Python basé sur la bibliothèque de caméras C et l'utiliser pour la numérisation de plusieurs codes-barres avec le SDK de lecteur de codes-barres Dynamsoft.

Vidéo de démonstration du scanner de codes-barres Python

Échafaudage d'un projet d'extension CPython

Une extension CPython est une bibliothèque partagée (par exemple, une DLL sous Windows, un .so sous Linux ou un .dylib sous macOS) qui peut être chargé dans l'interpréteur Python au moment de l'exécution et utilisé pour étendre ses fonctionnalités. La structure du projet d'extension CPython de la caméra Lite est la suivante :

python-lite-camera
│
│── include
│   ├── Camera.h
│   ├── CameraPreview.h
│   ├── stb_image_write.h
│── lib
│   ├── linux
│   │   ├── liblitecam.so
│   ├── macos
│   │   ├── liblitecam.dylib
│   ├── windows
│   │   ├── litecam.dll
│   │   ├── litecam.lib
├── src
│   ├── litecam.cpp
│   ├── pycamera.h
│   ├── pywindow.h
│── litecam
│   ├── __init__.py
│── setup.py
│── MANIFEST.in
│── README.md

Explication :

• include : Les fichiers d'en-tête de la bibliothèque de caméras C.
• lib : Les bibliothèques partagées de la bibliothèque de caméras C.
• src : Le code source du SDK de la caméra Python.
• litecam : Le point d'entrée de l'extension Python.
• setup.py : Le script de construction.
• MANIFEST.in : le fichier manifeste pour inclure des fichiers non Python.
• README.md : La documentation.

Écriture du script de construction setup.py pour l'extension Python

Ajoutez le contenu suivant à setup.py :

from setuptools.command import build_ext
from setuptools import setup, Extension
import sys
import os
import io
from setuptools.command.install import install
import shutil
from pathlib import Path

lib_dir = ''

sources = [
    "src/litecam.cpp",
]

include_dirs = [os.path.join(os.path.dirname(__file__), "include")]

libraries = ['litecam']

extra_compile_args = []

if sys.platform == "linux" or sys.platform == "linux2":
    lib_dir = 'lib/linux'
    extra_compile_args = ['-std=c++11']
    extra_link_args = ["-Wl,-rpath=$ORIGIN"]
elif sys.platform == "darwin":
    lib_dir = 'lib/macos'
    extra_compile_args = ['-std=c++11']
    extra_link_args = ["-Wl,-rpath,@loader_path"]
elif sys.platform == "win32":
    lib_dir = 'lib/windows'
    extra_link_args = []

else:
    raise RuntimeError("Unsupported platform")


long_description = io.open("README.md", encoding="utf-8").read()

module_litecam = Extension(
    "litecam",
    sources=sources,
    include_dirs=include_dirs,
    library_dirs=[lib_dir],
    libraries=libraries,
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

def copyfiles(src, dst):
    if os.path.isdir(src):
        filelist = os.listdir(src)
        for file in filelist:
            libpath = os.path.join(src, file)
            shutil.copy2(libpath, dst)
    else:
        shutil.copy2(src, dst)


class CustomBuildExt(build_ext.build_ext):
    def run(self):
        build_ext.build_ext.run(self)
        dst = os.path.join(self.build_lib, "litecam")
        copyfiles(lib_dir, dst)
        filelist = os.listdir(self.build_lib)
        for file in filelist:
            filePath = os.path.join(self.build_lib, file)
            if not os.path.isdir(file):
                copyfiles(filePath, dst)
                os.remove(filePath)


class CustomBuildExtDev(build_ext.build_ext):
    def run(self):
        build_ext.build_ext.run(self)
        dev_folder = os.path.join(Path(__file__).parent, 'litecam')
        copyfiles(lib_dir, dev_folder)
        filelist = os.listdir(self.build_lib)
        for file in filelist:
            filePath = os.path.join(self.build_lib, file)
            if not os.path.isdir(file):
                copyfiles(filePath, dev_folder)


class CustomInstall(install):
    def run(self):
        install.run(self)


setup(name='lite-camera',
      version='2.0.1',
      description='LiteCam is a lightweight, cross-platform library for capturing RGB frames from cameras and displaying them. Designed with simplicity and ease of integration in mind, LiteCam supports Windows, Linux and macOS platforms.',
      long_description=long_description,
      long_description_content_type="text/markdown",
      author='yushulx',
      url='https://github.com/yushulx/python-lite-camera',
      license='MIT',
      packages=['litecam'],
      ext_modules=[module_litecam],
      classifiers=[
           "Development Status :: 5 - Production/Stable",
           "Environment :: Console",
           "Intended Audience :: Developers",
          "Intended Audience :: Education",
          "Intended Audience :: Information Technology",
          "Intended Audience :: Science/Research",
          "License :: OSI Approved :: MIT License",
          "Operating System :: Microsoft :: Windows",
          "Operating System :: MacOS",
          "Operating System :: POSIX :: Linux",
          "Programming Language :: Python",
          "Programming Language :: Python :: 3",
          "Programming Language :: Python :: 3 :: Only",
          "Programming Language :: Python :: 3.6",
          "Programming Language :: Python :: 3.7",
          "Programming Language :: Python :: 3.8",
          "Programming Language :: Python :: 3.9",
          "Programming Language :: Python :: 3.10",
          "Programming Language :: Python :: 3.11",
          "Programming Language :: Python :: 3.12",
          "Programming Language :: C++",
          "Programming Language :: Python :: Implementation :: CPython",
          "Topic :: Scientific/Engineering",
          "Topic :: Software Development",
      ],
      cmdclass={
          'install': CustomInstall,
          'build_ext': CustomBuildExt,
          'develop': CustomBuildExtDev},
      )

Explication :

• lite-camera : Le nom du package Python.
• ext_modules : une liste d'extensions CPython. Il spécifie les fichiers sources, inclut les répertoires, les répertoires de bibliothèques, les bibliothèques et les indicateurs de compilation/lien pour différentes plates-formes.
• développer : une commande personnalisée pour le développement. Il copie les bibliothèques partagées dans le dossier Litecam pour des tests faciles.
• build_ext : personnalise le processus de construction pour empaqueter les bibliothèques partagées dans le package wheel.

Implémentation de l'API du SDK de caméra Python en C

Le fichier pycamera.h définit la classe Python PyCamera pour capturer les images de la caméra, tandis que le fichier pywindow.h définit la classe Python PyWindow pour afficher les images dans une fenêtre. Le fichier litecam.cpp sert de point d'entrée à l'extension Python, où certaines méthodes globales sont définies et où les classes PyCamera et PyWindow sont enregistrées.

pycamera.h

Comprend

python-lite-camera
│
│── include
│   ├── Camera.h
│   ├── CameraPreview.h
│   ├── stb_image_write.h
│── lib
│   ├── linux
│   │   ├── liblitecam.so
│   ├── macos
│   │   ├── liblitecam.dylib
│   ├── windows
│   │   ├── litecam.dll
│   │   ├── litecam.lib
├── src
│   ├── litecam.cpp
│   ├── pycamera.h
│   ├── pywindow.h
│── litecam
│   ├── __init__.py
│── setup.py
│── MANIFEST.in
│── README.md

• Python.h : Inclus pour utiliser l'API Python C.
• structmember.h : fournit des macros et des aides pour gérer les membres des objets.
• Camera.h : définit la classe Camera, que l'extension PyCamera encapsule.

Définition de la structure PyCamera

from setuptools.command import build_ext
from setuptools import setup, Extension
import sys
import os
import io
from setuptools.command.install import install
import shutil
from pathlib import Path

lib_dir = ''

sources = [
    "src/litecam.cpp",
]

include_dirs = [os.path.join(os.path.dirname(__file__), "include")]

libraries = ['litecam']

extra_compile_args = []

if sys.platform == "linux" or sys.platform == "linux2":
    lib_dir = 'lib/linux'
    extra_compile_args = ['-std=c++11']
    extra_link_args = ["-Wl,-rpath=$ORIGIN"]
elif sys.platform == "darwin":
    lib_dir = 'lib/macos'
    extra_compile_args = ['-std=c++11']
    extra_link_args = ["-Wl,-rpath,@loader_path"]
elif sys.platform == "win32":
    lib_dir = 'lib/windows'
    extra_link_args = []

else:
    raise RuntimeError("Unsupported platform")


long_description = io.open("README.md", encoding="utf-8").read()

module_litecam = Extension(
    "litecam",
    sources=sources,
    include_dirs=include_dirs,
    library_dirs=[lib_dir],
    libraries=libraries,
    extra_compile_args=extra_compile_args,
    extra_link_args=extra_link_args,
)

def copyfiles(src, dst):
    if os.path.isdir(src):
        filelist = os.listdir(src)
        for file in filelist:
            libpath = os.path.join(src, file)
            shutil.copy2(libpath, dst)
    else:
        shutil.copy2(src, dst)


class CustomBuildExt(build_ext.build_ext):
    def run(self):
        build_ext.build_ext.run(self)
        dst = os.path.join(self.build_lib, "litecam")
        copyfiles(lib_dir, dst)
        filelist = os.listdir(self.build_lib)
        for file in filelist:
            filePath = os.path.join(self.build_lib, file)
            if not os.path.isdir(file):
                copyfiles(filePath, dst)
                os.remove(filePath)


class CustomBuildExtDev(build_ext.build_ext):
    def run(self):
        build_ext.build_ext.run(self)
        dev_folder = os.path.join(Path(__file__).parent, 'litecam')
        copyfiles(lib_dir, dev_folder)
        filelist = os.listdir(self.build_lib)
        for file in filelist:
            filePath = os.path.join(self.build_lib, file)
            if not os.path.isdir(file):
                copyfiles(filePath, dev_folder)


class CustomInstall(install):
    def run(self):
        install.run(self)


setup(name='lite-camera',
      version='2.0.1',
      description='LiteCam is a lightweight, cross-platform library for capturing RGB frames from cameras and displaying them. Designed with simplicity and ease of integration in mind, LiteCam supports Windows, Linux and macOS platforms.',
      long_description=long_description,
      long_description_content_type="text/markdown",
      author='yushulx',
      url='https://github.com/yushulx/python-lite-camera',
      license='MIT',
      packages=['litecam'],
      ext_modules=[module_litecam],
      classifiers=[
           "Development Status :: 5 - Production/Stable",
           "Environment :: Console",
           "Intended Audience :: Developers",
          "Intended Audience :: Education",
          "Intended Audience :: Information Technology",
          "Intended Audience :: Science/Research",
          "License :: OSI Approved :: MIT License",
          "Operating System :: Microsoft :: Windows",
          "Operating System :: MacOS",
          "Operating System :: POSIX :: Linux",
          "Programming Language :: Python",
          "Programming Language :: Python :: 3",
          "Programming Language :: Python :: 3 :: Only",
          "Programming Language :: Python :: 3.6",
          "Programming Language :: Python :: 3.7",
          "Programming Language :: Python :: 3.8",
          "Programming Language :: Python :: 3.9",
          "Programming Language :: Python :: 3.10",
          "Programming Language :: Python :: 3.11",
          "Programming Language :: Python :: 3.12",
          "Programming Language :: C++",
          "Programming Language :: Python :: Implementation :: CPython",
          "Topic :: Scientific/Engineering",
          "Topic :: Software Development",
      ],
      cmdclass={
          'install': CustomInstall,
          'build_ext': CustomBuildExt,
          'develop': CustomBuildExtDev},
      )

La structure PyCamera représente l'objet Python qui entoure l'objet C Camera. Le gestionnaire est un pointeur vers une instance de la classe Camera.

Méthodes

• PyCamera_dealloc
  

  #include <Python.h>
  #include <structmember.h>
  #include "Camera.h"
  

  Désalloue l'objet Caméra et libère la mémoire associée.

• PyCamera_new
  

  typedef struct
  {
      PyObject_HEAD Camera *handler;
  } PyCamera;
  

  Crée une nouvelle instance de PyCamera. Il alloue de la mémoire à l'objet Python, crée un nouvel objet Caméra et l'attribue à self->handler.

• ouvrir
  

  static int PyCamera_clear(PyCamera *self)
  {
      if (self->handler)
      {
          delete self->handler;
      }
      return 0;
  }
  
  static void PyCamera_dealloc(PyCamera *self)
  {
      PyCamera_clear(self);
      Py_TYPE(self)->tp_free((PyObject *)self);
  }
  
  

  Ouvre la caméra avec l'index spécifié.

• listMediaTypes
  

  static PyObject *PyCamera_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
  {
      PyCamera *self;
  
      self = (PyCamera *)type->tp_alloc(type, 0);
      if (self != NULL)
      {
          self->handler = new Camera();
      }
  
      return (PyObject *)self;
  }
  
  

  Renvoie une liste des types de médias pris en charge. Pour Windows, il convertit la chaîne de caractères large en un objet Python Unicode.

• sortie
  

  static PyObject *open(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
  
      int index = 0;
      if (!PyArg_ParseTuple(args, "i", &index))
      {
          return NULL;
      }
  
      bool ret = self->handler->Open(index);
      return Py_BuildValue("i", ret);
  }
  

  Lâche la caméra.

• setRésolution
  

  static PyObject *listMediaTypes(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
  
      std::vector<MediaTypeInfo> mediaTypes = self->handler->ListSupportedMediaTypes();
  
      PyObject *pyList = PyList_New(0);
  
      for (size_t i = 0; i < mediaTypes.size(); i++)
      {
          MediaTypeInfo &mediaType = mediaTypes[i];
  
  #ifdef _WIN32
          PyObject *subtypeName = PyUnicode_FromWideChar(mediaType.subtypeName, wcslen(mediaType.subtypeName));
          PyObject *pyMediaType = Py_BuildValue("{s:i,s:i,s:O}",
                                                "width", mediaType.width,
                                                "height", mediaType.height,
                                                "subtypeName", subtypeName);
          if (subtypeName != NULL)
          {
              Py_DECREF(subtypeName);
          }
  
  #else
          PyObject *pyMediaType = Py_BuildValue("{s:i,s:i,s:s}",
                                                "width", mediaType.width,
                                                "height", mediaType.height,
                                                "subtypeName", mediaType.subtypeName);
  #endif
  
          PyList_Append(pyList, pyMediaType);
      }
  
      return pyList;
  }
  
  

  Définit la résolution de la caméra.

• captureFrame
  

  static PyObject *release(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
  
      self->handler->Release();
      Py_RETURN_NONE;
  }
  

  Capture une image de la caméra et renvoie les données RVB sous forme de tableau d'octets Python.

• getWidth et getHeight
  

  static PyObject *setResolution(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
      int width = 0, height = 0;
      if (!PyArg_ParseTuple(args, "ii", &width, &height))
      {
          return NULL;
      }
      int ret = self->handler->SetResolution(width, height);
      return Py_BuildValue("i", ret);
  }
  

  Renvoie la largeur et la hauteur du cadre capturé.

instance_methods

static PyObject *captureFrame(PyObject *obj, PyObject *args)
{
    PyCamera *self = (PyCamera *)obj;

    FrameData frame = self->handler->CaptureFrame();
    if (frame.rgbData)
    {
        PyObject *rgbData = PyByteArray_FromStringAndSize((const char *)frame.rgbData, frame.size);
        PyObject *pyFrame = Py_BuildValue("iiiO", frame.width, frame.height, frame.size, rgbData);
        ReleaseFrame(frame);

        return pyFrame;
    }
    else
    {
        Py_RETURN_NONE;
    }
}

Définit les méthodes disponibles sur l'objet Python PyCamera. Ces méthodes sont associées aux fonctions C correspondantes définies ci-dessus.

Type de caméra Py

static PyObject *getWidth(PyObject *obj, PyObject *args)
{
    PyCamera *self = (PyCamera *)obj;

    int width = self->handler->frameWidth;
    return Py_BuildValue("i", width);
}

static PyObject *getHeight(PyObject *obj, PyObject *args)
{
    PyCamera *self = (PyCamera *)obj;

    int height = self->handler->frameHeight;
    return Py_BuildValue("i", height);
}

Définit le type PyCamera, y compris ses méthodes, l'allocation de mémoire, la désallocation et d'autres comportements.

pywindow.h

Comprend

static PyMethodDef instance_methods[] = {
    {"open", open, METH_VARARGS, NULL},
    {"listMediaTypes", listMediaTypes, METH_VARARGS, NULL},
    {"release", release, METH_VARARGS, NULL},
    {"setResolution", setResolution, METH_VARARGS, NULL},
    {"captureFrame", captureFrame, METH_VARARGS, NULL},
    {"getWidth", getWidth, METH_VARARGS, NULL},
    {"getHeight", getHeight, METH_VARARGS, NULL},
    {NULL, NULL, 0, NULL}};

• Python.h : requis pour utiliser l'API Python C.
• structmember.h : fournit des macros pour gérer les membres des objets.
• CameraPreview.h : définit la classe CameraWindow, qui est utilisée pour afficher un aperçu de la caméra et interagir avec elle.

Définition de la structure PyWindow

static PyTypeObject PyCameraType = {
    PyVarObject_HEAD_INIT(NULL, 0) "litecam.PyCamera", /* tp_name */
    sizeof(PyCamera),                                  /* tp_basicsize */
    0,                                                 /* tp_itemsize */
    (destructor)PyCamera_dealloc,                      /* tp_dealloc */
    0,                                                 /* tp_print */
    0,                                                 /* tp_getattr */
    0,                                                 /* tp_setattr */
    0,                                                 /* tp_reserved */
    0,                                                 /* tp_repr */
    0,                                                 /* tp_as_number */
    0,                                                 /* tp_as_sequence */
    0,                                                 /* tp_as_mapping */
    0,                                                 /* tp_hash  */
    0,                                                 /* tp_call */
    0,                                                 /* tp_str */
    PyObject_GenericGetAttr,                           /* tp_getattro */
    PyObject_GenericSetAttr,                           /* tp_setattro */
    0,                                                 /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,          /*tp_flags*/
    "PyCamera",                                        /* tp_doc */
    0,                                                 /* tp_traverse */
    0,                                                 /* tp_clear */
    0,                                                 /* tp_richcompare */
    0,                                                 /* tp_weaklistoffset */
    0,                                                 /* tp_iter */
    0,                                                 /* tp_iternext */
    instance_methods,                                  /* tp_methods */
    0,                                                 /* tp_members */
    0,                                                 /* tp_getset */
    0,                                                 /* tp_base */
    0,                                                 /* tp_dict */
    0,                                                 /* tp_descr_get */
    0,                                                 /* tp_descr_set */
    0,                                                 /* tp_dictoffset */
    0,                                                 /* tp_init */
    0,                                                 /* tp_alloc */
    PyCamera_new,                                      /* tp_new */
};

Définit une structure PyWindow qui encapsule un objet C CameraWindow. Le membre gestionnaire pointe vers une instance de CameraWindow.

Méthodes pour l'objet PyWindow

• PyWindow_dealloc
  

  #include <Python.h>
  #include <structmember.h>
  #include "CameraPreview.h"
  

  Désalloue l'objet CameraWindow et libère la mémoire.

• PyWindow_new
  

  typedef struct
  {
      PyObject_HEAD CameraWindow *handler;
  } PyWindow;
  
  

  Crée une nouvelle instance de PyWindow. Il alloue de la mémoire à l'objet Python, crée un nouvel objet CameraWindow et l'attribue à self->handler.

• attendreClé
  

  python-lite-camera
  │
  │── include
  │   ├── Camera.h
  │   ├── CameraPreview.h
  │   ├── stb_image_write.h
  │── lib
  │   ├── linux
  │   │   ├── liblitecam.so
  │   ├── macos
  │   │   ├── liblitecam.dylib
  │   ├── windows
  │   │   ├── litecam.dll
  │   │   ├── litecam.lib
  ├── src
  │   ├── litecam.cpp
  │   ├── pycamera.h
  │   ├── pywindow.h
  │── litecam
  │   ├── __init__.py
  │── setup.py
  │── MANIFEST.in
  │── README.md
  

  Attend un événement d'appui sur une touche et renvoie False si la touche correspond au caractère spécifié. Le faux signifie que l'application doit se fermer.

• showFrame
  

  from setuptools.command import build_ext
  from setuptools import setup, Extension
  import sys
  import os
  import io
  from setuptools.command.install import install
  import shutil
  from pathlib import Path
  
  lib_dir = ''
  
  sources = [
      "src/litecam.cpp",
  ]
  
  include_dirs = [os.path.join(os.path.dirname(__file__), "include")]
  
  libraries = ['litecam']
  
  extra_compile_args = []
  
  if sys.platform == "linux" or sys.platform == "linux2":
      lib_dir = 'lib/linux'
      extra_compile_args = ['-std=c++11']
      extra_link_args = ["-Wl,-rpath=$ORIGIN"]
  elif sys.platform == "darwin":
      lib_dir = 'lib/macos'
      extra_compile_args = ['-std=c++11']
      extra_link_args = ["-Wl,-rpath,@loader_path"]
  elif sys.platform == "win32":
      lib_dir = 'lib/windows'
      extra_link_args = []
  
  else:
      raise RuntimeError("Unsupported platform")
  
  
  long_description = io.open("README.md", encoding="utf-8").read()
  
  module_litecam = Extension(
      "litecam",
      sources=sources,
      include_dirs=include_dirs,
      library_dirs=[lib_dir],
      libraries=libraries,
      extra_compile_args=extra_compile_args,
      extra_link_args=extra_link_args,
  )
  
  def copyfiles(src, dst):
      if os.path.isdir(src):
          filelist = os.listdir(src)
          for file in filelist:
              libpath = os.path.join(src, file)
              shutil.copy2(libpath, dst)
      else:
          shutil.copy2(src, dst)
  
  
  class CustomBuildExt(build_ext.build_ext):
      def run(self):
          build_ext.build_ext.run(self)
          dst = os.path.join(self.build_lib, "litecam")
          copyfiles(lib_dir, dst)
          filelist = os.listdir(self.build_lib)
          for file in filelist:
              filePath = os.path.join(self.build_lib, file)
              if not os.path.isdir(file):
                  copyfiles(filePath, dst)
                  os.remove(filePath)
  
  
  class CustomBuildExtDev(build_ext.build_ext):
      def run(self):
          build_ext.build_ext.run(self)
          dev_folder = os.path.join(Path(__file__).parent, 'litecam')
          copyfiles(lib_dir, dev_folder)
          filelist = os.listdir(self.build_lib)
          for file in filelist:
              filePath = os.path.join(self.build_lib, file)
              if not os.path.isdir(file):
                  copyfiles(filePath, dev_folder)
  
  
  class CustomInstall(install):
      def run(self):
          install.run(self)
  
  
  setup(name='lite-camera',
        version='2.0.1',
        description='LiteCam is a lightweight, cross-platform library for capturing RGB frames from cameras and displaying them. Designed with simplicity and ease of integration in mind, LiteCam supports Windows, Linux and macOS platforms.',
        long_description=long_description,
        long_description_content_type="text/markdown",
        author='yushulx',
        url='https://github.com/yushulx/python-lite-camera',
        license='MIT',
        packages=['litecam'],
        ext_modules=[module_litecam],
        classifiers=[
             "Development Status :: 5 - Production/Stable",
             "Environment :: Console",
             "Intended Audience :: Developers",
            "Intended Audience :: Education",
            "Intended Audience :: Information Technology",
            "Intended Audience :: Science/Research",
            "License :: OSI Approved :: MIT License",
            "Operating System :: Microsoft :: Windows",
            "Operating System :: MacOS",
            "Operating System :: POSIX :: Linux",
            "Programming Language :: Python",
            "Programming Language :: Python :: 3",
            "Programming Language :: Python :: 3 :: Only",
            "Programming Language :: Python :: 3.6",
            "Programming Language :: Python :: 3.7",
            "Programming Language :: Python :: 3.8",
            "Programming Language :: Python :: 3.9",
            "Programming Language :: Python :: 3.10",
            "Programming Language :: Python :: 3.11",
            "Programming Language :: Python :: 3.12",
            "Programming Language :: C++",
            "Programming Language :: Python :: Implementation :: CPython",
            "Topic :: Scientific/Engineering",
            "Topic :: Software Development",
        ],
        cmdclass={
            'install': CustomInstall,
            'build_ext': CustomBuildExt,
            'develop': CustomBuildExtDev},
        )
  

  Affiche un cadre dans la fenêtre.

• dessinerContour
  

  #include <Python.h>
  #include <structmember.h>
  #include "Camera.h"
  

  Dessine un contour (une série de points) sur le cadre.

• dessinerTexte
  

  typedef struct
  {
      PyObject_HEAD Camera *handler;
  } PyCamera;
  

  Dessine du texte sur le cadre.

window_instance_methods

static int PyCamera_clear(PyCamera *self)
{
    if (self->handler)
    {
        delete self->handler;
    }
    return 0;
}

static void PyCamera_dealloc(PyCamera *self)
{
    PyCamera_clear(self);
    Py_TYPE(self)->tp_free((PyObject *)self);
}

Définit les méthodes disponibles sur l'objet Python PyWindow.

Type de fenêtre Py

static PyObject *PyCamera_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    PyCamera *self;

    self = (PyCamera *)type->tp_alloc(type, 0);
    if (self != NULL)
    {
        self->handler = new Camera();
    }

    return (PyObject *)self;
}

Définit le type PyWindow, y compris ses méthodes, son allocation de mémoire, sa désallocation et d'autres comportements.

litecam.cpp

static PyObject *open(PyObject *obj, PyObject *args)
{
    PyCamera *self = (PyCamera *)obj;

    int index = 0;
    if (!PyArg_ParseTuple(args, "i", &index))
    {
        return NULL;
    }

    bool ret = self->handler->Open(index);
    return Py_BuildValue("i", ret);
}

Explication :

• getDeviceList : renvoie une liste des caméras disponibles.
• saveJpeg : enregistre un cadre sous forme d'image JPEG.
• PyInit_litecam : initialise le module litecam et enregistre les types PyCamera et PyWindow.

Construire le SDK de la caméra Python

• Mode Développement
  

  static PyObject *listMediaTypes(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
  
      std::vector<MediaTypeInfo> mediaTypes = self->handler->ListSupportedMediaTypes();
  
      PyObject *pyList = PyList_New(0);
  
      for (size_t i = 0; i < mediaTypes.size(); i++)
      {
          MediaTypeInfo &mediaType = mediaTypes[i];
  
  #ifdef _WIN32
          PyObject *subtypeName = PyUnicode_FromWideChar(mediaType.subtypeName, wcslen(mediaType.subtypeName));
          PyObject *pyMediaType = Py_BuildValue("{s:i,s:i,s:O}",
                                                "width", mediaType.width,
                                                "height", mediaType.height,
                                                "subtypeName", subtypeName);
          if (subtypeName != NULL)
          {
              Py_DECREF(subtypeName);
          }
  
  #else
          PyObject *pyMediaType = Py_BuildValue("{s:i,s:i,s:s}",
                                                "width", mediaType.width,
                                                "height", mediaType.height,
                                                "subtypeName", mediaType.subtypeName);
  #endif
  
          PyList_Append(pyList, pyMediaType);
      }
  
      return pyList;
  }
  
  

• Pack Roues
  

  static PyObject *release(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
  
      self->handler->Release();
      Py_RETURN_NONE;
  }
  

• Distribution des sources
  

  static PyObject *setResolution(PyObject *obj, PyObject *args)
  {
      PyCamera *self = (PyCamera *)obj;
      int width = 0, height = 0;
      if (!PyArg_ParseTuple(args, "ii", &width, &height))
      {
          return NULL;
      }
      int ret = self->handler->SetResolution(width, height);
      return Py_BuildValue("i", ret);
  }
  

Étapes pour implémenter un scanner de codes-barres Python

1. Installez le SDK de la caméra Python et le SDK du lecteur de codes-barres Dynamsoft :
   

   static PyObject *captureFrame(PyObject *obj, PyObject *args)
   {
       PyCamera *self = (PyCamera *)obj;
   
       FrameData frame = self->handler->CaptureFrame();
       if (frame.rgbData)
       {
           PyObject *rgbData = PyByteArray_FromStringAndSize((const char *)frame.rgbData, frame.size);
           PyObject *pyFrame = Py_BuildValue("iiiO", frame.width, frame.height, frame.size, rgbData);
           ReleaseFrame(frame);
   
           return pyFrame;
       }
       else
       {
           Py_RETURN_NONE;
       }
   }
   

2. Obtenez une licence d'essai gratuite de 30 jours pour Dynamsoft Barcode Reader.

3. Créez un script Python pour la numérisation de plusieurs codes-barres :
   

   static PyObject *getWidth(PyObject *obj, PyObject *args)
   {
       PyCamera *self = (PyCamera *)obj;
   
       int width = self->handler->frameWidth;
       return Py_BuildValue("i", width);
   }
   
   static PyObject *getHeight(PyObject *obj, PyObject *args)
   {
       PyCamera *self = (PyCamera *)obj;
   
       int height = self->handler->frameHeight;
       return Py_BuildValue("i", height);
   }
   

   Remplacez LICENSE-KEY par votre clé de licence Dynamsoft Barcode Reader.

4. Exécutez le script :
   

   static PyMethodDef instance_methods[] = {
       {"open", open, METH_VARARGS, NULL},
       {"listMediaTypes", listMediaTypes, METH_VARARGS, NULL},
       {"release", release, METH_VARARGS, NULL},
       {"setResolution", setResolution, METH_VARARGS, NULL},
       {"captureFrame", captureFrame, METH_VARARGS, NULL},
       {"getWidth", getWidth, METH_VARARGS, NULL},
       {"getHeight", getHeight, METH_VARARGS, NULL},
       {NULL, NULL, 0, NULL}};
   
   

   

Code source

https://github.com/yushulx/python-lite-camera

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!