将 v8 对象转换为自定义 C++ 对象

Question

我目前正在开发一个用 C++ 编写的 nodejs 模块，我一直在寻找一种方法将 v8::Object 对象从 [=14] 转换为 cv::Mat 对象=]，暂时没有运气。

我看到 nan library 可以帮助转换对象，但我找不到如何，我什至不知道在我的情况下是否可以转换它们。

v8 juice项目符合我的预期，但由于它已被放弃，我只是不知道该怎么做。

这是我正在尝试做的事情的片段：

void
BRMatcher::run(const v8::FunctionCallbackInfo<v8::Value>& args)
{
  v8::Isolate* isolate = v8::Isolate::GetCurrent();
  v8::HandleScope scope(isolate);

  if (args.Length() < 1)
  {
    isolate->ThrowException(v8::Exception::TypeError(v8::String::NewFromUtf8(isolate, "Missing parameter [Mat img].")));
    return ;
  }

  if (!args[0]->IsObject())
  {
    isolate->ThrowException(v8::Exception::TypeError(v8::String::NewFromUtf8(isolate, "Parameter [Mat img] must be an object.")));
    return ;
  }

  v8::Local<v8::Object> cvMat(args[0]->ToObject());

  Mat img = ??? // This is where I ended up...
  // ...
}

Whosebug 上所有讨论此问题的帖子都已过时（旧版本或工具不再可用...）

所以我的问题是：如何将函数中接收到的参数转换为cv::Mat对象？我想要的任何类型？

任何帮助将不胜感激，谢谢！

Answer 1

首先，我建议查看 Node.js 的现有 openCV 绑定，例如 node-opencv。

如果您需要绑定 C++ 和 JavaScript 代码，有几个库。作为其中之一的作者，v8pp，我知道其他几个：

vu8（弃）
v8-juice（弃）
cpgf
Embind

据我所知，要将 C++ 对象转换为 v8::Object，它们都使用 v8::Object::SetAlignedPointerInInternalField() 函数。

C++ 对象到 v8::Object 的转换通常通过将 C++ 指针映射到映射容器中 V8 对象的持久句柄来执行。

Answer 2

一定要看看 Nodejs.org C++ 插件和 Nan 教程。尽管两者都有点误导，但它们无论如何都描述了规范的方式。使用 Nan 而不是直接 V8 API，因为这部分（过去和现在）变化很大。

有了 Nan，您正在寻找的是 passing wrapped objects. More precisely this line 是它的核心。

在 this fork of Node-OpenCV 中，我正在对 cv::Mat 做同样的事情，以使其成为 JS 领域的第一个 class 对象。也许这个实现可以帮助你。

TL;DR

Wrap the object with Nan::ObjectWrap and pass it around. Internally uses v8::SetInternalFieldPointer(); for you. This is basically copy-paste-able.

// lib/mat.js
var cv = require('./bindings')('addon');

function Mat() {

}

/**
 * returns the wrapped c++ object
 * [arguments optional]
 */
Mat.prototype.createMat = function (a) {
  var args = Array.prototype.slice.call(arguments);
  return cv.Mat.createMat(args[0])
}

// src/addon.cc
// just initializes all your modules. Magic happening in mat.h and matwrap.h 
// matwrap.cc is the implementation of the wrapped object. mat.cc holds 
// JS-libarary specific methods 

#include <nan.h>
#include "opencv.h"
#include "imgproc.h"
#include "mat.h"
#include "matwrap.h"

void InitAll(v8::Local<v8::Object> exports) {
   Opencv::Init(exports);
   ImgProc::Init(exports);
   Matwrap::Init();
   Mat::Init(exports);
}

NODE_MODULE(addon, InitAll)

这里有重要内容...

// src/matwrap.h
#ifndef MATWRAP_H
#define MATWRAP_H

#include <opencv2/opencv.hpp>
#include <nan.h>

class Matwrap : public Nan::ObjectWrap {
 public:
  static void Init();
  static v8::Local<v8::Object> NewInstance(v8::Local<v8::Value> arg);
  cv::Mat Val() const { return val_; }

 private:
  Matwrap();
  ~Matwrap();

  static Nan::Persistent<v8::Function> constructor;
  static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
  cv::Mat val_;
};

#endif

...和这里你正在包装它（基本上就是这样;按照下面的消费）：

// src/matwrap.cc
#include <node.h>
#include "matwrap.h"
#include <opencv2/opencv.hpp>

Matwrap::Matwrap() {};
Matwrap::~Matwrap() {};

Nan::Persistent<v8::Function> Matwrap::constructor;

void Matwrap::Init() {
  Nan::HandleScope scope;

  // Prepare constructor template
  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
  tpl->SetClassName(Nan::New("Matwrap").ToLocalChecked());
  tpl->InstanceTemplate()->SetInternalFieldCount(1);

  constructor.Reset(tpl->GetFunction());
}

void Matwrap::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
  // wrap it...
  Matwrap* obj = new Matwrap();
  cv::Mat src;
  obj->val_ = src;
  obj->Wrap(info.This());
  // return wrapped here...
  info.GetReturnValue().Set(info.This());
}

v8::Local<v8::Object> Matwrap::NewInstance(v8::Local<v8::Value> arg) {
  Nan::EscapableHandleScope scope;

  // const unsigned argc = 1;
  // v8::Local<v8::Value> argv[argc] = { arg };
  v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
  v8::Local<v8::Object> instance = cons->NewInstance();

  return scope.Escape(instance);
}

For consumption you could do stuff like this:

// lib/mat.js
/**
 * Returns true if the array has no elements.
 * @param  {Object} mat - native cv::Mat
 * @return {Boolean}
 */
Mat.prototype.empty = function (mat) {
  var args = Array.prototype.slice.call(arguments);
  return cv.Mat.empty(args[0])
}

// src/mat.h
// This is your API
#ifndef MAT_H
#define MAT_H

// #include <opencv2/opencv.hpp>
#include <nan.h>

class Mat : public Nan::ObjectWrap {
 public:
  static void Init(v8::Local<v8::Object> exports);

 private:
  explicit Mat(double value = 0);
  ~Mat();

  static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
  static void CreateMat(const Nan::FunctionCallbackInfo<v8::Value>& info);
  static void Empty(const Nan::FunctionCallbackInfo<v8::Value>& info);
  static void Total(const Nan::FunctionCallbackInfo<v8::Value>& info);
  static void Type(const Nan::FunctionCallbackInfo<v8::Value>& info);
  static Nan::Persistent<v8::Function> constructor;
  double value_;
};
#endif

// src/mat.cc
#include "mat.h"
#include "matwrap.h"
#include <opencv2/opencv.hpp>

Nan::Persistent<v8::Function> Mat::constructor;

Mat::Mat(double value) : value_(value) {
}

Mat::~Mat() {
}

void Mat::Init(v8::Local<v8::Object> exports) {
  Nan::HandleScope scope;

  // Prepare constructor template
  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
  tpl->SetClassName(Nan::New("Mat").ToLocalChecked());
  tpl->InstanceTemplate()->SetInternalFieldCount(1);

  // Prototype
  Nan::SetPrototypeMethod(tpl, "createMat", CreateMat);
  Nan::SetPrototypeMethod(tpl, "empty", Empty);
  Nan::SetPrototypeMethod(tpl, "total", Total);
  Nan::SetPrototypeMethod(tpl, "type", Type);

  constructor.Reset(tpl->GetFunction());
  exports->Set(Nan::New("Mat").ToLocalChecked(), tpl->GetFunction());
}

void Mat::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
  if (info.IsConstructCall()) {
    // Invoked as constructor: `new Opencv(...)`
    double value = info[0]->IsUndefined() ? 0 : info[0]->NumberValue();
    Mat* obj = new Mat(value);
    obj->Wrap(info.This());
    info.GetReturnValue().Set(info.This());
  } else {
    // Invoked as plain function `Opencv(...)`, turn into construct call.
    const int argc = 1;
    v8::Local<v8::Value> argv[argc] = { info[0] };
    v8::Local<v8::Function> cons = Nan::New<v8::Function>(constructor);
    info.GetReturnValue().Set(cons->NewInstance(argc, argv));
  }
}

void Mat::CreateMat(const Nan::FunctionCallbackInfo<v8::Value>& info) {

  info.GetReturnValue().Set(Matwrap::NewInstance(info[0]));
}

void Mat::Empty(const Nan::FunctionCallbackInfo<v8::Value>& info) {

  Matwrap* obj = Nan::ObjectWrap::Unwrap<Matwrap>(info[0]->ToObject());
  // check through cv::Mat::empty()
  if (obj->Val().empty()) {
    // return JS bool
    info.GetReturnValue().Set(Nan::True());
  } else {
    // TODO: logically not correct
    info.GetReturnValue().Set(Nan::False());
  }
}

将 v8 对象转换为自定义 C++ 对象

Convert a v8 Object to a custom C++ object

c++

node.js

opencv

v8

node.js-addon

TL;DR