You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
656 lines
21 KiB
656 lines
21 KiB
//=============================================================================================================================
|
|
//
|
|
// EasyAR Sense 3.1.0-final-7bf6504c6
|
|
// Copyright (c) 2015-2020 VisionStar Information Technology (Shanghai) Co., Ltd. All Rights Reserved.
|
|
// EasyAR is the registered trademark or trademark of VisionStar Information Technology (Shanghai) Co., Ltd in China
|
|
// and other countries for the augmented reality technology developed by VisionStar Information Technology (Shanghai) Co., Ltd.
|
|
//
|
|
//=============================================================================================================================
|
|
|
|
#ifndef __EASYAR_IMAGETARGET_HXX__
|
|
#define __EASYAR_IMAGETARGET_HXX__
|
|
|
|
#include "easyar/types.hxx"
|
|
#include "easyar/target.hxx"
|
|
|
|
namespace easyar {
|
|
|
|
/// <summary>
|
|
/// ImageTargetParameters represents the parameters to create a `ImageTarget`_ .
|
|
/// </summary>
|
|
class ImageTargetParameters
|
|
{
|
|
protected:
|
|
easyar_ImageTargetParameters * cdata_ ;
|
|
void init_cdata(easyar_ImageTargetParameters * cdata);
|
|
virtual ImageTargetParameters & operator=(const ImageTargetParameters & data) { return *this; } //deleted
|
|
public:
|
|
ImageTargetParameters(easyar_ImageTargetParameters * cdata);
|
|
virtual ~ImageTargetParameters();
|
|
|
|
ImageTargetParameters(const ImageTargetParameters & data);
|
|
const easyar_ImageTargetParameters * get_cdata() const;
|
|
easyar_ImageTargetParameters * get_cdata();
|
|
|
|
ImageTargetParameters();
|
|
/// <summary>
|
|
/// Gets image.
|
|
/// </summary>
|
|
void image(/* OUT */ Image * * Return);
|
|
/// <summary>
|
|
/// Sets image.
|
|
/// </summary>
|
|
void setImage(Image * image);
|
|
/// <summary>
|
|
/// Gets target name. It can be used to distinguish targets.
|
|
/// </summary>
|
|
void name(/* OUT */ String * * Return);
|
|
/// <summary>
|
|
/// Sets target name.
|
|
/// </summary>
|
|
void setName(String * name);
|
|
/// <summary>
|
|
/// Gets the target uid. A target uid is useful in cloud based algorithms. If no cloud is used, you can set this uid in the json config as an alternative method to distinguish from targets.
|
|
/// </summary>
|
|
void uid(/* OUT */ String * * Return);
|
|
/// <summary>
|
|
/// Sets target uid.
|
|
/// </summary>
|
|
void setUid(String * uid);
|
|
/// <summary>
|
|
/// Gets meta data.
|
|
/// </summary>
|
|
void meta(/* OUT */ String * * Return);
|
|
/// <summary>
|
|
/// Sets meta data。
|
|
/// </summary>
|
|
void setMeta(String * meta);
|
|
/// <summary>
|
|
/// Gets the scale of image. The value is the physical image width divided by 1 meter. The default value is 1.
|
|
/// </summary>
|
|
float scale();
|
|
/// <summary>
|
|
/// Sets the scale of image. The value is the physical image width divided by 1 meter. The default value is 1.
|
|
/// It is needed to set the model scale in rendering engine separately.
|
|
/// </summary>
|
|
void setScale(float scale);
|
|
};
|
|
|
|
/// <summary>
|
|
/// ImageTarget represents planar image targets that can be tracked by `ImageTracker`_ .
|
|
/// The fields of ImageTarget need to be filled with the create.../setupAll method before it can be read. And ImageTarget can be tracked by `ImageTracker`_ after a successful load into the `ImageTracker`_ using `ImageTracker.loadTarget`_ .
|
|
/// </summary>
|
|
class ImageTarget : public Target
|
|
{
|
|
protected:
|
|
easyar_ImageTarget * cdata_ ;
|
|
void init_cdata(easyar_ImageTarget * cdata);
|
|
virtual ImageTarget & operator=(const ImageTarget & data) { return *this; } //deleted
|
|
public:
|
|
ImageTarget(easyar_ImageTarget * cdata);
|
|
virtual ~ImageTarget();
|
|
|
|
ImageTarget(const ImageTarget & data);
|
|
const easyar_ImageTarget * get_cdata() const;
|
|
easyar_ImageTarget * get_cdata();
|
|
|
|
ImageTarget();
|
|
/// <summary>
|
|
/// Creates a target from parameters.
|
|
/// </summary>
|
|
static void createFromParameters(ImageTargetParameters * parameters, /* OUT */ ImageTarget * * Return);
|
|
/// <summary>
|
|
/// Creates a target from an etd file.
|
|
/// </summary>
|
|
static void createFromTargetFile(String * path, StorageType storageType, /* OUT */ ImageTarget * * Return);
|
|
/// <summary>
|
|
/// Creates a target from an etd data buffer.
|
|
/// </summary>
|
|
static void createFromTargetData(Buffer * buffer, /* OUT */ ImageTarget * * Return);
|
|
/// <summary>
|
|
/// Saves as an etd file.
|
|
/// </summary>
|
|
bool save(String * path);
|
|
/// <summary>
|
|
/// Creates a target from an image file. If not needed, name, uid, meta can be passed with empty string, and scale can be passed with default value 1.
|
|
/// </summary>
|
|
static void createFromImageFile(String * path, StorageType storageType, String * name, String * uid, String * meta, float scale, /* OUT */ ImageTarget * * Return);
|
|
/// <summary>
|
|
/// Setup all targets listed in the json file or json string from path with storageType. This method only parses the json file or string.
|
|
/// If path is json file path, storageType should be `App` or `Assets` or `Absolute` indicating the path type. Paths inside json files should be absolute path or relative path to the json file.
|
|
/// See `StorageType`_ for more descriptions.
|
|
/// </summary>
|
|
static void setupAll(String * path, StorageType storageType, /* OUT */ ListOfImageTarget * * Return);
|
|
/// <summary>
|
|
/// The scale of image. The value is the physical image width divided by 1 meter. The default value is 1.
|
|
/// </summary>
|
|
float scale();
|
|
/// <summary>
|
|
/// The aspect ratio of image, width divided by height.
|
|
/// </summary>
|
|
float aspectRatio();
|
|
/// <summary>
|
|
/// Sets image target scale, this will overwrite the value set in the json file or the default value. The value is the physical image width divided by 1 meter. The default value is 1.
|
|
/// It is needed to set the model scale in rendering engine separately.
|
|
/// </summary>
|
|
bool setScale(float scale);
|
|
/// <summary>
|
|
/// Returns a list of images that stored in the target. It is generally used to get image data from cloud returned target.
|
|
/// </summary>
|
|
void images(/* OUT */ ListOfImage * * Return);
|
|
/// <summary>
|
|
/// Returns the target id. A target id is a integer number generated at runtime. This id is non-zero and increasing globally.
|
|
/// </summary>
|
|
int runtimeID();
|
|
/// <summary>
|
|
/// Returns the target uid. A target uid is useful in cloud based algorithms. If no cloud is used, you can set this uid in the json config as a alternative method to distinguish from targets.
|
|
/// </summary>
|
|
void uid(/* OUT */ String * * Return);
|
|
/// <summary>
|
|
/// Returns the target name. Name is used to distinguish targets in a json file.
|
|
/// </summary>
|
|
void name(/* OUT */ String * * Return);
|
|
/// <summary>
|
|
/// Set name. It will erase previously set data or data from cloud.
|
|
/// </summary>
|
|
void setName(String * name);
|
|
/// <summary>
|
|
/// Returns the meta data set by setMetaData. Or, in a cloud returned target, returns the meta data set in the cloud server.
|
|
/// </summary>
|
|
void meta(/* OUT */ String * * Return);
|
|
/// <summary>
|
|
/// Set meta data. It will erase previously set data or data from cloud.
|
|
/// </summary>
|
|
void setMeta(String * data);
|
|
static void tryCastFromTarget(Target * v, /* OUT */ ImageTarget * * Return);
|
|
};
|
|
|
|
#ifndef __EASYAR_OPTIONALOFIMAGETARGET__
|
|
#define __EASYAR_OPTIONALOFIMAGETARGET__
|
|
struct OptionalOfImageTarget
|
|
{
|
|
bool has_value;
|
|
ImageTarget * value;
|
|
};
|
|
static inline easyar_OptionalOfImageTarget OptionalOfImageTarget_to_c(ImageTarget * o);
|
|
#endif
|
|
|
|
#ifndef __EASYAR_LISTOFIMAGETARGET__
|
|
#define __EASYAR_LISTOFIMAGETARGET__
|
|
class ListOfImageTarget
|
|
{
|
|
private:
|
|
easyar_ListOfImageTarget * cdata_;
|
|
virtual ListOfImageTarget & operator=(const ListOfImageTarget & data) { return *this; } //deleted
|
|
public:
|
|
ListOfImageTarget(easyar_ListOfImageTarget * cdata);
|
|
virtual ~ListOfImageTarget();
|
|
|
|
ListOfImageTarget(const ListOfImageTarget & data);
|
|
const easyar_ListOfImageTarget * get_cdata() const;
|
|
easyar_ListOfImageTarget * get_cdata();
|
|
|
|
ListOfImageTarget(easyar_ImageTarget * * begin, easyar_ImageTarget * * end);
|
|
int size() const;
|
|
ImageTarget * at(int index) const;
|
|
};
|
|
#endif
|
|
|
|
#ifndef __EASYAR_LISTOFIMAGE__
|
|
#define __EASYAR_LISTOFIMAGE__
|
|
class ListOfImage
|
|
{
|
|
private:
|
|
easyar_ListOfImage * cdata_;
|
|
virtual ListOfImage & operator=(const ListOfImage & data) { return *this; } //deleted
|
|
public:
|
|
ListOfImage(easyar_ListOfImage * cdata);
|
|
virtual ~ListOfImage();
|
|
|
|
ListOfImage(const ListOfImage & data);
|
|
const easyar_ListOfImage * get_cdata() const;
|
|
easyar_ListOfImage * get_cdata();
|
|
|
|
ListOfImage(easyar_Image * * begin, easyar_Image * * end);
|
|
int size() const;
|
|
Image * at(int index) const;
|
|
};
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifndef __IMPLEMENTATION_EASYAR_IMAGETARGET_HXX__
|
|
#define __IMPLEMENTATION_EASYAR_IMAGETARGET_HXX__
|
|
|
|
#include "easyar/imagetarget.h"
|
|
#include "easyar/image.hxx"
|
|
#include "easyar/buffer.hxx"
|
|
#include "easyar/target.hxx"
|
|
|
|
namespace easyar {
|
|
|
|
inline ImageTargetParameters::ImageTargetParameters(easyar_ImageTargetParameters * cdata)
|
|
:
|
|
cdata_(NULL)
|
|
{
|
|
init_cdata(cdata);
|
|
}
|
|
inline ImageTargetParameters::~ImageTargetParameters()
|
|
{
|
|
if (cdata_) {
|
|
easyar_ImageTargetParameters__dtor(cdata_);
|
|
cdata_ = NULL;
|
|
}
|
|
}
|
|
|
|
inline ImageTargetParameters::ImageTargetParameters(const ImageTargetParameters & data)
|
|
:
|
|
cdata_(NULL)
|
|
{
|
|
easyar_ImageTargetParameters * cdata = NULL;
|
|
easyar_ImageTargetParameters__retain(data.cdata_, &cdata);
|
|
init_cdata(cdata);
|
|
}
|
|
inline const easyar_ImageTargetParameters * ImageTargetParameters::get_cdata() const
|
|
{
|
|
return cdata_;
|
|
}
|
|
inline easyar_ImageTargetParameters * ImageTargetParameters::get_cdata()
|
|
{
|
|
return cdata_;
|
|
}
|
|
inline void ImageTargetParameters::init_cdata(easyar_ImageTargetParameters * cdata)
|
|
{
|
|
cdata_ = cdata;
|
|
}
|
|
inline ImageTargetParameters::ImageTargetParameters()
|
|
:
|
|
cdata_(NULL)
|
|
{
|
|
easyar_ImageTargetParameters * _return_value_ = NULL;
|
|
easyar_ImageTargetParameters__ctor(&_return_value_);
|
|
init_cdata(_return_value_);
|
|
}
|
|
inline void ImageTargetParameters::image(/* OUT */ Image * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_Image * _return_value_ = NULL;
|
|
easyar_ImageTargetParameters_image(cdata_, &_return_value_);
|
|
*Return = new Image(_return_value_);
|
|
}
|
|
inline void ImageTargetParameters::setImage(Image * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTargetParameters_setImage(cdata_, arg0->get_cdata());
|
|
}
|
|
inline void ImageTargetParameters::name(/* OUT */ String * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_String * _return_value_ = NULL;
|
|
easyar_ImageTargetParameters_name(cdata_, &_return_value_);
|
|
*Return = new String(_return_value_);
|
|
}
|
|
inline void ImageTargetParameters::setName(String * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTargetParameters_setName(cdata_, arg0->get_cdata());
|
|
}
|
|
inline void ImageTargetParameters::uid(/* OUT */ String * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_String * _return_value_ = NULL;
|
|
easyar_ImageTargetParameters_uid(cdata_, &_return_value_);
|
|
*Return = new String(_return_value_);
|
|
}
|
|
inline void ImageTargetParameters::setUid(String * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTargetParameters_setUid(cdata_, arg0->get_cdata());
|
|
}
|
|
inline void ImageTargetParameters::meta(/* OUT */ String * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_String * _return_value_ = NULL;
|
|
easyar_ImageTargetParameters_meta(cdata_, &_return_value_);
|
|
*Return = new String(_return_value_);
|
|
}
|
|
inline void ImageTargetParameters::setMeta(String * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTargetParameters_setMeta(cdata_, arg0->get_cdata());
|
|
}
|
|
inline float ImageTargetParameters::scale()
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return float();
|
|
}
|
|
float _return_value_ = easyar_ImageTargetParameters_scale(cdata_);
|
|
return _return_value_;
|
|
}
|
|
inline void ImageTargetParameters::setScale(float arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTargetParameters_setScale(cdata_, arg0);
|
|
}
|
|
|
|
inline ImageTarget::ImageTarget(easyar_ImageTarget * cdata)
|
|
:
|
|
Target(static_cast<easyar_Target *>(NULL)),
|
|
cdata_(NULL)
|
|
{
|
|
init_cdata(cdata);
|
|
}
|
|
inline ImageTarget::~ImageTarget()
|
|
{
|
|
if (cdata_) {
|
|
easyar_ImageTarget__dtor(cdata_);
|
|
cdata_ = NULL;
|
|
}
|
|
}
|
|
|
|
inline ImageTarget::ImageTarget(const ImageTarget & data)
|
|
:
|
|
Target(static_cast<easyar_Target *>(NULL)),
|
|
cdata_(NULL)
|
|
{
|
|
easyar_ImageTarget * cdata = NULL;
|
|
easyar_ImageTarget__retain(data.cdata_, &cdata);
|
|
init_cdata(cdata);
|
|
}
|
|
inline const easyar_ImageTarget * ImageTarget::get_cdata() const
|
|
{
|
|
return cdata_;
|
|
}
|
|
inline easyar_ImageTarget * ImageTarget::get_cdata()
|
|
{
|
|
return cdata_;
|
|
}
|
|
inline void ImageTarget::init_cdata(easyar_ImageTarget * cdata)
|
|
{
|
|
cdata_ = cdata;
|
|
{
|
|
easyar_Target * cdata_inner = NULL;
|
|
easyar_castImageTargetToTarget(cdata, &cdata_inner);
|
|
Target::init_cdata(cdata_inner);
|
|
}
|
|
}
|
|
inline ImageTarget::ImageTarget()
|
|
:
|
|
Target(static_cast<easyar_Target *>(NULL)),
|
|
cdata_(NULL)
|
|
{
|
|
easyar_ImageTarget * _return_value_ = NULL;
|
|
easyar_ImageTarget__ctor(&_return_value_);
|
|
init_cdata(_return_value_);
|
|
}
|
|
inline void ImageTarget::createFromParameters(ImageTargetParameters * arg0, /* OUT */ ImageTarget * * Return)
|
|
{
|
|
easyar_OptionalOfImageTarget _return_value_ = {false, NULL};
|
|
easyar_ImageTarget_createFromParameters(arg0->get_cdata(), &_return_value_);
|
|
*Return = (_return_value_.has_value ? new ImageTarget(_return_value_.value) : NULL);
|
|
}
|
|
inline void ImageTarget::createFromTargetFile(String * arg0, StorageType arg1, /* OUT */ ImageTarget * * Return)
|
|
{
|
|
easyar_OptionalOfImageTarget _return_value_ = {false, NULL};
|
|
easyar_ImageTarget_createFromTargetFile(arg0->get_cdata(), static_cast<easyar_StorageType>(arg1), &_return_value_);
|
|
*Return = (_return_value_.has_value ? new ImageTarget(_return_value_.value) : NULL);
|
|
}
|
|
inline void ImageTarget::createFromTargetData(Buffer * arg0, /* OUT */ ImageTarget * * Return)
|
|
{
|
|
easyar_OptionalOfImageTarget _return_value_ = {false, NULL};
|
|
easyar_ImageTarget_createFromTargetData(arg0->get_cdata(), &_return_value_);
|
|
*Return = (_return_value_.has_value ? new ImageTarget(_return_value_.value) : NULL);
|
|
}
|
|
inline bool ImageTarget::save(String * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return bool();
|
|
}
|
|
bool _return_value_ = easyar_ImageTarget_save(cdata_, arg0->get_cdata());
|
|
return _return_value_;
|
|
}
|
|
inline void ImageTarget::createFromImageFile(String * arg0, StorageType arg1, String * arg2, String * arg3, String * arg4, float arg5, /* OUT */ ImageTarget * * Return)
|
|
{
|
|
easyar_OptionalOfImageTarget _return_value_ = {false, NULL};
|
|
easyar_ImageTarget_createFromImageFile(arg0->get_cdata(), static_cast<easyar_StorageType>(arg1), arg2->get_cdata(), arg3->get_cdata(), arg4->get_cdata(), arg5, &_return_value_);
|
|
*Return = (_return_value_.has_value ? new ImageTarget(_return_value_.value) : NULL);
|
|
}
|
|
inline void ImageTarget::setupAll(String * arg0, StorageType arg1, /* OUT */ ListOfImageTarget * * Return)
|
|
{
|
|
easyar_ListOfImageTarget * _return_value_ = NULL;
|
|
easyar_ImageTarget_setupAll(arg0->get_cdata(), static_cast<easyar_StorageType>(arg1), &_return_value_);
|
|
*Return = new ListOfImageTarget(_return_value_);
|
|
}
|
|
inline float ImageTarget::scale()
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return float();
|
|
}
|
|
float _return_value_ = easyar_ImageTarget_scale(cdata_);
|
|
return _return_value_;
|
|
}
|
|
inline float ImageTarget::aspectRatio()
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return float();
|
|
}
|
|
float _return_value_ = easyar_ImageTarget_aspectRatio(cdata_);
|
|
return _return_value_;
|
|
}
|
|
inline bool ImageTarget::setScale(float arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return bool();
|
|
}
|
|
bool _return_value_ = easyar_ImageTarget_setScale(cdata_, arg0);
|
|
return _return_value_;
|
|
}
|
|
inline void ImageTarget::images(/* OUT */ ListOfImage * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_ListOfImage * _return_value_ = NULL;
|
|
easyar_ImageTarget_images(cdata_, &_return_value_);
|
|
*Return = new ListOfImage(_return_value_);
|
|
}
|
|
inline int ImageTarget::runtimeID()
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return int();
|
|
}
|
|
int _return_value_ = easyar_ImageTarget_runtimeID(cdata_);
|
|
return _return_value_;
|
|
}
|
|
inline void ImageTarget::uid(/* OUT */ String * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_String * _return_value_ = NULL;
|
|
easyar_ImageTarget_uid(cdata_, &_return_value_);
|
|
*Return = new String(_return_value_);
|
|
}
|
|
inline void ImageTarget::name(/* OUT */ String * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_String * _return_value_ = NULL;
|
|
easyar_ImageTarget_name(cdata_, &_return_value_);
|
|
*Return = new String(_return_value_);
|
|
}
|
|
inline void ImageTarget::setName(String * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTarget_setName(cdata_, arg0->get_cdata());
|
|
}
|
|
inline void ImageTarget::meta(/* OUT */ String * * Return)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_String * _return_value_ = NULL;
|
|
easyar_ImageTarget_meta(cdata_, &_return_value_);
|
|
*Return = new String(_return_value_);
|
|
}
|
|
inline void ImageTarget::setMeta(String * arg0)
|
|
{
|
|
if (cdata_ == NULL) {
|
|
return;
|
|
}
|
|
easyar_ImageTarget_setMeta(cdata_, arg0->get_cdata());
|
|
}
|
|
inline void ImageTarget::tryCastFromTarget(Target * v, /* OUT */ ImageTarget * * Return)
|
|
{
|
|
if (v == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
easyar_ImageTarget * cdata = NULL;
|
|
easyar_tryCastTargetToImageTarget(v->get_cdata(), &cdata);
|
|
if (cdata == NULL) {
|
|
*Return = NULL;
|
|
return;
|
|
}
|
|
*Return = new ImageTarget(cdata);
|
|
}
|
|
|
|
#ifndef __IMPLEMENTATION_EASYAR_OPTIONALOFIMAGETARGET__
|
|
#define __IMPLEMENTATION_EASYAR_OPTIONALOFIMAGETARGET__
|
|
static inline easyar_OptionalOfImageTarget OptionalOfImageTarget_to_c(ImageTarget * o)
|
|
{
|
|
if (o != NULL) {
|
|
easyar_OptionalOfImageTarget _return_value_ = {true, o->get_cdata()};
|
|
return _return_value_;
|
|
} else {
|
|
easyar_OptionalOfImageTarget _return_value_ = {false, NULL};
|
|
return _return_value_;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifndef __IMPLEMENTATION_EASYAR_LISTOFIMAGETARGET__
|
|
#define __IMPLEMENTATION_EASYAR_LISTOFIMAGETARGET__
|
|
inline ListOfImageTarget::ListOfImageTarget(easyar_ListOfImageTarget * cdata)
|
|
: cdata_(cdata)
|
|
{
|
|
}
|
|
inline ListOfImageTarget::~ListOfImageTarget()
|
|
{
|
|
if (cdata_) {
|
|
easyar_ListOfImageTarget__dtor(cdata_);
|
|
cdata_ = NULL;
|
|
}
|
|
}
|
|
|
|
inline ListOfImageTarget::ListOfImageTarget(const ListOfImageTarget & data)
|
|
: cdata_(static_cast<easyar_ListOfImageTarget *>(NULL))
|
|
{
|
|
easyar_ListOfImageTarget_copy(data.cdata_, &cdata_);
|
|
}
|
|
inline const easyar_ListOfImageTarget * ListOfImageTarget::get_cdata() const
|
|
{
|
|
return cdata_;
|
|
}
|
|
inline easyar_ListOfImageTarget * ListOfImageTarget::get_cdata()
|
|
{
|
|
return cdata_;
|
|
}
|
|
|
|
inline ListOfImageTarget::ListOfImageTarget(easyar_ImageTarget * * begin, easyar_ImageTarget * * end)
|
|
: cdata_(static_cast<easyar_ListOfImageTarget *>(NULL))
|
|
{
|
|
easyar_ListOfImageTarget__ctor(begin, end, &cdata_);
|
|
}
|
|
inline int ListOfImageTarget::size() const
|
|
{
|
|
return easyar_ListOfImageTarget_size(cdata_);
|
|
}
|
|
inline ImageTarget * ListOfImageTarget::at(int index) const
|
|
{
|
|
easyar_ImageTarget * _return_value_ = easyar_ListOfImageTarget_at(cdata_, index);
|
|
easyar_ImageTarget__retain(_return_value_, &_return_value_);
|
|
return new ImageTarget(_return_value_);
|
|
}
|
|
#endif
|
|
|
|
#ifndef __IMPLEMENTATION_EASYAR_LISTOFIMAGE__
|
|
#define __IMPLEMENTATION_EASYAR_LISTOFIMAGE__
|
|
inline ListOfImage::ListOfImage(easyar_ListOfImage * cdata)
|
|
: cdata_(cdata)
|
|
{
|
|
}
|
|
inline ListOfImage::~ListOfImage()
|
|
{
|
|
if (cdata_) {
|
|
easyar_ListOfImage__dtor(cdata_);
|
|
cdata_ = NULL;
|
|
}
|
|
}
|
|
|
|
inline ListOfImage::ListOfImage(const ListOfImage & data)
|
|
: cdata_(static_cast<easyar_ListOfImage *>(NULL))
|
|
{
|
|
easyar_ListOfImage_copy(data.cdata_, &cdata_);
|
|
}
|
|
inline const easyar_ListOfImage * ListOfImage::get_cdata() const
|
|
{
|
|
return cdata_;
|
|
}
|
|
inline easyar_ListOfImage * ListOfImage::get_cdata()
|
|
{
|
|
return cdata_;
|
|
}
|
|
|
|
inline ListOfImage::ListOfImage(easyar_Image * * begin, easyar_Image * * end)
|
|
: cdata_(static_cast<easyar_ListOfImage *>(NULL))
|
|
{
|
|
easyar_ListOfImage__ctor(begin, end, &cdata_);
|
|
}
|
|
inline int ListOfImage::size() const
|
|
{
|
|
return easyar_ListOfImage_size(cdata_);
|
|
}
|
|
inline Image * ListOfImage::at(int index) const
|
|
{
|
|
easyar_Image * _return_value_ = easyar_ListOfImage_at(cdata_, index);
|
|
easyar_Image__retain(_return_value_, &_return_value_);
|
|
return new Image(_return_value_);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif
|