Media Vision package includes following modules: Common, Media Vision Barcode,
Media Vision Face and Media Vision Image. Common module provides two handles
-(mv_source_h and mv_engine_config_h) and related fuctionality. It used by
+(mv_source_h and mv_engine_config_h) and related functionality. It used by
barcode detector and generator submodules. mv_source_h is used for wrapping raw
image data buffers. mv_engine_config_h is optional. It can be used for fine
tuning of internal libraries which are used by API. mv_engine_config_h handle
delete[] types;
}
- return TIZEN_ERROR_NONE;
+ return MEDIA_VISION_ERROR_NONE;
}
c. Change the packaging/capi-media-vision.spec to support any packages required
* </table>
* Before subscription of the event trigger with
* @ref mv_surveillance_subscribe_event_trigger() call it is possible to create
- * @ref mv_engine_config_h handle and configurate following attributes:
+ * @ref mv_engine_config_h handle and configure following attributes:
* - @ref MV_SURVEILLANCE_SKIP_FRAMES_COUNT to setup number of frames will be
ignored by event trigger;
* - @ref MV_SURVEILLANCE_MOVEMENT_DETECTION_THRESHOLD to specify sensitivity of
* Created engine config has to be used as a parameter of
* @ref mv_surveillance_subscribe_event_trigger() to apply the configuration. If
* NULL will be passed instead of valid @ref mv_engine_config_h handle, then
- * default attribute values will be used for subsriptions.
+ * default attribute values will be used for subscriptions.
* To make surveillance system work with video sequences
* @ref mv_surveillance_push_source() function has to
* be used for each frame in the sequence in the correct order. Multiple video
/**
* @brief Define MV_FACE_DETECTION_ROI_X to set X coordinate of face detection
- * roi as attribute of the engine configuration.
+ * roi (Region of Interest) as attribute of the engine configuration.
* @details Default value is -1 (the roi will be a full image) can be changed
* to specify the roi for face detection
*
/**
* @brief Define MV_FACE_DETECTION_ROI_Y to set Y coordinate of face detection
- * roi as attribute of the engine configuration.
+ * roi (Region of Interest) as attribute of the engine configuration.
* @details Default value is -1 (the roi will be a full image) can be changed
* to specify the roi for face detection
*
/**
* @brief Define MV_FACE_DETECTION_ROI_WIDTH to set width of face detection
- * roi as attribute of the engine configuration.
+ * roi (Region of Interest) as attribute of the engine configuration.
* @details Default value is -1 (the roi will be a full image) can be changed
* to specify the roi for face detection
*
/**
* @brief Define MV_FACE_DETECTION_ROI_HEIGHT to set height of face detection
- * roi as attribute of the engine configuration.
+ * roi (Region of Interest) as attribute of the engine configuration.
* @details Default value is -1 (the roi will be a full image) can be changed
* to specify the roi for face detection
*
* @see mv_surveillance_unsubscribe_event_trigger()
*/
typedef void (*mv_surveillance_event_occurred_cb)(
- mv_surveillance_event_trigger_h trigger,
- mv_source_h source,
- int video_stream_id,
- mv_surveillance_result_h event_result,
- void *user_data);
+ mv_surveillance_event_trigger_h trigger,
+ mv_source_h source,
+ int video_stream_id,
+ mv_surveillance_result_h event_result,
+ void *user_data);
/**
* @brief Called to get the information once for each supported event type.
* @see mv_surveillance_foreach_supported_event_type()
*/
typedef bool (*mv_surveillance_event_type_cb)(
- const char *event_type,
- void *user_data);
+ const char *event_type,
+ void *user_data);
/**
* @brief Called to get the result name from the triggered event.
* @see mv_surveillance_foreach_event_result_name()
*/
typedef bool (*mv_surveillance_event_result_name_cb)(
- const char *name,
- void *user_data);
+ const char *name,
+ void *user_data);
/**
* @brief Creates surveillance event trigger handle.
* @see mv_surveillance_foreach_supported_event_type()
*/
int mv_surveillance_event_trigger_create(
- const char *event_type,
- mv_surveillance_event_trigger_h *trigger);
+ const char *event_type,
+ mv_surveillance_event_trigger_h *trigger);
/**
* @brief Destroys the surveillance event trigger handle and releases all its
* @see mv_surveillance_event_trigger_create
*/
int mv_surveillance_event_trigger_destroy(
- mv_surveillance_event_trigger_h trigger);
+ mv_surveillance_event_trigger_h trigger);
/**
* @brief Gets the surveillance event trigger type as character string.
* @ref mv_surveillance_event_trigger_create() function
*/
int mv_surveillance_get_event_trigger_type(
- mv_surveillance_event_trigger_h trigger,
- char **event_type);
+ mv_surveillance_event_trigger_h trigger,
+ char **event_type);
/**
* @brief Sets ROI (Region Of Interest) to the event trigger.
* @see mv_surveillance_get_event_trigger_roi()
*/
int mv_surveillance_set_event_trigger_roi(
- mv_surveillance_event_trigger_h trigger,
- int number_of_points,
- mv_point_s *roi);
+ mv_surveillance_event_trigger_h trigger,
+ int number_of_points,
+ mv_point_s *roi);
/**
* @brief Gets ROI (Region Of Interest) from the event trigger.
* @see mv_surveillance_set_event_trigger_roi()
*/
int mv_surveillance_get_event_trigger_roi(
- mv_surveillance_event_trigger_h trigger,
- int *number_of_points,
- mv_point_s **roi);
+ mv_surveillance_event_trigger_h trigger,
+ int *number_of_points,
+ mv_point_s **roi);
/**
* @brief Subscribes @a trigger to process sources pushed from video identified
* @see mv_surveillance_push_source()
*/
int mv_surveillance_subscribe_event_trigger(
- mv_surveillance_event_trigger_h trigger,
- int video_stream_id,
- mv_engine_config_h engine_cfg,
- mv_surveillance_event_occurred_cb callback,
- void *user_data);
+ mv_surveillance_event_trigger_h trigger,
+ int video_stream_id,
+ mv_engine_config_h engine_cfg,
+ mv_surveillance_event_occurred_cb callback,
+ void *user_data);
/**
* @brief Unsubscribes @a trigger from the event and stop calling @a callback.
* @see mv_surveillance_subscribe_event_trigger()
*/
int mv_surveillance_unsubscribe_event_trigger(
- mv_surveillance_event_trigger_h trigger,
- int video_stream_id);
+ mv_surveillance_event_trigger_h trigger,
+ int video_stream_id);
/**
* @brief Pushes source to the surveillance system to detect events.
* @see mv_surveillance_unsubscribe_event_trigger()
*/
int mv_surveillance_push_source(
- mv_source_h source,
- int video_stream_id);
+ mv_source_h source,
+ int video_stream_id);
/**
* @brief Starts traversing through list of supported event types.
* @see mv_surveillance_foreach_event_result_name()
*/
int mv_surveillance_foreach_supported_event_type(
- mv_surveillance_event_type_cb callback,
- void *user_data);
+ mv_surveillance_event_type_cb callback,
+ void *user_data);
/**
* @brief Starts traversing through list of supported event result value names.
* @see mv_surveillance_get_result_value()
*/
int mv_surveillance_foreach_event_result_name(
- const char *event_type,
- mv_surveillance_event_result_name_cb callback,
- void *user_data);
+ const char *event_type,
+ mv_surveillance_event_result_name_cb callback,
+ void *user_data);
/**
* @brief Gets result value.
* @see mv_surveillance_foreach_event_result_name()
*/
int mv_surveillance_get_result_value(
- mv_surveillance_result_h result,
- const char *name,
- void *value);
+ mv_surveillance_result_h result,
+ const char *name,
+ void *value);
/**
* @}
* limitations under the License.
*/
-#ifndef __BARCODE_H__
-#define __BARCODE_H__
+#ifndef __MEDIA_VISION_BARCODE_H__
+#define __MEDIS_VISION_BARCODE_H__
#include "mv_barcode.h"
int calculateLocation(mv_quadrangle_s& location) const;
private:
- const zbar::Symbol *m_pBarcodeObj; ///< Pointer to zbar barcode handle
+ const zbar::Symbol *__pBarcodeObj; ///< Pointer to zbar barcode handle
};
} /* Barcode */
} /* MediaVision */
-#endif /* __BARCODE_H__ */
+#endif /* __MEDIA_VISION_BARCODE_H__ */
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_BARCODE_UTILS_H__
-#define __TIZEN_MEDIAVISION_BARCODE_UTILS_H__
+#ifndef __MEDIA_VISION_BARCODE_UTILS_H__
+#define __MEDIA_VISION_BARCODE_UTILS_H__
#include "mv_common.h"
namespace zbar {
-class Image;
+ class Image;
}
namespace MediaVision {
} /* Barcode */
} /* MediaVision */
-#endif /* __TIZEN_MEDIAVISION_BARCODE_UTILS_H__ */
+#endif /* __MEDIA_VISION_BARCODE_UTILS_H__ */
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_BARCODE_DETECT_OPEN_H__
-#define __TIZEN_MEDIAVISION_BARCODE_DETECT_OPEN_H__
+#ifndef __MEDIA_VISION_BARCODE_DETECT_OPEN_H__
+#define __MEDIA_VISION_BARCODE_DETECT_OPEN_H__
#include "mv_barcode_detect.h"
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_BARCODE_DETECT_OPEN_H__ */
+#endif /* __MEDIA_VISION_BARCODE_DETECT_OPEN_H__ */
namespace Barcode {
Barcode::Barcode(const zbar::Symbol& barObj):
- m_pBarcodeObj(new zbar::Symbol(barObj))
+ __pBarcodeObj(new zbar::Symbol(barObj))
{
- ; /* NULL */
+ ; /* NULL */
}
Barcode::~Barcode()
{
LOGI("Delete ZBar object");
- delete m_pBarcodeObj;
+ delete __pBarcodeObj;
}
std::string Barcode::getMessage(void) const
{
LOGI("Retrieve message data from ZBar object");
- return m_pBarcodeObj->get_data();
+ return __pBarcodeObj->get_data();
}
mv_barcode_type_e Barcode::getType(void) const
{
- zbar::zbar_symbol_type_t barcodeType = m_pBarcodeObj->get_type();
+ zbar::zbar_symbol_type_t barcodeType = __pBarcodeObj->get_type();
switch (barcodeType) {
case zbar::ZBAR_QRCODE:
return MV_BARCODE_QR;
+
case zbar::ZBAR_UPCA:
return MV_BARCODE_UPC_A;
+
case zbar::ZBAR_UPCE:
return MV_BARCODE_UPC_E;
+
case zbar::ZBAR_EAN8:
return MV_BARCODE_EAN_8;
+
case zbar::ZBAR_EAN13:
return MV_BARCODE_EAN_13;
+
case zbar::ZBAR_CODE128:
return MV_BARCODE_CODE128;
+
case zbar::ZBAR_CODE39:
return MV_BARCODE_CODE39;
+
case zbar::ZBAR_I25:
return MV_BARCODE_I2_5;
+
default:
LOGE("ZBar symbol colorspace is not supported by media vision");
return MV_BARCODE_UNDEFINED;
{
const int numberOfVertexes = 4;
- const int locationPolygonSize = m_pBarcodeObj->get_location_size();
+ const int locationPolygonSize = __pBarcodeObj->get_location_size();
- /*polygon location should contain at least 4 points */
+ /* polygon location should contain at least 4 points */
if (locationPolygonSize < numberOfVertexes) {
- LOGW("Can't compute location of the barcode by %i points (less then %i).", locationPolygonSize, numberOfVertexes);
+ LOGW("Can't compute location of the barcode by %i"
+ " points (less then %i).", locationPolygonSize,
+ numberOfVertexes);
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
- if (locationPolygonSize == numberOfVertexes) {
- for (int i = 0; i < numberOfVertexes; ++i) {
- location.points[i].x = m_pBarcodeObj->get_location_x(i);
- location.points[i].y = m_pBarcodeObj->get_location_y(i);
- }
-
- return MEDIA_VISION_ERROR_NONE;
- }
-
/* bounding quadrangle is computing by 4 marginal points */
- mv_point_s first = {m_pBarcodeObj->get_location_x(0), m_pBarcodeObj->get_location_y(0)};
+ mv_point_s first = {__pBarcodeObj->get_location_x(0),
+ __pBarcodeObj->get_location_y(0)};
int minX = first.x;
int maxX = first.x;
int maxY = first.y;
for (int i = 0; i < locationPolygonSize; ++i) {
- mv_point_s current = {m_pBarcodeObj->get_location_x(i), m_pBarcodeObj->get_location_y(i)};
+ mv_point_s current = {__pBarcodeObj->get_location_x(i),
+ __pBarcodeObj->get_location_y(i)};
if (current.x < minX) {
minX = current.x;
} else if (current.x > maxX) {
}
}
+ /* magic number("5") mean minimal size of detected area which will be returned. */
+ if (abs(minX - maxX) < 5 || abs(minY - maxY) < 5)
+ return MEDIA_VISION_ERROR_INVALID_OPERATION;
+
mv_point_s bottomLeft = {minX, maxY};
mv_point_s bottomRight = {maxX, maxY};
mv_point_s topRight = {maxX, minY};
namespace MediaVision {
namespace Barcode {
+
int convertSourceMV2Zbar(mv_source_h mvSource, zbar::Image& zbarSource)
{
int err = MEDIA_VISION_ERROR_NONE;
err = mv_source_get_colorspace_c(mvSource, &colorspace);
if (err != MEDIA_VISION_ERROR_NONE) {
- LOGW("Can't determine mv_source_h colorspace to convert to ZBar colorspace. Conversion failed");
+ LOGW("Can't determine mv_source_h colorspace to convert"
+ " to ZBar colorspace. Conversion failed");
return err;
}
mv_barcode_detected_cb detect_cb,
void *user_data)
{
- if (!source || !detect_cb) {
+ if (!source || !detect_cb)
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- }
zbar::Image image;
int err = convertSourceMV2Zbar(source, image);
zbar::ImageScanner scanner;
int target_val;
- err = mv_engine_config_get_int_attribute(engine_cfg, "MV_BARCODE_DETECT_ATTR_TARGET", &target_val);
+ err = mv_engine_config_get_int_attribute(
+ engine_cfg,
+ "MV_BARCODE_DETECT_ATTR_TARGET",
+ &target_val);
if (err != MEDIA_VISION_ERROR_NONE) {
LOGW("mv_engine_config_get_int_attribute failed");
return err;
}
int numberOfBarcodes = scanner.scan(greyImage);
- LOGI("ZBar scanner has found %i barcodes on the mv_source_h", numberOfBarcodes);
+ LOGI("ZBar scanner has found %i barcodes on the mv_source_h",
+ numberOfBarcodes);
mv_quadrangle_s *barcodeLocations = NULL;
mv_barcode_type_e *types = NULL;
if (numberOfBarcodes == 0) {
LOGI("Call the detect callback for 0 detected barcodes");
- detect_cb(source, engine_cfg, barcodeLocations, NULL, types, numberOfBarcodes, user_data);
+ detect_cb(source, engine_cfg, barcodeLocations, NULL,
+ types, numberOfBarcodes, user_data);
return MEDIA_VISION_ERROR_NONE;
} else if (numberOfBarcodes < 0) {
- LOGW("Incorrect number of barcodes (%i), detection is terminated", numberOfBarcodes);
+ LOGW("Incorrect number of barcodes (%i), detection is terminated",
+ numberOfBarcodes);
return MEDIA_VISION_ERROR_INTERNAL;
}
int err = curBarcode.calculateLocation(barcodeLocations[i]);
if (err != MEDIA_VISION_ERROR_NONE) {
LOGW("Can't determine location for barcode, detection is terminated");
- for (int j = 0; j <= i; ++j) {
+ for (int j = 0; j <= i; ++j)
delete[] messagesArray[j];
- }
delete[] messagesArray;
delete[] barcodeLocations;
delete[] types;
}
LOGI("Call the detect callback for %i detected barcodes", numberOfBarcodes);
- detect_cb(source, engine_cfg, barcodeLocations, messagesArray, types, numberOfBarcodes, user_data);
+ detect_cb(source, engine_cfg, barcodeLocations, messagesArray, types,
+ numberOfBarcodes, user_data);
LOGI("Clean the memory from barcodes messages, locations and types");
- for (int j = 0; j < numberOfBarcodes; ++j) {
+ for (int j = 0; j < numberOfBarcodes; ++j)
delete[] messagesArray[j];
- }
delete[] messagesArray;
delete[] barcodeLocations;
delete[] types;
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_BARCODE_DETECT_LIC_H__
-#define __TIZEN_MEDIAVISION_BARCODE_DETECT_LIC_H__
+#ifndef __MEDIA_VISION_BARCODE_DETECT_LIC_H__
+#define __MEDIA_VISION_BARCODE_DETECT_LIC_H__
#include "mv_barcode_detect.h"
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_BARCODE_DETECT_LIC_H__ */
+#endif /* __MEDIA_VISION_BARCODE_DETECT_LIC_H__ */
* limitations under the License.
*/
-#ifndef __BARCODEGENERATOR_H__
-#define __BARCODEGENERATOR_H__
+#ifndef __MEDIA_VISION_BARCODE_GENERATOR_H__
+#define __MEDIA_VISION_BARCODE_GENERATOR_H__
#include "BarcodeOptions.h"
} /* Barcode */
} /* MediaVision */
-#endif /* __BARCODEGENERATOR_H__ */
+#endif /* __MEDIA_VISION_BARCODE_GENERATOR_H__ */
* limitations under the License.
*/
-#ifndef __BARCODEOPTIONS_H__
-#define __BARCODEOPTIONS_H__
+#ifndef __MEDIA_VISION_BARCODE_OPTIONS_H__
+#define __MEDIA_VISION_BARCODE_OPTIONS_H__
/**
* @file BarcodeOptions.h
} /* Barcode */
} /* MediaVision */
-#endif /* __BARCODEOPTIONS_H__ */
+#endif /* __MEDIA_VISION_BARCODE_OPTIONS_H__ */
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_BARCODE_GENERATE_OPEN_H__
-#define __TIZEN_MEDIAVISION_BARCODE_GENERATE_OPEN_H__
+#ifndef __MEDIA_VISION_BARCODE_GENERATE_OPEN_H__
+#define __MEDIA_VISION_BARCODE_GENERATE_OPEN_H__
#include "mv_barcode_generate.h"
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_BARCODE_GENERATE_OPEN_H__ */
+#endif /* __MEDIA_VISION_BARCODE_GENERATE_OPEN_H__ */
namespace Barcode {
namespace {
+
int getFormatEncodingInfo(
BarcodeImageFormat imageFormat,
std::vector<std::string>& extensions,
std::vector<int>& compressionParams)
{
- static const int PNGCompressionLevel = 3;
+ static const int PNG_COMPRESSION_LEVEL = 3;
compressionParams.clear();
extensions.clear();
switch (imageFormat) {
case BARCODE_IMAGE_PNG:
compressionParams.push_back(CV_IMWRITE_PNG_COMPRESSION);
- compressionParams.push_back(PNGCompressionLevel);
+ compressionParams.push_back(PNG_COMPRESSION_LEVEL);
extensions.push_back(".png");
break;
case BARCODE_IMAGE_JPG:
}
}
- if (!rightExtensionFlag) {
+ if (!rightExtensionFlag)
resultFilePath += expectedExtensions[0];
- }
cv::Mat image(symbol->bitmap_height, symbol->bitmap_width, CV_8UC3, symbol->bitmap);
cv::resize(image, image, cv::Size(imageWidth, imageHeight), 0, 0, cv::INTER_AREA);
if (BARCODE_ERROR_NONE != error) {
LOGE("Write barcode image to file %s operation failed.",
- resultFilePath.c_str());
+ resultFilePath.c_str());
return error;
}
imageFormat,
imageWidth,
imageHeight);
- if (error != BARCODE_ERROR_NONE) {
+ if (error != BARCODE_ERROR_NONE)
LOGE("Barcode [%s] file write fail, clean memory", imageFileName.c_str());
- } else {
- LOGI("Barcode image [%s] is successfully generated, clean memory", imageFileName.c_str());
- }
+ else
+ LOGI("Barcode image [%s] is successfully generated, clean memory",
+ imageFileName.c_str());
ZBarcode_Delete(symbol);
*imageWidth = symbol->bitmap_width;
*imageHeight = symbol->bitmap_height;
*imageChannels = 3;
- const unsigned int imageBufferSize = (*imageWidth) * (*imageHeight) * (*imageChannels);
+ const unsigned int imageBufferSize = (*imageWidth) * (*imageHeight) *
+ (*imageChannels);
*imageBuffer = new unsigned char[imageBufferSize];
memmove(*imageBuffer, symbol->bitmap, imageBufferSize);
using namespace MediaVision::Barcode;
namespace {
+
int alphanumToUpper(std::string& strToTransform)
{
std::string tempString = strToTransform;
std::transform(tempString.begin(), tempString.end(),
- tempString.begin(), ::toupper);
+ tempString.begin(), ::toupper);
- if (std::string::npos != tempString.find_first_not_of("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")) {
+ if (std::string::npos != tempString.find_first_not_of(
+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:")) {
LOGE("Barcode message can't be converted according to support "
"alphanumeric (0..9, A..Z, space, $, %, *, +, -, ., /, :) "
"mode: %s", strToTransform.c_str());
}
LOGI("Media vision ECC level has been converted to "
- "ZInt ECC level (%i -> %i)", ecc, ecclevel);
+ "ZInt ECC level (%i -> %i)", ecc, ecclevel);
return ecclevel;
}
}
LOGI("ZInt error code has been converted to the media vision error code "
- "(%i -> (0x%08x))", barcodeError, mvError);
+ "(%i -> (0x%08x))", barcodeError, mvError);
return mvError;
}
}
LOGI("Media vision image format has been converted to "
- "internal image format (%i -> %i)", format, imageFormat);
+ "internal image format (%i -> %i)", format, imageFormat);
return imageFormat;
}
if (MV_BARCODE_QR == type &&
MV_BARCODE_QR_MODE_ALPHANUMERIC == qr_enc_mode) {
error = alphanumToUpper(messageStr);
- if (BARCODE_ERROR_NONE != error) {
+ if (BARCODE_ERROR_NONE != error)
return convertBarcodeError(error);
- }
}
unsigned char *imageBuffer = NULL;
if (qr_enc_mode == MV_BARCODE_QR_MODE_NUMERIC &&
messageStr.find_first_not_of("0123456789") != std::string::npos) {
LOGE("Barcode message can't be used according to support "
- "numeric (0..9) mode: %s", messageStr.c_str());
+ "numeric (0..9) mode: %s", messageStr.c_str());
return MEDIA_VISION_ERROR_INVALID_DATA;
}
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_BARCODE_GENERATE_LIC_H__
-#define __TIZEN_MEDIAVISION_BARCODE_GENERATE_LIC_H__
+#ifndef __MEDIA_VISION_BARCODE_GENERATE_LIC_H__
+#define __MEDIA_VISION_BARCODE_GENERATE_LIC_H__
#include "mv_barcode_generate.h"
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_BARCODE_GENERATE_LIC_H__ */
+#endif /* __MEDIA_VISION_BARCODE_GENERATE_LIC_H__ */
file(GLOB MV_COMMON_INCLUDE_LIST "${PROJECT_SOURCE_DIR}/include/*.h")
file(GLOB MV_COMMON_SRC_LIST "${PROJECT_SOURCE_DIR}/src/*.cpp")
-find_package(OpenCV REQUIRED core highgui imgproc)
+find_package(OpenCV REQUIRED core imgproc)
if(NOT OpenCV_FOUND)
message(SEND_ERROR "Failed to find OpenCV")
* limitations under the License.
*/
-#ifndef __ENGINECONFIG_H__
-#define __ENGINECONFIG_H__
+#ifndef __MEDIA_VISION_ENGINE_CONFIG_H__
+#define __MEDIA_VISION_ENGINE_CONFIG_H__
#include <string>
#include <map>
*/
int getIntegerAttribute(const std::string& key, int *value) const;
-/**
+ /**
* @brief Gets boolean attribute value by attribute name.
*
* @since_tizen @if MOBILE 2.4 @else 3.0 @endif
} /* Common */
} /* MediaVision */
-#endif /* __ENGINECONFIG_H__ */
+#endif /* __MEDIA_VISION_ENGINE_CONFIG_H__ */
* limitations under the License.
*/
-#ifndef __MEDIASOURCE_H__
-#define __MEDIASOURCE_H__
+#ifndef __MEDIA_VISION_MEDIA_SOURCE_H__
+#define __MEDIA_VISION_MEDIA_SOURCE_H__
// Need for a colorspace
#include <mv_common.h>
* @see MediaSource::MediaSource()
* @see MediaSource::clear()
*/
- bool fill(const unsigned char *buffer, unsigned int bufferSize, unsigned int
- width, unsigned int height, mv_colorspace_e colorspace);
+ bool fill(const unsigned char *buffer, unsigned int bufferSize,
+ unsigned int width, unsigned int height, mv_colorspace_e colorspace);
/**
* @brief Gets data buffer of the MediaSource.
*
* @since_tizen @if MOBILE 2.4 @else 3.0 @endif
- * @return Pointer to the data buffer.
+ * @return Pointer to the data buffer.
*/
unsigned char *getBuffer(void) const;
-/**
+ /**
* @brief Gets buffer size of the MediaSource.
*
* @since_tizen @if MOBILE 2.4 @else 3.0 @endif
} /* Common */
} /* MediaVision */
-#endif /* __MEDIASOURCE_H__ */
+#endif /* __MEDIA_VISION_MEDIA_SOURCE_H__ */
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_COMMON_C_H__
-#define __TIZEN_MEDIAVISION_COMMON_C_H__
+#ifndef __MEDIA_VISION_COMMON_C_H__
+#define __MEDIA_VISION_COMMON_C_H__
#include "mv_common.h"
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_COMMON_C_H__ */
+#endif /* __MEDIA_VISION_COMMON_C_H__ */
LOGE("Default Engine config file location is %s", DefConfigFilePath.c_str());
- // Force load default attributes from configuration file
+ /* Force load default attributes from configuration file */
cacheDictionaries(false);
- // Insert default attribute values into creating engine configuration
+ /* Insert default attribute values into creating engine configuration */
m_dblDict.insert(getDefaultDblDict().begin(), getDefaultDblDict().end());
m_intDict.insert(getDefaultIntDict().begin(), getDefaultIntDict().end());
m_boolDict.insert(getDefaultBoolDict().begin(), getDefaultBoolDict().end());
if (!json_object_has_member(jobj, "attributes")) {
LOGW("Can't parse tests configuration file. "
- "No 'attributes' section.");
+ "No 'attributes' section.");
g_object_unref(parser);
return MEDIA_VISION_ERROR_NO_DATA;
}
if (JSON_NODE_ARRAY != json_node_get_node_type(attr_node)) {
LOGW("Can't parse tests configuration file. "
- "'attributes' section isn't array.");
+ "'attributes' section isn't array.");
g_object_unref(parser);
return MEDIA_VISION_ERROR_NO_DATA;
}
JsonObject *attr_obj = json_node_get_object(attr_node);
if (!json_object_has_member(attr_obj, "name") ||
- !json_object_has_member(attr_obj, "type") ||
- !json_object_has_member(attr_obj, "value")) {
+ !json_object_has_member(attr_obj, "type") ||
+ !json_object_has_member(attr_obj, "value")) {
+
LOGW("Attribute %u wasn't parsed from json file.", attrInd);
continue;
}
if (NULL == nameStr || NULL == typeStr) {
LOGW("Attribute %i wasn't parsed from json file. name and/or "
- "type of the attribute are parsed as NULL.", attrInd);
+ "type of the attribute are parsed as NULL.", attrInd);
continue;
} else if (0 == strcmp("double", typeStr)) {
DefDblDict[std::string(nameStr)] =
(char*)json_object_get_string_member(attr_obj, "value");
} else {
LOGW("Attribute %i:%s wasn't parsed from json file. "
- "Type isn't supported.", attrInd, nameStr);
+ "Type isn't supported.", attrInd, nameStr);
continue;
}
}
return MEDIA_VISION_ERROR_NONE;
}
-} /* namespace Common */
-} /* namespace MediaVision */
+} /* Common */
+} /* MediaVision */
#include <mv_private.h>
#include <cstring>
+#include <new>
namespace MediaVision {
namespace Common {
+
MediaSource::MediaSource() :
m_pBuffer(NULL),
m_bufferSize(0),
delete[] m_pBuffer;
}
LOGD("Set defaults for media source %p : buffer = NULL; "
- "bufferSize = 0; width = 0; height = 0; "
- "colorspace = MEDIA_VISION_COLORSPACE_INVALID", this);
+ "bufferSize = 0; width = 0; height = 0; "
+ "colorspace = MEDIA_VISION_COLORSPACE_INVALID", this);
m_pBuffer = NULL;
m_bufferSize = 0;
m_width = 0;
}
bool MediaSource::fill(const unsigned char *buffer, unsigned int bufferSize,
- unsigned int width, unsigned int height, mv_colorspace_e colorspace)
+ unsigned int width, unsigned int height, mv_colorspace_e colorspace)
{
- if (bufferSize == 0 || buffer == NULL) {
+ if (bufferSize == 0 || buffer == NULL)
return false;
- }
LOGD("Call clear() first for media source %p", this);
clear();
- try {
- LOGD("Allocate memory for buffer in media source %p", this);
- m_pBuffer = new unsigned char[bufferSize];
- } catch(...) {
+ LOGD("Allocate memory for buffer in media source %p", this);
+ m_pBuffer = new (std::nothrow)unsigned char[bufferSize];
+ if (m_pBuffer == NULL) {
LOGE("Memory allocating for buffer in media source %p failed!", this);
- m_pBuffer = NULL;
return false;
}
LOGD("Copy data from external buffer (%p) to the internal buffer (%p) of "
- "media source %p", buffer, m_pBuffer, this);
+ "media source %p", buffer, m_pBuffer, this);
std::memcpy(m_pBuffer, buffer, bufferSize);
LOGD("Assign new size of the internal buffer of media source %p. "
- "New size is %ui.", this, bufferSize);
+ "New size is %ui.", this, bufferSize);
m_bufferSize = bufferSize;
LOGD("Assign new size (%ui x %ui) of the internal buffer image for "
- "the media source %p", width, height, this);
+ "the media source %p", width, height, this);
m_width = width;
m_height = height;
LOGD("Assign new colorspace (%i) of the internal buffer image for "
- "the media source %p", colorspace, this);
+ "the media source %p", colorspace, this);
m_colorspace = colorspace;
return true;
#include <mv_private.h>
+#include <new>
#include <string.h>
#include <stdlib.h>
#include <media_packet.h>
int mv_create_source_c(
- mv_source_h *source_ptr)
+ mv_source_h *source_ptr)
{
- if (source_ptr == NULL) {
+ if (source_ptr == NULL)
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- }
LOGD("Creating media vision source");
- (*source_ptr) = ((mv_source_h)new MediaVision::Common::MediaSource());
+ (*source_ptr) = (static_cast<mv_source_h>
+ (new (std::nothrow)MediaVision::Common::MediaSource()));
if (*source_ptr == NULL) {
LOGE("Failed to create media vision source");
}
int mv_destroy_source_c(
- mv_source_h source)
+ mv_source_h source)
{
if (!source) {
LOGE("Media source can't be destroyed because handle is NULL");
}
LOGD("Destroying media vision source [%p]", source);
- delete ((MediaVision::Common::MediaSource*)source);
+ delete (static_cast<MediaVision::Common::MediaSource*>(source));
LOGD("Media vision source has been destroyed");
return MEDIA_VISION_ERROR_NONE;
}
int mv_source_fill_by_media_packet_c(
- mv_source_h source,
- media_packet_h media_packet)
+ mv_source_h source,
+ media_packet_h media_packet)
{
if (!source || !media_packet) {
LOGE("Media source can't be filled by media_packet handle because "
break;
default:
LOGE("Format of the media packet buffer is not supported by media "
- "vision source (media_format_h mimetype=%i)", mimetype);
+ "vision source (media_format_h mimetype=%i)", mimetype);
return MEDIA_VISION_ERROR_NOT_SUPPORTED_FORMAT;
}
ret = media_packet_get_buffer_data_ptr(media_packet, (void**)&data_buffer);
if (ret != MEDIA_PACKET_ERROR_NONE) {
LOGE("media_packet_get_buffer_data_ptr() failed, mv_source_h fill skipped");
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
ret = media_packet_get_buffer_size(media_packet, &buffer_size);
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- if (!((MediaVision::Common::MediaSource*)source)->fill(data_buffer, buffer_size,
- (unsigned int)image_width, (unsigned int)image_height, image_colorspace)) {
+ if (!(static_cast<MediaVision::Common::MediaSource*>(source))->fill(data_buffer,
+ buffer_size, static_cast<unsigned int>(image_width),
+ static_cast<unsigned int>(image_height), image_colorspace)) {
LOGE("mv_source_h filling from media_packet_h failed");
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
}
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- if (!((MediaVision::Common::MediaSource*)source)->fill(data_buffer,
- buffer_size, image_width, image_height, image_colorspace)) {
+ if (!(static_cast<MediaVision::Common::MediaSource*>(source))->fill(data_buffer,
+ buffer_size, image_width, image_height, image_colorspace)) {
LOGE("mv_source_h filling from buffer failed");
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
}
}
int mv_source_clear_c(
- mv_source_h source)
+ mv_source_h source)
{
if (!source) {
LOGE("Media source can't be cleared because source handle is NULL");
}
LOGD("Clear media vision source [%p]", source);
- ((MediaVision::Common::MediaSource*)source)->clear();
+ (static_cast<MediaVision::Common::MediaSource*>(source))->clear();
LOGD("Media vision source [%p] has been cleared", source);
return MEDIA_VISION_ERROR_NONE;
}
int mv_source_get_buffer_c(
- mv_source_h source,
- unsigned char **buffer,
- unsigned int *size)
+ mv_source_h source,
+ unsigned char **buffer,
+ unsigned int *size)
{
if (!source) {
LOGE("Impossible to get buffer for NULL mv_source_h handle");
}
LOGD("Get media vision source [%p] buffer and buffer size to be returned", source);
- *buffer = ((MediaVision::Common::MediaSource*)source)->getBuffer();
- *size = ((MediaVision::Common::MediaSource*)source)->getBufferSize();
+ *buffer = (static_cast<MediaVision::Common::MediaSource*>(source))->getBuffer();
+ *size = (static_cast<MediaVision::Common::MediaSource*>(source))->getBufferSize();
LOGD("Media vision source [%p] buffer (%p) and buffer size (%ui) has been returned", source, buffer, *size);
return MEDIA_VISION_ERROR_NONE;
}
int mv_source_get_height_c(
- mv_source_h source,
- unsigned int *height)
+ mv_source_h source,
+ unsigned int *height)
{
if (!source) {
LOGE("Impossible to get height for NULL mv_source_h handle");
}
LOGD("Get media vision source [%p] height to be returned", source);
- *height = ((MediaVision::Common::MediaSource*)source)->getHeight();
+ *height = (static_cast<MediaVision::Common::MediaSource*>(source))->getHeight();
LOGD("Media vision source [%p] height (%ui) has been returned", source, *height);
return MEDIA_VISION_ERROR_NONE;
}
int mv_source_get_width_c(
- mv_source_h source,
- unsigned int *width)
+ mv_source_h source,
+ unsigned int *width)
{
if (!source) {
LOGE("Impossible to get width for NULL mv_source_h handle");
}
LOGD("Get media vision source [%p] width to be returned", source);
- *width = ((MediaVision::Common::MediaSource*)source)->getWidth();
+ *width = (static_cast<MediaVision::Common::MediaSource*>(source))->getWidth();
LOGD("Media vision source [%p] width (%ui) has been returned", source, *width);
return MEDIA_VISION_ERROR_NONE;
}
int mv_source_get_colorspace_c(
- mv_source_h source,
- mv_colorspace_e *colorspace)
+ mv_source_h source,
+ mv_colorspace_e *colorspace)
{
if (!source) {
LOGE("Impossible to get colorspace for NULL mv_source_h handle");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- LOGD("Get media vision source [%p] colorspace to be returned", source);
- *colorspace = ((MediaVision::Common::MediaSource*)source)->getColorspace();
- LOGD("Media vision source [%p] colorspace (%i) has been returned", source, *colorspace);
+ LOGD("Get media vision source [%p] colorspace to be returned", source);
+ *colorspace = (static_cast<MediaVision::Common::MediaSource*>(source))->getColorspace();
+ LOGD("Media vision source [%p] colorspace (%i) has been returned", source, *colorspace);
- return MEDIA_VISION_ERROR_NONE;
+ return MEDIA_VISION_ERROR_NONE;
}
int mv_create_engine_config_c(
- mv_engine_config_h *engine_cfg)
+ mv_engine_config_h *engine_cfg)
{
if (engine_cfg == NULL) {
LOGE("Impossible to create mv_engine_config_h handle");
}
LOGD("Creating media vision engine config");
- (*engine_cfg) = ((mv_engine_config_h)new MediaVision::Common::EngineConfig());
- LOGD("Media vision engine config [%p] has been created", *engine_cfg);
-
+ (*engine_cfg) = static_cast<mv_engine_config_h>
+ (new (std::nothrow) MediaVision::Common::EngineConfig());
if (*engine_cfg == NULL) {
LOGE("Failed to create mv_engine_config_h handle");
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
}
+ LOGD("Media vision engine config [%p] has been created", *engine_cfg);
return MEDIA_VISION_ERROR_NONE;
}
}
LOGD("Destroying media vision engine config [%p]", engine_cfg);
- delete ((MediaVision::Common::EngineConfig*)engine_cfg);
+ delete (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg));
LOGD("Media vision engine config has been destroyed");
return MEDIA_VISION_ERROR_NONE;
if (!engine_cfg || name == NULL) {
LOGE("Impossible to set attribute. One of the required parameters is "
"NULL. engine_cfg = %p; name = %p;",
- engine_cfg, name);
+ engine_cfg, name);
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->setAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->setAttribute(
std::string(name), value);
if (ret != MEDIA_VISION_ERROR_NONE) {
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->setAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->setAttribute(
std::string(name), value);
if (ret != MEDIA_VISION_ERROR_NONE) {
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->setAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->setAttribute(
std::string(name), value);
if (ret != MEDIA_VISION_ERROR_NONE) {
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->setAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->setAttribute(
std::string(name), std::string(value));
if (ret != MEDIA_VISION_ERROR_NONE) {
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->getDoubleAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->getDoubleAttribute(
std::string(name), value);
if (ret != MEDIA_VISION_ERROR_NONE) {
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->getIntegerAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->getIntegerAttribute(
std::string(name), value);
if (ret != MEDIA_VISION_ERROR_NONE) {
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->getBooleanAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->getBooleanAttribute(
std::string(name), value);
if (ret != MEDIA_VISION_ERROR_NONE) {
}
std::string attributeValue;
- int ret = ((MediaVision::Common::EngineConfig*)engine_cfg)->getStringAttribute(
+ int ret = (static_cast<MediaVision::Common::EngineConfig*>(engine_cfg))->getStringAttribute(
std::string(name), &attributeValue);
if (ret != MEDIA_VISION_ERROR_NONE) {
LOGD("Convert string to char*");
int stringSize = attributeValue.size();
- (*value) = (char *)malloc(sizeof(char) * (stringSize + 1));
+ (*value) = (char*)malloc(sizeof(char) * (stringSize + 1));
+ if ((*value) == NULL) {
+ LOGE("Failed to convert string to char*");
+ return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
+ }
if (attributeValue.copy(*value, stringSize) != attributeValue.size()) {
LOGE("Conversion from string to char* failed");
}
int mv_engine_config_foreach_supported_attribute_c(
- mv_supported_attribute_cb callback,
- void *user_data)
+ mv_supported_attribute_cb callback,
+ void *user_data)
{
if (NULL == callback) {
LOGE("Impossible to traverse supported by Media Vision engine "
* limitations under the License.
*/
-#ifndef __FACEDETECTOR_H__
-#define __FACEDETECTOR_H__
+#ifndef __MEDIA_VISION_FACE_DETECTOR_H__
+#define __MEDIA_VISION_FACE_DETECTOR_H__
#include <opencv/cv.h>
#include <vector>
} /* Face */
} /* MediaVision */
-#endif /* __FACEDETECTOR_H__ */
+#endif /* __MEDIA_VISION_FACE_DETECTOR_H__ */
* limitations under the License.
*/
-#ifndef __FACEEXPRESSIONRECOGNIZER_H__
-#define __FACEEXPRESSIONRECOGNIZER_H__
+#ifndef __MEDIA_VISION_FACE_EXPRESSION_RECOGNIZER_H__
+#define __MEDIA_VISION_FACE_EXPRESSION_RECOGNIZER_H__
#include "mv_common_c.h"
#include "mv_face_open.h"
#include <string>
namespace cv {
- class Mat;
+ class Mat;
}
/**
* @since_tizen 3.0
*/
struct FaceRecognizerConfig {
- FaceRecognizerConfig();
- std::string mHaarcascadeFilepath;
+ FaceRecognizerConfig();
+ std::string mHaarcascadeFilepath;
};
/**
} /* Face */
} /* MediaVision */
-#endif /* __FACEEXPRESSIONRECOGNIZER_H__ */
+#endif /* __MEDIA_VISION_FACE_EXPRESSION_RECOGNIZER_H__ */
* limitations under the License.
*/
-#ifndef __FACEEYECONDITION_H__
-#define __FACEEYECONDITION_H__
+#ifndef __MEDIA_VISION_FACE_EYE_CONDITION_H__
+#define __MEDIA_VISION_FACE_EYE_CONDITION_H__
#include <mv_common_c.h>
#include <mv_face.h>
} /* Face */
} /* MediaVision */
-#endif /* __FACEEYECONDITION_H__ */
+#endif /* __MEDIA_VISION_FACE_EYE_CONDITION_H__ */
* limitations under the License.
*/
-#ifndef __FACERECOGNITIONMODEL_H__
-#define __FACERECOGNITIONMODEL_H__
+#ifndef __MEDIA_VISION_FACE_RECOGNITION_MODEL_H__
+#define __MEDIA_VISION_FACE_RECOGNITION_MODEL_H__
#include "FaceUtil.h"
*/
class FaceRecognitionModel {
public:
-/**
+ /**
* @brief Creates a FaceRecognitionModel class instance.
*
* @since_tizen 3.0
} /* Face */
} /* MediaVision */
-#endif /* __FACERECOGNITIONMODEL_H__ */
+#endif /* __MEDIA_VISION_FACE_RECOGNITION_MODEL_H__ */
* limitations under the License.
*/
-#ifndef __FACETRACKINGMODEL_H__
-#define __FACETRACKINGMODEL_H__
+#ifndef __MEDIA_VISION_FACE_TRACKING_MODEL_H__
+#define __MEDIA_VISION_FACE_TRACKING_MODEL_H__
#include "TrackerMedianFlow.h"
} /* Face */
} /* MediaVision */
-#endif /* __FACETRACKINGMODEL_H__ */
+#endif /* __MEDIA_VISION_FACE_TRACKING_MODEL_H__ */
* limitations under the License.
*/
-#ifndef __FACEUTIL_H__
-#define __FACEUTIL_H__
+#ifndef __MEDIA_VISION_FACE_UTIL_H__
+#define __MEDIA_VISION_FACE_UTIL_H__
#include <opencv/cv.h>
} /* Face */
} /* MediaVision */
-#endif /* __FACEUTIL_H__ */
+#endif /* __MEDIA_VISION_FACE_UTIL_H__ */
//
//M*/
-#ifndef __TRACKERMEDIANFLOW_H__
-#define __TRACKERMEDIANFLOW_H__
+#ifndef __MEDIA_VISION_TRACKER_MEDIAN_FLOW_H__
+#define __MEDIA_VISION_TRACKER_MEDIAN_FLOW_H__
#include "opencv2/core/core.hpp"
-namespace cv
-{
+namespace cv {
class TrackerMedianFlowModel;
void write(FileStorage& fs) const;
private:
- bool isInit;
+ bool m_isInit;
bool medianFlowImpl(Mat oldImage, Mat newImage, Rect_<float>& oldBox);
inline float l2distance(Point2f p1, Point2f p2);
- Params params; /**< Parameters used during tracking, see
+ Params m_params; /**< Parameters used during tracking, see
@ref TrackerMedianFlow::Params */
- TermCriteria termcrit; /**< Terminating criteria for OpenCV
+ TermCriteria m_termcrit; /**< Terminating criteria for OpenCV
Lucas–Kanade optical flow algorithm used
during tracking */
} /* namespace cv */
-#endif /* __TRACKERMEDIANFLOW_H__ */
+#endif /* __MEDIA_VISION_TRACKER_MEDIAN_FLOW_H__ */
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_FACE_OPEN_H__
-#define __TIZEN_MEDIAVISION_FACE_OPEN_H__
+#ifndef __MEDIA_VISION_FACE_OPEN_H__
+#define __MEDIA_VISION_FACE_OPEN_H__
#include "mv_face.h"
* isn't supported
* @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
*
- * @pre Create a source handle by calling @ref mv_create_source_open()
+ * @pre Create a source handle by calling @ref mv_create_source()
*
* @see mv_face_eye_condition_recognized_cb
*/
* isn't supported
* @retval #MEDIA_VISION_ERROR_NOT_SUPPORTED Not supported
*
- * @pre Create a source handle by calling @ref mv_create_source_open()
+ * @pre Create a source handle by calling @ref mv_create_source()
* @pre Create a face engine configuration handle by calling @ref mv_create_engine_config()
*
* @see mv_face_facial_expression_recognized_cb
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_FACE_OPEN_H__ */
+#endif /* __MEDIA_VISION_FACE_OPEN_H__ */
namespace MediaVision {
namespace Face {
+
FaceDetector::FaceDetector() :
m_faceCascade(),
m_haarcascadeFilepath(),
m_faceCascadeIsLoaded(false)
{
- ; /* NULL */
+ ; /* NULL */
}
FaceDetector::~FaceDetector()
const cv::Size& minSize,
std::vector<cv::Rect>& faceLocations)
{
- if (!m_faceCascadeIsLoaded) {
+ if (!m_faceCascadeIsLoaded)
return false;
- }
faceLocations.clear();
bool roiIsUsed = false;
if (roi.x >= 0 && roi.y >= 0 && roi.width > 0 && roi.height > 0 &&
- (roi.x + roi.width) <= image.cols &&
- (roi.y + roi.height) <= image.rows) {
+ (roi.x + roi.width) <= image.cols &&
+ (roi.y + roi.height) <= image.rows) {
+
intrestingRegion = intrestingRegion(roi);
roiIsUsed = true;
}
if (minSize.width > 0 && minSize.height > 0 &&
- minSize.width <= image.cols && minSize.height <= image.rows) {
+ minSize.width <= image.cols && minSize.height <= image.rows) {
+
m_faceCascade.detectMultiScale(
intrestingRegion,
faceLocations,
3,
0,
minSize);
+
} else {
+
m_faceCascade.detectMultiScale(intrestingRegion, faceLocations);
}
bool FaceDetector::loadHaarcascade(const std::string& haarcascadeFilepath)
{
if (!m_faceCascadeIsLoaded ||
- m_haarcascadeFilepath != haarcascadeFilepath) {
- if (!(m_faceCascadeIsLoaded = m_faceCascade.load(haarcascadeFilepath))) {
+ m_haarcascadeFilepath != haarcascadeFilepath) {
+
+ if (!(m_faceCascadeIsLoaded = m_faceCascade.load(haarcascadeFilepath)))
return false;
- }
+
m_haarcascadeFilepath = haarcascadeFilepath;
}
namespace MediaVision {
namespace Face {
-static const int MinDetectionWidth = 30;
-static const int MinDetectionHeight = 30;
+
+static const int MIN_DETECTION_WIDTH = 30;
+static const int MIN_DETECTION_HEIGHT = 30;
FaceRecognizerConfig::FaceRecognizerConfig() :
- mHaarcascadeFilepath(
+ mHaarcascadeFilepath(
"/usr/share/OpenCV/haarcascades/haarcascade_smile.xml")
{
; /* NULL */
}
int FaceExpressionRecognizer::recognizeFaceExpression(
- const cv::Mat& grayImage,
- const mv_rectangle_s& faceLocation,
- mv_face_facial_expression_e *faceExpression,
- const FaceRecognizerConfig& config)
+ const cv::Mat& grayImage,
+ const mv_rectangle_s& faceLocation,
+ mv_face_facial_expression_e *faceExpression,
+ const FaceRecognizerConfig& config)
{
- if (NULL == faceExpression) {
+ if (NULL == faceExpression)
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- }
const int smileRectHeight = cvRound((float)faceLocation.height / 2);
faceLocation.width,
smileRectHeight);
- if (roi.width < MinDetectionWidth ||
- roi.height < MinDetectionHeight) {
+ if (roi.width < MIN_DETECTION_WIDTH ||
+ roi.height < MIN_DETECTION_HEIGHT) {
(*faceExpression) = MV_FACE_UNKNOWN;
return MEDIA_VISION_ERROR_NONE;
}
- if (0 > roi.x ||
- 0 > roi.y ||
- roi.x + roi.width > grayImage.cols ||
- roi.y + roi.height > grayImage.rows) {
+ if (0 > roi.x || 0 > roi.y ||
+ roi.x + roi.width > grayImage.cols ||
+ roi.y + roi.height > grayImage.rows)
return MEDIA_VISION_ERROR_INVALID_OPERATION;
- }
const cv::Mat mouthImg(grayImage, roi);
cv::CascadeClassifier smileClassifier;
smileClassifier.load(config.mHaarcascadeFilepath);
smileClassifier.detectMultiScale(
- mouthImg,
- areas,
- 1.1,
- 80,
- cv::CASCADE_FIND_BIGGEST_OBJECT |
- cv::CASCADE_DO_CANNY_PRUNING |
- cv::CASCADE_SCALE_IMAGE,
- cv::Size(MinDetectionWidth, MinDetectionHeight));
+ mouthImg,
+ areas,
+ 1.1,
+ 80,
+ cv::CASCADE_FIND_BIGGEST_OBJECT |
+ cv::CASCADE_DO_CANNY_PRUNING |
+ cv::CASCADE_SCALE_IMAGE,
+ cv::Size(MIN_DETECTION_WIDTH, MIN_DETECTION_HEIGHT));
(*faceExpression) = MV_FACE_UNKNOWN;
const size_t smilesFoundSize = areas.size();
- if (smilesFoundSize == 0) {
+ if (smilesFoundSize == 0)
(*faceExpression) = MV_FACE_NEUTRAL;
- } else if (smilesFoundSize == 1) {
+ else if (smilesFoundSize == 1)
(*faceExpression) = MV_FACE_SMILE;
- }
return MEDIA_VISION_ERROR_NONE;
}
cv::Mat eyeEqualized;
cv::equalizeHist(eye, eyeEqualized);
- const int thresold = 8;
+ const int thresold = 20;
eyeEqualized = eyeEqualized < thresold;
std::vector<std::vector<cv::Point> > contours;
const size_t contoursSize = contours.size();
- if (!contoursSize) {
+ if (!contoursSize)
return MV_FACE_EYES_NOT_FOUND;
- }
const int xCenter = eyeEqualized.cols / 2;
const int yCenter = eyeEqualized.rows / 2;
const double currentArea = cv::contourArea(contours[i]);
if (boundThresold.contains(currentRect.br()) &&
- boundThresold.contains(currentRect.tl()) &&
- currentArea > areaRatio * boundThresold.area() &&
- currentRect.width < widthHeightRatio * currentRect.height) {
+ boundThresold.contains(currentRect.tl()) &&
+ currentArea > areaRatio * boundThresold.area() &&
+ currentRect.width < widthHeightRatio * currentRect.height)
isOpen = MV_FACE_EYES_OPEN;
- } else if (boundThresold.contains(currentRect.br()) &&
- boundThresold.contains(currentRect.tl()) &&
- currentArea > areaSmallRatio * boundThresold.area()) {
+ else if (boundThresold.contains(currentRect.br()) &&
+ boundThresold.contains(currentRect.tl()) &&
+ currentArea > areaSmallRatio * boundThresold.area())
++rectanglesInsideCount;
- }
+
}
- if (rectanglesInsideCount > 8u) {
+ if (rectanglesInsideCount > 8u)
isOpen = MV_FACE_EYES_CLOSED;
- }
return isOpen;
}
const int isOpenRight = isEyeOpen(rightEye);
- if (isOpenRight == MV_FACE_EYES_OPEN) {
+ if (isOpenRight == MV_FACE_EYES_OPEN)
*eyeCondition = MV_FACE_EYES_OPEN;
- } else if (isOpenRight == MV_FACE_EYES_CLOSED) {
+ else if (isOpenRight == MV_FACE_EYES_CLOSED)
*eyeCondition = MV_FACE_EYES_CLOSED;
- } else {
+ else
*eyeCondition = MV_FACE_EYES_NOT_FOUND;
- }
return MEDIA_VISION_ERROR_NONE;
}
srcAlg->save(tempPath);
dstAlg->load(tempPath);
- if (0 != remove(tempPath)) {
+ if (0 != remove(tempPath))
LOGW("Error removing serialized FaceRecognizer in %s", tempPath);
- }
/* todo: consider to uncomment this lines if OpenCV will support deep
- / copy of AlgorithmInfo objects: */
+ copy of AlgorithmInfo objects: */
/*std::vector<std::string> paramNames;
srcAlg->getParams(paramNames);
std::set<int>& outLabels)
{
if (!recognizer.empty()) {
+
cv::Mat labels = recognizer->getMat("labels");
- for (int i = 0; i < labels.rows; ++i) {
+
+ for (int i = 0; i < labels.rows; ++i)
outLabels.insert(labels.at<int>(i, 0));
- }
}
}
bool FaceRecognitionModelConfig::operator!=(
const FaceRecognitionModelConfig& other) const
{
- return mModelType != other.mModelType ||
+ return mModelType != other.mModelType ||
mNumComponents != other.mNumComponents ||
mThreshold != other.mThreshold ||
mRadius != other.mRadius ||
m_recognizer(CreateRecognitionAlgorithm(origin.m_learnAlgorithmConfig)),
m_learnedLabels(origin.m_learnedLabels)
{
- if (!m_recognizer.empty()) {
+ if (!m_recognizer.empty())
CopyOpenCVAlgorithmParameters(origin.m_recognizer, m_recognizer);
- }
}
FaceRecognitionModel& FaceRecognitionModel::operator=(
m_recognizer = CreateRecognitionAlgorithm(m_learnAlgorithmConfig);
m_learnedLabels = copy.m_learnedLabels;
- if (!m_recognizer.empty()) {
+ if (!m_recognizer.empty())
CopyOpenCVAlgorithmParameters(copy.m_recognizer, m_recognizer);
- }
}
return *this;
} else {
tempConfig = FaceRecognitionModelConfig();
LOGE("Failed to load face recognition model from file. File is in "
- "unsupported format");
+ "unsupported format");
storage.release();
{
if (1 > m_faceSamples.erase(faceLabel)) {
LOGD("Failed to remove face image examples for label %i. "
- "No such examples", faceLabel);
+ "No such examples", faceLabel);
return MEDIA_VISION_ERROR_KEY_NOT_AVAILABLE;
}
bool isIncremental = false;
bool isUnisize = false;
- if (MEDIA_VISION_FACE_MODEL_TYPE_LBPH == config.mModelType) {
+ if (MEDIA_VISION_FACE_MODEL_TYPE_LBPH == config.mModelType)
isIncremental = true;
- }
if (MEDIA_VISION_FACE_MODEL_TYPE_EIGENFACES == config.mModelType ||
- MEDIA_VISION_FACE_MODEL_TYPE_FISHERFACES == config.mModelType) {
+ MEDIA_VISION_FACE_MODEL_TYPE_FISHERFACES == config.mModelType)
isUnisize = true;
- }
std::vector<cv::Mat> samples;
std::vector<int> labels;
std::set<int> learnedLabels;
- if (isIncremental) {
+ if (isIncremental)
learnedLabels.insert(m_learnedLabels.begin(), m_learnedLabels.end());
- }
- std::map<int, std::vector<cv::Mat> >::const_iterator it =
- m_faceSamples.begin();
+ std::map<int, std::vector<cv::Mat> >::const_iterator it = m_faceSamples.begin();
+
for (; it != m_faceSamples.end(); ++it) {
const size_t faceClassSamplesSize = it->second.size();
labels.insert(labels.end(), faceClassSamplesSize, it->first);
for (size_t sampleInd = 0; sampleInd < faceClassSamplesSize; ++sampleInd) {
cv::Mat resizedSample;
cv::resize(it->second[sampleInd],
- resizedSample,
- cv::Size(config.mImgWidth, config.mImgHeight),
- 0.0, 0.0, cv::INTER_CUBIC);
+ resizedSample,
+ cv::Size(config.mImgWidth, config.mImgHeight),
+ 0.0, 0.0, cv::INTER_CUBIC);
samples.push_back(resizedSample);
}
}
if (0 != samplesSize && samplesSize == labelsSize) {
LOGD("Start to learn the model for %u samples and %u labels",
- samplesSize, labelsSize);
+ samplesSize, labelsSize);
- if (m_learnAlgorithmConfig != config || m_recognizer.empty()) {
+ if (m_learnAlgorithmConfig != config || m_recognizer.empty())
m_recognizer = CreateRecognitionAlgorithm(config);
- }
if (m_recognizer.empty()) {
LOGE("Can't create recognition algorithm for recognition model. "
- "Configuration is not supported by any of known algorithms.");
+ "Configuration is not supported by any of known algorithms.");
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
m_canTrack(origin.m_canTrack),
m_tracker(new cv::TrackerMedianFlow())
{
- if (!origin.m_tracker.empty()) {
+ if (!origin.m_tracker.empty())
origin.m_tracker->copyTo(*(m_tracker.obj));
- }
}
FaceTrackingModel& FaceTrackingModel::operator=(const FaceTrackingModel& copy)
if (this != ©) {
m_canTrack = copy.m_canTrack;
m_tracker = cv::Ptr<cv::TrackerMedianFlow>(new cv::TrackerMedianFlow());
- if (!copy.m_tracker.empty()) {
+ if (!copy.m_tracker.empty())
copy.m_tracker->copyTo(*(m_tracker.obj));
- }
}
return *this;
{
if (m_tracker.empty()) {
LOGE("Failed to prepare tracking model. No tracking algorithm "
- "is available.");
- return MEDIA_VISION_ERROR_INVALID_OPERATION;
+ "is available.");
+ return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
cv::Rect_<float> lastBoundingBox;
{
if (m_tracker.empty()) {
LOGE("Failed to prepare tracking model. No tracking algorithm "
- "is available.");
+ "is available.");
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
#include "mv_private.h"
#include <opencv2/imgproc/types_c.h>
-#include <opencv2/highgui/highgui.hpp>
namespace MediaVision {
namespace Face {
}
TrackerMedianFlow::TrackerMedianFlow(Params paramsIn) :
- termcrit(TermCriteria::COUNT | TermCriteria::EPS, 20, 0.3),
+ m_termcrit(TermCriteria::COUNT | TermCriteria::EPS, 20, 0.3),
m_confidence(0.0)
{
- params = paramsIn;
- isInit = false;
+ m_params = paramsIn;
+ m_isInit = false;
}
bool TrackerMedianFlow::copyTo(TrackerMedianFlow& copy) const
{
- copy.isInit = isInit;
- copy.params = params;
- copy.termcrit = termcrit;
+ copy.m_isInit = m_isInit;
+ copy.m_params = m_params;
+ copy.m_termcrit = m_termcrit;
copy.m_boundingBox = m_boundingBox;
copy.m_confidence = m_confidence;
m_image.copyTo(copy.m_image);
bool TrackerMedianFlow::init(const Mat& image, const Rect_<float>& boundingBox)
{
- if (image.empty()) {
+ if (image.empty())
return false;
- }
image.copyTo(m_image);
buildOpticalFlowPyramid(
- m_image, m_pyramid, params.mWindowSize, params.mPyrMaxLevel);
+ m_image, m_pyramid, m_params.mWindowSize, m_params.mPyrMaxLevel);
m_boundingBox = boundingBox;
- isInit = true;
- return isInit;
+ m_isInit = true;
+ return m_isInit;
}
bool TrackerMedianFlow::update(const Mat& image, Rect_<float>& boundingBox)
{
- if (!isInit || image.empty())
+ if (!m_isInit || image.empty())
return false;
/* Handles such behaviour when preparation frame has the size
Mat oldImage = m_image;
Rect_<float> oldBox = m_boundingBox;
- if(!medianFlowImpl(oldImage, image, oldBox)) {
+ if(!medianFlowImpl(oldImage, image, oldBox))
return false;
- }
boundingBox = oldBox;
image.copyTo(m_image);
bool TrackerMedianFlow::isInited() const
{
- return isInit;
+ return m_isInit;
}
float TrackerMedianFlow::getLastConfidence() const
}
bool TrackerMedianFlow::medianFlowImpl(
- Mat oldImage_gray, Mat newImage_gray, Rect_<float>& oldBox)
+ Mat oldGrayImage, Mat newGrayImage, Rect_<float>& oldBox)
{
std::vector<Point2f> pointsToTrackOld, pointsToTrackNew;
- const float gridXStep = oldBox.width / params.mPointsInGrid;
- const float gridYStep = oldBox.height / params.mPointsInGrid;
- for (int i = 0; i < params.mPointsInGrid; i++) {
- for (int j = 0; j < params.mPointsInGrid; j++) {
+ const float gridXStep = oldBox.width / m_params.mPointsInGrid;
+ const float gridYStep = oldBox.height / m_params.mPointsInGrid;
+ for (int i = 0; i < m_params.mPointsInGrid; i++)
+ for (int j = 0; j < m_params.mPointsInGrid; j++)
pointsToTrackOld.push_back(
Point2f(oldBox.x + .5f*gridXStep + 1.f*gridXStep*j,
oldBox.y + .5f*gridYStep + 1.f*gridYStep*i));
- }
- }
std::vector<uchar> status(pointsToTrackOld.size());
std::vector<float> errors(pointsToTrackOld.size());
std::vector<Mat> tempPyramid;
buildOpticalFlowPyramid(
- newImage_gray,
+ newGrayImage,
tempPyramid,
- params.mWindowSize,
- params.mPyrMaxLevel);
+ m_params.mWindowSize,
+ m_params.mPyrMaxLevel);
calcOpticalFlowPyrLK(m_pyramid,
tempPyramid,
pointsToTrackNew,
status,
errors,
- params.mWindowSize,
- params.mPyrMaxLevel,
- termcrit);
+ m_params.mWindowSize,
+ m_params.mPyrMaxLevel,
+ m_termcrit);
std::vector<Point2f> di;
- for (size_t idx = 0u; idx < pointsToTrackOld.size(); idx++) {
- if (status[idx] == 1) {
+ for (size_t idx = 0u; idx < pointsToTrackOld.size(); idx++)
+ if (status[idx] == 1)
di.push_back(pointsToTrackNew[idx] - pointsToTrackOld[idx]);
- }
- }
std::vector<bool> filter_status;
check_FB(tempPyramid,
pointsToTrackNew,
filter_status);
- check_NCC(oldImage_gray,
- newImage_gray,
+ check_NCC(oldGrayImage,
+ newGrayImage,
pointsToTrackOld,
pointsToTrackNew,
filter_status);
}
}
- if (pointsToTrackOld.size() == 0 || di.size() == 0) {
+ if (pointsToTrackOld.size() == 0 || di.size() == 0)
return false;
- }
Point2f mDisplacement;
Rect_<float> boxCandidate =
oldRect.y + oldRect.height/2.0);
int n = (int)oldPoints.size();
- std::vector<float>buf(std::max(n*(n-1) / 2, 3), 0.f);
+ std::vector<float> buf(std::max(n*(n-1) / 2, 3), 0.f);
if(oldPoints.size() == 1) {
newRect.x = oldRect.x+newPoints[0].x-oldPoints[0].x;
float xshift = 0.f;
float yshift = 0.f;
- for(int i = 0; i < n; i++) {
+ for(int i = 0; i < n; i++)
buf[i] = newPoints[i].x - oldPoints[i].x;
- }
xshift = getMedian(buf, n);
newCenter.x += xshift;
- for(int idx = 0; idx < n; idx++) {
+ for(int idx = 0; idx < n; idx++)
buf[idx] = newPoints[idx].y - oldPoints[idx].y;
- }
yshift = getMedian(buf, n);
newCenter.y += yshift;
template<typename T>
T TrackerMedianFlow::getMedian(std::vector<T>& values, int size)
{
- if (size == -1) {
+ if (size == -1)
size = (int)values.size();
- }
std::vector<T> copy(values.begin(), values.begin() + size);
std::sort(copy.begin(), copy.end());
const std::vector<Point2f>& newPoints,
std::vector<bool>& status)
{
- if(status.size() == 0) {
+ if(status.size() == 0)
status = std::vector<bool>(oldPoints.size(), true);
- }
std::vector<uchar> LKstatus(oldPoints.size());
std::vector<float> errors(oldPoints.size());
pointsToTrackReprojection,
LKstatus,
errors,
- params.mWindowSize,
- params.mPyrMaxLevel,
- termcrit);
+ m_params.mWindowSize,
+ m_params.mPyrMaxLevel,
+ m_termcrit);
- for (size_t idx = 0u; idx < oldPoints.size(); idx++) {
- FBerror[idx] =
- l2distance(oldPoints[idx], pointsToTrackReprojection[idx]);
- }
+ for (size_t idx = 0u; idx < oldPoints.size(); idx++)
+ FBerror[idx] = l2distance(oldPoints[idx], pointsToTrackReprojection[idx]);
float FBerrorMedian = getMedian(FBerror) + FloatEps;
- for (size_t idx = 0u; idx < oldPoints.size(); idx++) {
+ for (size_t idx = 0u; idx < oldPoints.size(); idx++)
status[idx] = (FBerror[idx] < FBerrorMedian);
- }
}
void TrackerMedianFlow::check_NCC(
}
float median = getMedian(NCC) - FloatEps;
- for(size_t idx = 0u; idx < oldPoints.size(); idx++) {
+ for(size_t idx = 0u; idx < oldPoints.size(); idx++)
status[idx] = status[idx] && (NCC[idx] > median);
- }
}
void TrackerMedianFlow::read(cv::FileStorage& fs)
{
- params.read(fs.root());
+ m_params.read(fs.root());
float bbX = 0.f;
float bbY = 0.f;
float bbW = 0.f;
void TrackerMedianFlow::write(cv::FileStorage& fs) const
{
- params.write(fs);
+ m_params.write(fs);
fs << "lastLocationX" << m_boundingBox.x;
fs << "lastLocationY" << m_boundingBox.y;
fs << "lastLocationW" << m_boundingBox.width;
using namespace ::MediaVision::Face;
-static const RecognitionParams defaultRecognitionParams = RecognitionParams();
+static const RecognitionParams DEFAULT_RECOGNITION_PARAMS = RecognitionParams();
static void extractRecognitionParams(
mv_engine_config_h engine_cfg,
"MV_FACE_RECOGNITION_MODEL_TYPE",
&algType);
- if (0 < algType && 4 > algType) {
+ if (0 < algType && 4 > algType)
recognitionParams.mRecognitionAlgType =
- (FaceRecognitionModelType)algType;
- } else {
- recognitionParams.mRecognitionAlgType =
- defaultRecognitionParams.mRecognitionAlgType;
- }
+ (FaceRecognitionModelType)algType;
+ else
+ recognitionParams.mRecognitionAlgType =
+ DEFAULT_RECOGNITION_PARAMS.mRecognitionAlgType;
- if (NULL == engine_cfg) {
- mv_destroy_engine_config(working_cfg);
- }
+ if (NULL == engine_cfg)
+ mv_destroy_engine_config(working_cfg);
}
inline void convertRectCV2MV(const cv::Rect& src, mv_rectangle_s& dst)
engine_cfg,
MV_FACE_DETECTION_ROI_X,
&roi.x);
- if (error != MEDIA_VISION_ERROR_NONE) {
+ if (error != MEDIA_VISION_ERROR_NONE)
LOGE("Error occurred during face detection roi (x) receiving."
" (%i)", error);
- }
error = mv_engine_config_get_int_attribute_c(
engine_cfg,
MV_FACE_DETECTION_ROI_Y,
&roi.y);
- if (error != MEDIA_VISION_ERROR_NONE) {
+ if (error != MEDIA_VISION_ERROR_NONE)
LOGE("Error occurred during face detection roi (y) receiving."
" (%i)", error);
-}
error = mv_engine_config_get_int_attribute_c(
engine_cfg,
MV_FACE_DETECTION_ROI_WIDTH,
&roi.width);
- if (error != MEDIA_VISION_ERROR_NONE) {
+ if (error != MEDIA_VISION_ERROR_NONE)
LOGE("Error occurred during face detection roi (width) receiving."
" (%i)", error);
- }
error = mv_engine_config_get_int_attribute_c(
engine_cfg,
MV_FACE_DETECTION_ROI_HEIGHT,
&roi.height);
- if (error != MEDIA_VISION_ERROR_NONE) {
+ if (error != MEDIA_VISION_ERROR_NONE)
LOGE("Error occurred during face detection roi (height) receiving."
" (%i)", error);
- }
cv::Size minSize(-1, -1);
error = mv_engine_config_get_int_attribute_c(
engine_cfg,
MV_FACE_DETECTION_MIN_SIZE_WIDTH,
&minSize.width);
- if (error != MEDIA_VISION_ERROR_NONE) {
+ if (error != MEDIA_VISION_ERROR_NONE)
LOGE("Error occurred during face detection minimum width receiving."
" (%i)", error);
- }
error = mv_engine_config_get_int_attribute_c(
engine_cfg,
MV_FACE_DETECTION_MIN_SIZE_HEIGHT,
&minSize.height);
- if (error != MEDIA_VISION_ERROR_NONE) {
+ if (error != MEDIA_VISION_ERROR_NONE)
LOGE("Error occurred during face detection minimum height receiving."
" (%i)", error);
- }
std::vector<cv::Rect> faceLocations;
if (!faceDetector.detectFaces(image, roi, minSize, faceLocations)) {
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
- static const int StartMaxResultsNumber = 50;
- static std::vector<mv_rectangle_s> results(StartMaxResultsNumber);
+ static const int START_MAX_RESULTS_NUMBER = 50;
+ static std::vector<mv_rectangle_s> results(START_MAX_RESULTS_NUMBER);
const int numberOfResults = faceLocations.size();
- if (numberOfResults > StartMaxResultsNumber) {
+ if (numberOfResults > START_MAX_RESULTS_NUMBER)
results.resize(numberOfResults);
- }
- for (int rectNum = 0; rectNum < numberOfResults; ++rectNum) {
+ for (int rectNum = 0; rectNum < numberOfResults; ++rectNum)
convertRectCV2MV(faceLocations[rectNum], results[rectNum]);
- }
LOGI("Call the detect callback for %i detected faces", numberOfResults);
detected_cb(source, engine_cfg, results.data(), numberOfResults, user_data);
if (!recognized_cb) {
LOGE("Recognition failed. Can't output recognition results without "
- "callback function");
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ "callback function");
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!recognition_model) {
- LOGE("Can't recognize for the NULL Media Vision Face recognition model");
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ LOGE("Can't recognize for the NULL Media Vision Face recognition model");
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
FaceRecognitionModel *pRecModel = static_cast<FaceRecognitionModel*>(recognition_model);
if (!results.mIsRecognized) {
recognized_cb(
- source,
- recognition_model,
- engine_cfg,
- NULL,
- NULL,
- 0.0,
- user_data);
+ source,
+ recognition_model,
+ engine_cfg,
+ NULL,
+ NULL,
+ 0.0,
+ user_data);
} else {
mv_rectangle_s location;
location.point.x = results.mFaceLocation.x;
if (!pTrackModel) {
LOGE("Face tracking failed. "
- "Incorrect Media Vision Face tracking model handle is used");
+ "Incorrect Media Vision Face tracking model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (MEDIA_VISION_ERROR_NONE != ret) {
LOGE("Tracking can't be performed. "
- "Check that tracking model is prepared when tracking starts");
+ "Check that tracking model is prepared when tracking starts");
return ret;
}
mv_face_facial_expression_e expression;
error = FaceExpressionRecognizer::recognizeFaceExpression(
- image, face_location, &expression);
+ image, face_location, &expression);
if (error != MEDIA_VISION_ERROR_NONE) {
LOGE("eye contition recognition failed");
{
if (!src || !dst) {
LOGE("Can't clone recognition model. Both source and destination"
- "recognition model handles has to be not NULL");
+ "recognition model handles has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
{
if (!recognition_model) {
LOGE("Can't load recognition model from the file. "
- "Handle has to be not NULL");
+ "Handle has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (NULL == file_name) {
LOGE("Can't load recognition model from the file. "
- "File name has to be specified");
+ "File name has to be specified");
return MEDIA_VISION_ERROR_INVALID_PATH;
}
if (!pRecModel) {
LOGE("Loading of the face recognition model from file failed. "
- "Incorrect Media Vision Face recognition model handle is used");
+ "Incorrect Media Vision Face recognition model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
{
if (!source) {
LOGE("Can't add face image example for recognition model. "
- "Media Vision source handle has to be not NULL");
+ "Media Vision source handle has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!recognition_model) {
LOGE("Can't add face image example for recognition model. "
- "Model handle has to be not NULL");
+ "Model handle has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!pRecModel) {
LOGE("Add face image example to the model failed. "
- "Incorrect Media Vision Face recognition model handle is used");
+ "Incorrect Media Vision Face recognition model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
}
LOGD("The face image example labeled %i has been added "
- "to the Media Vision recognition model", face_label);
+ "to the Media Vision recognition model", face_label);
return ret;
}
if (!pRecModel) {
LOGE("Loading of the face recognition model from file failed. "
- "Incorrect Media Vision Face recognition model handle is used");
+ "Incorrect Media Vision Face recognition model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!pRecModel) {
LOGE("Learning of the face recognition model failed. "
- "Incorrect Media Vision Face recognition model handle is used");
+ "Incorrect Media Vision Face recognition model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (NULL == labels || NULL == number_of_labels) {
LOGE("Can't get list of labels. labels and number_of_labels out "
- "parameters both has to be not NULL.");
+ "parameters both has to be not NULL.");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!pRecModel) {
LOGE("Learning of the face recognition model failed. "
- "Incorrect Media Vision Face recognition model handle is used");
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ "Incorrect Media Vision Face recognition model handle is used");
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
const std::set<int>& learnedLabels = pRecModel->getFaceLabels();
if (!source) {
LOGE("Can't prepare tracking model. "
- "Media Vision source handle has to be not NULL");
+ "Media Vision source handle has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!pTrackModel) {
LOGE("Preparation of the face tracking model failed. "
- "Incorrect Media Vision Face tracking model handle is used");
+ "Incorrect Media Vision Face tracking model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
{
if (!src || !dst) {
LOGE("Can't clone tracking model. Both source and destination"
- "tracking model handles has to be not NULL");
+ "tracking model handles has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
{
if (!tracking_model) {
LOGE("Can't save tracking model to the file. "
- "Handle has to be not NULL");
+ "Handle has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (NULL == file_name) {
LOGE("Can't save tracking model to the file. "
- "File name has to be specified");
+ "File name has to be specified");
return MEDIA_VISION_ERROR_INVALID_PATH;
}
if (!pTrackModel) {
LOGE("Saving of the face tracking model to file failed. "
- "Incorrect Media Vision Face tracking model handle is used");
+ "Incorrect Media Vision Face tracking model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
{
if (!tracking_model) {
LOGE("Can't load tracking model from the file. "
- "Handle has to be not NULL");
+ "Handle has to be not NULL");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (NULL == file_name) {
LOGE("Can't load tracking model from the file. "
- "File name has to be specified");
+ "File name has to be specified");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
if (!pTrackModel) {
LOGE("Loading of the face tracking model from file failed. "
- "Incorrect Media Vision Face tracking model handle is used");
+ "Incorrect Media Vision Face tracking model handle is used");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_FACE_LIC_H__
-#define __TIZEN_MEDIAVISION_FACE_LIC_H__
+#ifndef __MEDIA_VISION_FACE_LIC_H__
+#define __MEDIA_VISION_FACE_LIC_H__
#include "mv_face.h"
* @since_tizen 3.0
* @remarks Cloning perform not only handle copy, but also copies all internal
* resources of the model. @a dst must be released using
- * @a mv_face_recognition_model_destroy_open_lic().
+ * @a mv_face_recognition_model_destroy_lic().
* @param [in] src The handle to the recognition model to be copied
* @param [out] dst The handle to the copy of existed recognition model
* specified as @a src
* support reinforcement learning.
* @remarks @a recognition_model is loaded from the application's data directory.
* @a recognition_model must be destroyed using
- * @ref mv_face_recognition_model_destroy_open_lic().
+ * @ref mv_face_recognition_model_destroy_lic().
* @param [in] file_name Name of file to load the model
* @param [out] recognition_model The handle to the recognition model
* to be loaded from the file
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_FACE_LIC_H__ */
+#endif /* __MEDIA_VISION_FACE_LIC_H__ */
int mv_face_tracking_model_clone_lic(
mv_face_tracking_model_h src,
- mv_face_tracking_model_h *dst)
+ mv_face_tracking_model_h *dst)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
project(mv_image_port)
cmake_minimum_required(VERSION 2.6)
-if(MEDIA_VISION_IMAGE_PORT)
+if(MEDIA_VISION_IMAGE_LICENSE_PORT)
add_subdirectory(${PROJECT_SOURCE_DIR}/image_lic) # Licensed port
else()
add_subdirectory(${PROJECT_SOURCE_DIR}/image) # Open port
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG _DEBUG)
+if(NOT SKIP_WARNINGS)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Werror")
+endif()
+
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${LIB_INSTALL_DIR})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${LIB_INSTALL_DIR})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
* limitations under the License.
*/
-#ifndef __IMAGEFEATURES_BASICEXTRACTORFACTORY_H__
-#define __IMAGEFEATURES_BASICEXTRACTORFACTORY_H__
+#ifndef __MEDIA_VISION_BASICEXTRACTORFACTORY_H__
+#define __MEDIA_VISION_BASICEXTRACTORFACTORY_H__
#include "Features/FeatureExtractorFactory.h"
virtual cv::Ptr<FeatureExtractor> buildFeatureExtractor();
private:
- KeypointType m_kpType;
+ KeypointType __kpType;
- DescriptorType m_descType;
+ DescriptorType __descType;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEFEATURES_BASICEXTRACTORFACTORY_H__ */
+#endif /* __MEDIA_VISION_BASICEXTRACTORFACTORY_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEFEATURES_FEATUREEXTRACTOR_H__
-#define __IMAGEFEATURES_FEATUREEXTRACTOR_H__
+#ifndef __MEDIA_VISION_FEATUREEXTRACTOR_H__
+#define __MEDIA_VISION_FEATUREEXTRACTOR_H__
#include "ImageConfig.h"
const std::vector<cv::Point2f>& roi = std::vector<cv::Point2f>());
private:
- static const cv::Size MinSize;
+ static const cv::Size __MIN_SIZE;
private:
- KeypointType m_kpType;
+ KeypointType __kpType;
- cv::Ptr<cv::FeatureDetector> m_detector;
+ cv::Ptr<cv::FeatureDetector> __detector;
- DescriptorType m_descType;
+ DescriptorType __descType;
- cv::Ptr<cv::DescriptorExtractor> m_extractor;
+ cv::Ptr<cv::DescriptorExtractor> __extractor;
- float (*m_computeRecognitionRate)(
+ float (*__computeRecognitionRate)(
const cv::Mat&,
const std::vector<cv::KeyPoint>&);
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEFEATURES_FEATUREEXTRACTOR_H__ */
+#endif /* __MEDIA_VISION_FEATUREEXTRACTOR_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEFEATURES_FEATUREEXTRACTORFACTORY_H__
-#define __IMAGEFEATURES_FEATUREEXTRACTORFACTORY_H__
+#ifndef __MEDIA_VISION_FEATUREEXTRACTORFACTORY_H__
+#define __MEDIA_VISION_FEATUREEXTRACTORFACTORY_H__
#include "Features/FeatureExtractor.h"
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEFEATURES_FEATUREEXTRACTORFACTORY_H__ */
+#endif /* __MEDIA_VISION_FEATUREEXTRACTORFACTORY_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEFEATURES_FEATUREMATCHER_H__
-#define __IMAGEFEATURES_FEATUREMATCHER_H__
+#ifndef __MEDIA_VISION_FEATUREMATCHER_H__
+#define __MEDIA_VISION_FEATUREMATCHER_H__
#include "Features/FeaturePack.h"
class FeatureMatcher {
public:
- enum MatchError{
+ enum MatchError {
InvalidFeaturePackFrom,
InvalidFeaturePackTo,
DisparateTypes,
void setMinimumMatchesNumber(size_t minimumMatchesNumber);
private:
- cv::BFMatcher m_matcher;
+ cv::BFMatcher __matcher;
- float m_affectingPart;
+ float __affectingPart;
- float m_tolerantError;
+ float __tolerantError;
- size_t m_minimumMatchesNumber;
+ size_t __minimumMatchesNumber;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEFEATURES_FEATUREMATCHER_H__ */
+#endif /* __MEDIA_VISION_FEATUREMATCHER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEFEATURES_FEATUREPACK_H__
-#define __IMAGEFEATURES_FEATUREPACK_H__
+#ifndef __MEDIA_VISION_FEATUREPACK_H__
+#define __MEDIA_VISION_FEATUREPACK_H__
#include "ImageConfig.h"
*/
FeaturePack& operator= (const FeaturePack& copy);
- KeypointType m_keypointsType;
+ KeypointType __keypointsType;
- std::vector<cv::KeyPoint> m_objectKeypoints;
+ std::vector<cv::KeyPoint> __objectKeypoints;
- DescriptorType m_descriptorsType;
+ DescriptorType __descriptorsType;
- cv::Mat m_objectDescriptors;
+ cv::Mat __objectDescriptors;
- float m_recognitionRate;
+ float __recognitionRate;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEFEATURES_FEATUREPACK_H__ */
+#endif /* __MEDIA_VISION_FEATUREPACK_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEFEATURES_ORBEXTRACTORFACTORY_H__
-#define __IMAGEFEATURES_ORBEXTRACTORFACTORY_H__
+#ifndef __MEDIA_VISION_ORBEXTRACTORFACTORY_H__
+#define __MEDIA_VISION_ORBEXTRACTORFACTORY_H__
#include "Features/FeatureExtractorFactory.h"
const cv::Mat&,
const std::vector<cv::KeyPoint>&);
- float m_scaleFactor; /**< Recognition scale factor for the ORB detector. */
+ float __scaleFactor; /**< Recognition scale factor for the ORB detector. */
- size_t m_maximumFeaturesNumber; /**< Maximum number of features, which will
- be extracted from object image. */
+ size_t __maximumFeaturesNumber; /**< Maximum number of features, which will
+ be extracted from object image. */
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEFEATURES_ORBEXTRACTORFACTORY_H__ */
+#endif /* __MEDIA_VISION_ORBEXTRACTORFACTORY_H__ */
* limitations under the License.
*/
-#ifndef __IMAGECONFIG_H__
-#define __IMAGECONFIG_H__
+#ifndef __MEDIA_VISION_IMAGECONFIG_H__
+#define __MEDIA_VISION_IMAGECONFIG_H__
#include <string>
/**
* @file ImageConfig.h
- * @brief This file contains Image Module Configuration.
+ * @brief This file contains Image Module configuration.
*/
namespace MediaVision {
};
const std::string DescriptorNames[DT_SIZE] = {
- [DT_ORB] = "ORB",
- [DT_BRIEF] = "BRIEF"
+ [DT_ORB] = "ORB",
+ [DT_BRIEF] = "BRIEF"
};
/**
+ * @class FeaturesExtractingParams
* @brief Contains parameters for features extracting from image objects.
*
* @since_tizen 3.0
DescriptorType mDescriptorType; /**< Descriptor's type. */
- union { /**< Extracting parameters for concretes algorithms */
+ union { /**< Extracting parameters for concretes algorithms. */
struct { /**< Extracting parameters for ORB algorithm. */
double mScaleFactor; /**< Recognition scale factor for the ORB detector. */
int mMaximumFeaturesNumber; /**< Maximum number of features,
};
/**
- * @calss TrackingParams
+ * @class TrackingParams
* @brief Contains parameters for image objects tracking.
*
* @since_tizen 3.0
} /* Image */
} /* MediaVision */
-#endif /* __IMAGECONFIG_H__ */
+#endif /* __MEDIA_VISION_IMAGECONFIG_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEMATHUTIL_H__
-#define __IMAGEMATHUTIL_H__
+#ifndef __MEDIA_VISION_IMAGEMATHUTIL_H__
+#define __MEDIA_VISION_IMAGEMATHUTIL_H__
#include <opencv/cv.h>
namespace MediaVision {
namespace Image {
+
const size_t MinimumNumberOfFeatures = 4u; /* Minimum number of features
when perspective transform
parameters calculation
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEMATHUTIL_H__ */
+#endif /* __MEDIA_VISION_IMAGEMATHUTIL_H__ */
* limitations under the License.
*/
-#ifndef __IMAGEOBJECT_H__
-#define __IMAGEOBJECT_H__
+#ifndef __MEDIA_VISION_IMAGEOBJECT_H__
+#define __MEDIA_VISION_IMAGEOBJECT_H__
#include "ImageConfig.h"
* @since_tizen 3.0
*/
class ImageObject {
+
public:
/**
* @brief @ref ImageObject default constructor.
* @param [in] image The image for which instance of @ref ImageObject
* will be created
* @param [in] params Features extracting parameters
- */
+ */
ImageObject(const cv::Mat& image, const FeaturesExtractingParams& params);
/**
* @param [in] roi Region of interested object on the @a image
*/
void fill(
- const cv::Mat& image,
- const FeaturesExtractingParams& params,
- const std::vector<cv::Point2f>& roi = std::vector<cv::Point2f>());
+ const cv::Mat& image,
+ const FeaturesExtractingParams& params,
+ const std::vector<cv::Point2f>& roi = std::vector<cv::Point2f>());
/**
* @brief Gets a value that determines how well an @ref ImageObject can be recognized.
const std::vector<cv::Point2f>& roi);
private:
- FeaturesExtractingParams m_featureExtractingParams;
+ FeaturesExtractingParams __featureExtractingParams;
- FeaturePack m_features;
+ FeaturePack __features;
- bool m_isEmpty;
+ bool __isEmpty;
- bool m_isLabeled;
+ bool __isLabeled;
- int m_label;
+ int __label;
- std::vector<cv::Point2f> m_boundingContour;
+ std::vector<cv::Point2f> __boundingContour;
friend class ImageRecognizer;
} /* Image */
} /* MediaVision */
-#endif /* __IMAGEOBJECT_H__ */
+#endif /* __MEDIA_VISION_IMAGEOBJECT_H__ */
* limitations under the License.
*/
-#ifndef __IMAGERECOGNIZER_H__
-#define __IMAGERECOGNIZER_H__
+#ifndef __MEDIA_VISION_IMAGERECOGNIZER_H__
+#define __MEDIA_VISION_IMAGERECOGNIZER_H__
#include "ImageMathUtil.h"
#include "ImageConfig.h"
* @brief Recognizes the @a target on the scene.
*
* @since_tizen 3.0
- * @param [in] target @ref ImageObject, which will be recognized
- * @param [in] params Recognition parameters
- * @param [out] contour The result contour of @a target object on the
- * scene
- * @param [out] ignoreFactor Scaling factor of area near the contour
- * of object which will be ignored
+ * @param [in] target @ref ImageObject, which will be recognized
+ * @param [in] params Recognition parameters
+ * @param [out] contour The result contour of @a target object on the
+ * scene
+ * @param [out] ignoreFactor Scaling factor of area near the contour
+ * of object which will be ignored
* @return true if object is found on the scene, otherwise return false
*/
bool recognize(
private:
/* TODO: Replace to cv::Ptr<ImageObject> */
- ImageObject m_scene;
+ ImageObject __scene;
- cv::BFMatcher m_matcher;
+ cv::BFMatcher __matcher;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGERECOGNIZER_H__ */
+#endif /* __MEDIA_VISION_IMAGERECOGNIZER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKING_ASYNCTRACKER_H__
-#define __IMAGETRACKING_ASYNCTRACKER_H__
+#ifndef __MEDIA_VISION_ASYNCTRACKER_H__
+#define __MEDIA_VISION_ASYNCTRACKER_H__
#include "Tracking/ObjectTracker.h"
static void *asyncTrack(void *data);
private:
- cv::Ptr<ObjectTracker> m_baseTracker;
+ cv::Ptr<ObjectTracker> __baseTracker;
- cv::Mat m_frame;
+ cv::Mat __frame;
- std::vector<cv::Point> m_result;
+ std::vector<cv::Point> __result;
- bool m_isRun;
+ bool __isRun;
- bool m_isUpdated;
+ bool __isUpdated;
- bool m_copyingPolicy;
+ bool __copyingPolicy;
- pthread_t m_thread;
+ pthread_t __mvThread;
- mutable pthread_mutex_t m_globalGuard;
+ mutable pthread_mutex_t __globalGuard;
- mutable pthread_spinlock_t m_resultGuard;
+ mutable pthread_spinlock_t __resultGuard;
- mutable pthread_spinlock_t m_isRunGuard;
+ mutable pthread_spinlock_t __isRunGuard;
- mutable pthread_spinlock_t m_isUpdatedGuard;
+ mutable pthread_spinlock_t __isUpdatedGuard;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKING_ASYNCTRACKER_H__ */
+#endif /* __MEDIA_VISION_ASYNCTRACKER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKING_CASCADETRACKER_H__
-#define __IMAGETRACKING_CASCADETRACKER_H__
+#ifndef __MEDIA_VISION_CASCADETRACKER_H__
+#define __MEDIA_VISION_CASCADETRACKER_H__
#include "Tracking/ObjectTracker.h"
mutable std::vector<cv::Point> mResult;
};
- /* don't use m_trackers.find() because
- operator==() and operator<() are independent
- TODO: Fix it with aggregator or something like that */
- std::set<TrackerInfo> m_trackers;
+ /* don't use __trackers.find() because
+ * operator==() and operator<() are independent
+ * TODO: Fix it with aggregator or something like that
+ */
+ std::set<TrackerInfo> __trackers;
- float m_minimumArea;
+ float __minimumArea;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKING_CASCADETRACKER_H__ */
+#endif /* __MEDIA_VISION_CASCADETRACKER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKING_FEATURESUBSTITUTIONTRACKER_H__
-#define __IMAGETRACKING_FEATURESUBSTITUTIONTRACKER_H__
+#ifndef __MEDIA_VISION_FEATURESUBSTITUTIONTRACKER_H__
+#define __MEDIA_VISION_FEATURESUBSTITUTIONTRACKER_H__
#include "Tracking/ObjectTracker.h"
std::vector<cv::Point2f> computeExpectedArea();
private:
- bool m_isInit;
+ bool __isInit;
- cv::Ptr<ImageObject> m_target;
+ cv::Ptr<ImageObject> __target;
- std::vector<cv::Point> m_location;
+ std::vector<cv::Point> __location;
- FeaturesExtractingParams m_featureExtractingParams;
+ FeaturesExtractingParams __featureExtractingParams;
- RecognitionParams m_recogParams;
+ RecognitionParams __recogParams;
- float m_expectedOffset;
+ float __expectedOffset;
- float m_sceneScalingFactor;
+ float __sceneScalingFactor;
- float m_objectScalingFactor;
+ float __objectScalingFactor;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKING_FEATURESUBSTITUTIONTRACKER_H__ */
+#endif /* __MEDIA_VISION_FEATURESUBSTITUTIONTRACKER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGECONTOURSTABILIZATOR_H__
-#define __IMAGECONTOURSTABILIZATOR_H__
+#ifndef __MEDIA_VISION_IMAGECONTOURSTABILIZATOR_H__
+#define __MEDIA_VISION_IMAGECONTOURSTABILIZATOR_H__
#include "ImageConfig.h"
enum StabilizationError {
Successfully, /**< Contour is stabilized. */
TooShortMovingHistory, /**< Too short moving history, it's normal
- behavior, you can continue to call
- stabilization in order to accumulate it. */
+ behavior, you can continue to call
+ stabilization in order to accumulate it. */
InvalidSettings, /**< Invalid settings. */
UnsupportedContourType /**< Unsupported contour type. */
};
std::vector<cv::Point2f> computeStabilizedQuadrangleContour(void);
private:
- float m_tolerantShift;
+ float __tolerantShift;
- float m_tolerantShiftExtra;
+ float __tolerantShiftExtra;
- std::vector<float> m_speeds;
+ std::vector<float> __speeds;
- std::vector<size_t> m_currentCornersSpeed;
+ std::vector<size_t> __currentCornersSpeed;
- std::deque<std::vector<cv::Point2f> > m_movingHistory;
+ std::deque<std::vector<cv::Point2f> > __movingHistory;
- std::vector<cv::Point2f> m_lastStabilizedContour;
+ std::vector<cv::Point2f> __lastStabilizedContour;
- size_t m_historyAmount;
+ size_t __historyAmount;
- size_t m_currentHistoryAmount;
+ size_t __currentHistoryAmount;
- int m_tempContourIndex;
+ int __tempContourIndex;
- std::vector<float> m_priorities;
+ std::vector<float> __priorities;
- bool m_isPrepared;
+ bool __isPrepared;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGECONTOURSTABILIZATOR_H__ */
+#endif /* __MEDIA_VISION_IMAGECONTOURSTABILIZATOR_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKINGMODEL_H__
-#define __IMAGETRACKINGMODEL_H__
+#ifndef __MEDIA_VISION_IMAGETRACKINGMODEL_H__
+#define __MEDIA_VISION_IMAGETRACKINGMODEL_H__
#include "Recognition/ImageObject.h"
ImageTrackingModel& obj);
private:
- ImageObject m_target;
+ ImageObject __target;
- cv::Ptr<ObjectTracker> m_tracker;
+ cv::Ptr<ObjectTracker> __tracker;
- ImageContourStabilizator m_stabilizator;
+ ImageContourStabilizator __stabilizator;
- std::vector<cv::Point> m_location;
+ std::vector<cv::Point> __location;
- StabilizationParams m_stabilizationParams;
+ StabilizationParams __stabilizationParams;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKINGMODEL_H__ */
+#endif /* __MEDIA_VISION_IMAGETRACKINGMODEL_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKING_MFTRACKER_H__
-#define __IMAGETRACKING_MFTRACKER_H__
+#ifndef __MEDIA_VISION_MFTRACKER_H__
+#define __MEDIA_VISION_MFTRACKER_H__
#include "Tracking/ObjectTracker.h"
/**
* @brief TrackerMedianFlow algorithm parameters constructor
*/
- Params();
+ Params();
- int mPointsInGrid; /**< Square root of number of used keypoints.
- Increase it to trade accurateness for speed.
- Default value is sensible and recommended */
+ int mPointsInGrid; /**< Square root of number of used keypoints.
+ Increase it to trade accurateness for speed.
+ Default value is sensible and recommended */
- cv::Size mWindowSize; /**< Size of the search window at each pyramid level
- for Lucas-Kanade optical flow search used for
- tracking */
+ cv::Size mWindowSize; /**< Size of the search window at each pyramid level
+ for Lucas-Kanade optical flow search used for
+ tracking */
- int mPyrMaxLevel; /**< Number of pyramid levels for Lucas-Kanade optical
- flow search used for tracking */
+ int mPyrMaxLevel; /**< Number of pyramid levels for Lucas-Kanade optical
+ flow search used for tracking */
/* TODO: add lifetime*/
/*time_t mLifetime;*/ /**< Time of tracking without reinforcement. */
- };
+ };
/**
* @brief @ref MFTracker constructor based on tracking algorithm parameters.
std::vector<bool>& status);
private:
- bool m_isInit; /**< Flag is used to determine the model
+ bool __isInit; /**< Flag is used to determine the model
initialization */
- Params m_params; /**< Parameters used during tracking, see
+ Params __params; /**< Parameters used during tracking, see
@ref TrackerMedianFlow::Params */
- cv::TermCriteria m_termcrit; /**< Terminating criteria for OpenCV
+ cv::TermCriteria __termcrit; /**< Terminating criteria for OpenCV
Lucas–Kanade optical flow algorithm used
during tracking */
- std::vector<cv::Point2f> m_startLocation; /**< Tracking object start
+ std::vector<cv::Point2f> __startLocation; /**< Tracking object start
location with relative values
to the bounding box */
- cv::Rect_<float> m_boundingBox; /**< Tracking object bounding box */
+ cv::Rect_<float> __boundingBox; /**< Tracking object bounding box */
- float m_confidence; /**< Confidence that object was tracked
+ float __confidence; /**< Confidence that object was tracked
correctly at the last tracking iteration */
- cv::Mat m_image; /**< Last image for which tracking was
+ cv::Mat __image; /**< Last image for which tracking was
performed */
- std::vector<cv::Mat> m_pyramid; /**< The pyramid had been calculated for
+ std::vector<cv::Mat> __pyramid; /**< The pyramid had been calculated for
the previous frame(or when
initialize the model) */
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKING_MFTRACKER_H__ */
+#endif /* __MEDIA_VISION_MFTRACKER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKING_OBJECTTRACKER_H__
-#define __IMAGETRACKING_OBJECTTRACKER_H__
+#ifndef __MEDIA_VISION_OBJECTTRACKER_H__
+#define __MEDIA_VISION_OBJECTTRACKER_H__
#include <opencv2/core/core.hpp>
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKING_OBJECTTRACKER_H__ */
+#endif /* __MEDIA_VISION_OBJECTTRACKER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGETRACKING_RECOGNITIONBASEDTRACKER_H__
-#define __IMAGETRACKING_RECOGNITIONBASEDTRACKER_H__
+#ifndef __MEDIA_VISION_RECOGNITIONBASEDTRACKER_H__
+#define __MEDIA_VISION_RECOGNITIONBASEDTRACKER_H__
#include "Tracking/ObjectTracker.h"
virtual cv::Ptr<ObjectTracker> clone() const;
private:
- ImageObject m_target;
+ ImageObject __target;
- FeaturesExtractingParams m_sceneFeatureExtractingParams;
+ FeaturesExtractingParams __sceneFeatureExtractingParams;
- RecognitionParams m_recogParams;
+ RecognitionParams __recogParams;
};
} /* Image */
} /* MediaVision */
-#endif /* __IMAGETRACKING_RECOGNITIONBASEDTRACKER_H__ */
+#endif /* __MEDIA_VISION_RECOGNITIONBASEDTRACKER_H__ */
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_IMAGE_OPEN_H__
-#define __TIZEN_MEDIAVISION_IMAGE_OPEN_H__
+#ifndef __MEDIA_VISION_IMAGE_OPEN_H__
+#define __MEDIA_VISION_IMAGE_OPEN_H__
#include "mv_image.h"
* @see mv_image_object_destroy_open()
*/
int mv_image_object_save_open(
- const char *file_name, mv_image_object_h image_object);
+ const char *file_name,
+ mv_image_object_h image_object);
/**
* @brief Loads an image object from the file.
* @see mv_image_object_destroy_open()
*/
int mv_image_object_load_open(
- const char *file_name, mv_image_object_h *image_object);
+ const char *file_name,
+ mv_image_object_h *image_object);
/**********************************/
/* Image tracking model behaviour */
* @see mv_image_tracking_model_destroy_open()
*/
int mv_image_tracking_model_save_open(
- const char *file_name, mv_image_tracking_model_h image_tracking_model);
+ const char *file_name,
+ mv_image_tracking_model_h image_tracking_model);
/**
* @brief Loads an image tracking model from the file.
* @see mv_image_tracking_model_destroy_open()
*/
int mv_image_tracking_model_load_open(
- const char *file_name, mv_image_tracking_model_h *image_tracking_model);
+ const char *file_name,
+ mv_image_tracking_model_h *image_tracking_model);
#ifdef __cplusplus
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_IMAGE_OPEN_H__ */
+#endif /* __MEDIA_VISION_IMAGE_OPEN_H__ */
namespace MediaVision {
namespace Image {
+
BasicExtractorFactory::BasicExtractorFactory(
KeypointType keypointsType,
DescriptorType descType) :
- m_kpType(keypointsType),
- m_descType(descType)
+ __kpType(keypointsType),
+ __descType(descType)
{
}
cv::Ptr<FeatureExtractor> BasicExtractorFactory::buildFeatureExtractor()
{
- cv::Ptr<FeatureExtractor> featureExtractor(new FeatureExtractor());
+ cv::Ptr<FeatureExtractor> featureExtractor(new (std::nothrow)FeatureExtractor());
+ if (featureExtractor == NULL)
+ return NULL;
cv::Ptr<cv::FeatureDetector> detector =
- cv::FeatureDetector::create(KeypointNames[m_kpType]);
+ cv::FeatureDetector::create(KeypointNames[__kpType]);
cv::Ptr<cv::DescriptorExtractor> extractor =
- cv::DescriptorExtractor::create(DescriptorNames[m_descType]);
+ cv::DescriptorExtractor::create(DescriptorNames[__descType]);
- featureExtractor->setFeatureDetector(detector, m_kpType);
- featureExtractor->setDescriptorExtractor(extractor, m_descType);
+ featureExtractor->setFeatureDetector(detector, __kpType);
+ featureExtractor->setDescriptorExtractor(extractor, __descType);
return featureExtractor;
}
namespace MediaVision {
namespace Image {
-const cv::Size FeatureExtractor::MinSize = cv::Size(5, 5);
+
+const cv::Size FeatureExtractor::__MIN_SIZE = cv::Size(5, 5);
FeatureExtractor::FeatureExtractor() :
- m_kpType(KT_INVALID),
- m_detector(),
- m_descType(DT_INVALID),
- m_extractor(),
- m_computeRecognitionRate(NULL)
+ __kpType(KT_INVALID),
+ __detector(),
+ __descType(DT_INVALID),
+ __extractor(),
+ __computeRecognitionRate(NULL)
{
}
const cv::Ptr<cv::FeatureDetector> detector,
KeypointType keypointType)
{
- m_detector = detector;
- m_kpType = keypointType;
+ __detector = detector;
+ __kpType = keypointType;
}
void FeatureExtractor::setDescriptorExtractor(
cv::Ptr<cv::DescriptorExtractor> extractor,
DescriptorType descriptorType)
{
- m_extractor = extractor;
- m_descType = descriptorType;
+ __extractor = extractor;
+ __descType = descriptorType;
}
void FeatureExtractor::setRecognitionRateMetric(
const cv::Mat&,
const std::vector<cv::KeyPoint>&))
{
- m_computeRecognitionRate = computeRecognitionRate;
+ __computeRecognitionRate = computeRecognitionRate;
}
bool FeatureExtractor::extract(
FeaturePack& result,
const std::vector<cv::Point2f>& roi)
{
- if (m_detector.empty() || m_extractor.empty())
+ if (__detector.empty() || __extractor.empty())
return false;
cv::Rect boundingBox;
catRect(boundingBox, image.size());
}
- if (boundingBox.width < MinSize.width || boundingBox.height < MinSize.height)
+ if (boundingBox.width < __MIN_SIZE.width || boundingBox.height < __MIN_SIZE.height)
return false;
- result.m_objectKeypoints.clear();
+ result.__objectKeypoints.clear();
std::vector<cv::KeyPoint> keypoints;
- m_detector->detect(
+ __detector->detect(
image(boundingBox),
keypoints);
- result.m_objectKeypoints = keypoints;
+ result.__objectKeypoints = keypoints;
+
if (!roi.empty()) {
const size_t numberOfKeypoints = keypoints.size();
- result.m_objectKeypoints.resize(numberOfKeypoints);
+ result.__objectKeypoints.resize(numberOfKeypoints);
for (size_t i = 0; i < numberOfKeypoints; ++i) {
- result.m_objectKeypoints[i].pt.x += boundingBox.x;
- result.m_objectKeypoints[i].pt.y += boundingBox.y;
+ result.__objectKeypoints[i].pt.x += boundingBox.x;
+ result.__objectKeypoints[i].pt.y += boundingBox.y;
}
}
if (!roi.empty()) {
/* TODO: Ecode roi to reduce the boundary effect. Provide new parameter
- / for this action cause roi is a bounding contour for the object. */
+ for this action cause roi is a bounding contour for the object. */
- for (size_t i = 0; i < result.m_objectKeypoints.size(); ++i) {
- if (!checkAccessory(result.m_objectKeypoints[i].pt, roi)) {
- result.m_objectKeypoints.erase(result.m_objectKeypoints.begin() + i);
+ for (size_t i = 0; i < result.__objectKeypoints.size(); ++i) {
+ if (!checkAccessory(result.__objectKeypoints[i].pt, roi)) {
+ result.__objectKeypoints.erase(result.__objectKeypoints.begin() + i);
--i;
}
}
}
- m_extractor->compute(
+ __extractor->compute(
image,
- result.m_objectKeypoints,
- result.m_objectDescriptors);
+ result.__objectKeypoints,
+ result.__objectDescriptors);
- if (NULL != m_computeRecognitionRate) {
- result.m_recognitionRate = m_computeRecognitionRate(
+ if (NULL != __computeRecognitionRate) {
+ result.__recognitionRate = __computeRecognitionRate(
image(boundingBox),
keypoints);
} else {
/* Default recognition rate metric */
- if (result.m_objectKeypoints.size() < MinimumNumberOfFeatures)
- result.m_recognitionRate = 0.f;
+ if (result.__objectKeypoints.size() < MinimumNumberOfFeatures)
+ result.__recognitionRate = 0.f;
else
- result.m_recognitionRate = 0.5f;
+ result.__recognitionRate = 0.5f;
}
- result.m_keypointsType = m_kpType;
- result.m_descriptorsType = m_descType;
+ result.__keypointsType = __kpType;
+ result.__descriptorsType = __descType;
return true;
}
FeatureExtractorFactory::~FeatureExtractorFactory()
{
- ; /* NULL */
+ ; /* NULL */
}
} /* Image */
namespace Image {
namespace {
+
float computeLinearSupportElement(
const std::vector<cv::DMatch>& examples,
int requiredNumber,
while (true) {
if (leftLimit >= rightLimit) {
- if (leftLimit < (requiredNumber - (int)allowableError))
- leftLimit = requiredNumber + (int)allowableError;
+ if (leftLimit < (requiredNumber - static_cast<int>(allowableError)))
+ leftLimit = requiredNumber + static_cast<int>(allowableError);
break;
}
/* Iteration similar quicksort */
while (true) {
- /* Search the leftmost element which have bigger confidence than support element */
+ /* Search the leftmost element which have
+ * bigger confidence than support element */
while (examples[leftLimit].distance <= supportElement &&
- leftLimit < startRightLimit) {
+ leftLimit < startRightLimit)
++leftLimit;
- }
- /* Search the rightmost element which have smaller confidence than support element */
+ /* Search the rightmost element which have smaller
+ * confidence than support element */
while (examples[rightLimit].distance >= supportElement &&
- rightLimit >= startLeftLimit) {
+ rightLimit >= startLeftLimit)
--rightLimit;
- }
if (leftLimit >= rightLimit)
break;
/* Swap */
- std::swap(examples[leftLimit], examples[rightLimit]);
+ std::swap(examples[leftLimit], examples[rightLimit]);
}
-
- if (abs(filterAmount - leftLimit) <= (int)allowableError)
+ if (abs(filterAmount - leftLimit) <= static_cast<int>(allowableError))
break;
-
- if ((int)filterAmount > leftLimit) {
+ if (static_cast<int>(filterAmount) > leftLimit) {
requiredNumber -= leftLimit - startLeftLimit;
rightLimit = startRightLimit;
const FeaturePack& to,
cv::Mat& homophraphyMatrix) const
{
- if (MinimumNumberOfFeatures > from.m_objectKeypoints.size())
+ if (MinimumNumberOfFeatures > from.__objectKeypoints.size())
return InvalidFeaturePackFrom;
- if (MinimumNumberOfFeatures > to.m_objectKeypoints.size())
+ if (MinimumNumberOfFeatures > to.__objectKeypoints.size())
return InvalidFeaturePackTo;
- if (from.m_descriptorsType != to.m_descriptorsType)
+ if (from.__descriptorsType != to.__descriptorsType)
return DisparateTypes;
std::vector<cv::DMatch> matches;
- m_matcher.match(from.m_objectDescriptors, to.m_objectDescriptors, matches);
+ __matcher.match(from.__objectDescriptors, to.__objectDescriptors, matches);
size_t matchesNumber = matches.size();
if (MinimumNumberOfFeatures > matchesNumber)
return MatchesNotFound;
- size_t requiredMatchesNumber = m_affectingPart * matchesNumber;
- size_t allowableMatchesNumberError = m_tolerantError * requiredMatchesNumber;
+ size_t requiredMatchesNumber = __affectingPart * matchesNumber;
+ size_t allowableMatchesNumberError = __tolerantError * requiredMatchesNumber;
if (matchesNumber - allowableMatchesNumberError > MinimumNumberOfFeatures &&
- requiredMatchesNumber + allowableMatchesNumberError < matchesNumber) {
+ requiredMatchesNumber + allowableMatchesNumberError < matchesNumber) {
if (requiredMatchesNumber - allowableMatchesNumberError <
- m_minimumMatchesNumber) {
+ __minimumMatchesNumber) {
if (requiredMatchesNumber + allowableMatchesNumberError >
- m_minimumMatchesNumber) {
+ __minimumMatchesNumber) {
requiredMatchesNumber = (requiredMatchesNumber +
- m_minimumMatchesNumber + allowableMatchesNumberError) / 2;
+ __minimumMatchesNumber + allowableMatchesNumberError) / 2;
allowableMatchesNumberError = requiredMatchesNumber -
- m_minimumMatchesNumber + allowableMatchesNumberError;
+ __minimumMatchesNumber + allowableMatchesNumberError;
} else {
const size_t minimalAllowableMatchesNumberError = 2u;
requiredMatchesNumber = minimalAllowableMatchesNumberError +
- m_minimumMatchesNumber;
+ __minimumMatchesNumber;
allowableMatchesNumberError = minimalAllowableMatchesNumberError;
}
for (size_t matchIdx = 0; matchIdx < matchesNumber; ++matchIdx) {
objectPoints[matchIdx] =
- from.m_objectKeypoints[matches[matchIdx].queryIdx].pt;
+ from.__objectKeypoints[matches[matchIdx].queryIdx].pt;
scenePoints[matchIdx] =
- to.m_objectKeypoints[matches[matchIdx].trainIdx].pt;
+ to.__objectKeypoints[matches[matchIdx].trainIdx].pt;
}
homophraphyMatrix = cv::findHomography(objectPoints, scenePoints, CV_RANSAC);
float FeatureMatcher::getAffectingPart() const
{
- return m_affectingPart;
+ return __affectingPart;
}
void FeatureMatcher::setAffectingPart(float affectingPart)
{
- m_affectingPart = std::max(0.f, std::min(1.f, affectingPart));
+ __affectingPart = std::max(0.f, std::min(1.f, affectingPart));
}
float FeatureMatcher::getTolerantError() const
{
- return m_tolerantError;
+ return __tolerantError;
}
void FeatureMatcher::setTolerantError(float tolerantError)
{
- m_tolerantError = std::max(0.f, std::min(1.f, tolerantError));
+ __tolerantError = std::max(0.f, std::min(1.f, tolerantError));
}
size_t FeatureMatcher::getMinimumMatchesNumber() const
{
- return m_minimumMatchesNumber;
+ return __minimumMatchesNumber;
}
void FeatureMatcher::setMinimumMatchesNumber(size_t minimumMatchesNumber)
{
- m_minimumMatchesNumber = minimumMatchesNumber;
+ __minimumMatchesNumber = minimumMatchesNumber;
}
} /* Image */
namespace Image {
FeaturePack::FeaturePack() :
- m_keypointsType(KT_INVALID),
- m_objectKeypoints(),
- m_descriptorsType(DT_INVALID),
- m_objectDescriptors(),
- m_recognitionRate(0.f)
+ __keypointsType(KT_INVALID),
+ __objectKeypoints(),
+ __descriptorsType(DT_INVALID),
+ __objectDescriptors(),
+ __recognitionRate(0.f)
{
; /* NULL */
}
FeaturePack::FeaturePack(const FeaturePack& copy) :
- m_keypointsType(copy.m_keypointsType),
- m_objectKeypoints(copy.m_objectKeypoints),
- m_descriptorsType(copy.m_descriptorsType),
- m_objectDescriptors(copy.m_objectDescriptors.clone()),
- m_recognitionRate(copy.m_recognitionRate)
+ __keypointsType(copy.__keypointsType),
+ __objectKeypoints(copy.__objectKeypoints),
+ __descriptorsType(copy.__descriptorsType),
+ __objectDescriptors(copy.__objectDescriptors.clone()),
+ __recognitionRate(copy.__recognitionRate)
{
; /* NULL */
}
FeaturePack& FeaturePack::operator= (const FeaturePack& copy)
{
if (this != ©) {
- m_keypointsType = copy.m_keypointsType;
- m_objectKeypoints = copy.m_objectKeypoints;
- m_descriptorsType = copy.m_descriptorsType;
- m_objectDescriptors = copy.m_objectDescriptors.clone();
- m_recognitionRate = copy.m_recognitionRate;
+ __keypointsType = copy.__keypointsType;
+ __objectKeypoints = copy.__objectKeypoints;
+ __descriptorsType = copy.__descriptorsType;
+ __objectDescriptors = copy.__objectDescriptors.clone();
+ __recognitionRate = copy.__recognitionRate;
}
return *this;
cv::Ptr<FeatureExtractor> ORBExtractorFactory::buildFeatureExtractor()
{
- cv::Ptr<FeatureExtractor> featureExtractor(new FeatureExtractor());
+ cv::Ptr<FeatureExtractor> featureExtractor(new (std::nothrow)FeatureExtractor());
+ if (featureExtractor == NULL)
+ return NULL;
cv::Ptr<cv::OrbFeatureDetector> detector(
- new cv::ORB(
- m_maximumFeaturesNumber,
- m_scaleFactor));
+ new (std::nothrow)cv::ORB(
+ __maximumFeaturesNumber,
+ __scaleFactor));
+ if (detector == NULL)
+ return NULL;
cv::Ptr<cv::OrbDescriptorExtractor> extractor = detector;
float ORBExtractorFactory::getScaleFactor() const
{
- return m_scaleFactor;
+ return __scaleFactor;
}
void ORBExtractorFactory::setScaleFactor(float scaleFactor)
{
- m_scaleFactor = scaleFactor;
+ __scaleFactor = scaleFactor;
}
size_t ORBExtractorFactory::getMaximumFeaturesNumber() const
{
- return m_scaleFactor;
+ return __scaleFactor;
}
void ORBExtractorFactory::setMaximumFeaturesNumber(size_t maximumFeaturesNumber)
{
- m_maximumFeaturesNumber = maximumFeaturesNumber;
+ __maximumFeaturesNumber = maximumFeaturesNumber;
}
float ORBExtractorFactory::computeRecognitionRate(
if (numberOfKeypoints < MinimumNumberOfFeatures)
return 0.f;
- static const size_t xCellsNumber = 10u;
- static const size_t yCellsNumber = 10u;
+ static const size_t X_CELLS_NUMBER = 10u;
+ static const size_t Y_CELLS_NUMBER = 10u;
- cv::Mat cells[xCellsNumber][yCellsNumber];
- size_t accumulationCounter[xCellsNumber][yCellsNumber];
+ cv::Mat cells[X_CELLS_NUMBER][Y_CELLS_NUMBER];
+ size_t accumulationCounter[X_CELLS_NUMBER][Y_CELLS_NUMBER];
- const size_t cellWidth = image.cols / xCellsNumber;
- const size_t cellHeight = image.rows / yCellsNumber;
+ const size_t cellWidth = image.cols / X_CELLS_NUMBER;
+ const size_t cellHeight = image.rows / Y_CELLS_NUMBER;
- for (size_t x = 0u; x < xCellsNumber; ++x) {
- for (size_t y = 0u; y < yCellsNumber; ++y) {
+ for (size_t x = 0u; x < X_CELLS_NUMBER; ++x) {
+ for (size_t y = 0u; y < Y_CELLS_NUMBER; ++y) {
cells[x][y] = image(cv::Rect(
x * cellWidth,
y * cellHeight,
for (size_t i = 0u; i < numberOfKeypoints; ++i) {
size_t xCellIdx = keypoints[i].pt.x / cellWidth;
- if (xCellIdx >= xCellsNumber)
- xCellIdx = xCellsNumber - 1;
-
+ if (xCellIdx >= X_CELLS_NUMBER)
+ xCellIdx = X_CELLS_NUMBER - 1;
size_t yCellIdx = keypoints[i].pt.y / cellHeight;
- if (yCellIdx >= yCellsNumber)
- yCellIdx = yCellsNumber - 1;
-
+ if (yCellIdx >= Y_CELLS_NUMBER)
+ yCellIdx = Y_CELLS_NUMBER - 1;
++(accumulationCounter[xCellIdx][yCellIdx]);
}
const float exceptedNumber = numberOfKeypoints /
- (float)(xCellsNumber * yCellsNumber);
+ (float)(X_CELLS_NUMBER * Y_CELLS_NUMBER);
float distributedEvaluation = 0.f;
- for (size_t x = 0u; x < xCellsNumber; ++x) {
- for (size_t y = 0u; y < yCellsNumber; ++y) {
+ for (size_t x = 0u; x < X_CELLS_NUMBER; ++x) {
+ for (size_t y = 0u; y < Y_CELLS_NUMBER; ++y) {
distributedEvaluation += (accumulationCounter[x][y] - exceptedNumber) *
(accumulationCounter[x][y] - exceptedNumber) / exceptedNumber;
}
}
- float maximumDistributedEvaluation = (xCellsNumber * yCellsNumber - 1) *
- exceptedNumber;
+ float maximumDistributedEvaluation = (X_CELLS_NUMBER * Y_CELLS_NUMBER - 1) *
+ exceptedNumber;
maximumDistributedEvaluation += (numberOfKeypoints - exceptedNumber) *
(numberOfKeypoints - exceptedNumber) / exceptedNumber;
distributedEvaluation = 1 -
- (distributedEvaluation / maximumDistributedEvaluation);
+ (distributedEvaluation / maximumDistributedEvaluation);
/* Exponentiation to find an approximate confidence value based on the
* number of key points on the image. */
}
RecognitionParams::RecognitionParams() :
- mMinMatchesNumber(0),
- mRequiredMatchesPart(1.0),
- mTolerantMatchesPartError(0.0)
+ mMinMatchesNumber(0),
+ mRequiredMatchesPart(1.0),
+ mTolerantMatchesPartError(0.0)
{
; /* NULL */
}
}
TrackingParams::TrackingParams(
- FeaturesExtractingParams framesFeaturesExtractingParams,
- RecognitionParams recognitionParams,
- StabilizationParams stabilizationParams,
- double expectedOffset) :
+ FeaturesExtractingParams framesFeaturesExtractingParams,
+ RecognitionParams recognitionParams,
+ StabilizationParams stabilizationParams,
+ double expectedOffset) :
mFramesFeaturesExtractingParams(framesFeaturesExtractingParams),
mRecognitionParams(recognitionParams),
mStabilizationParams(stabilizationParams),
for (size_t i = 0u, j = numberOfContourPoints - 1; i < numberOfContourPoints; j = i++) {
if (((region[i].y > point.y) != (region[j].y > point.y)) &&
- ((float) point.x < (float)
- (region[j].x - region[i].x) * (point.y - region[i].y) /
- (region[j].y - region[i].y) + region[i].x)) {
+ ((float) point.x < (float)
+ (region[j].x - region[i].x) * (point.y - region[i].y) /
+ (region[j].y - region[i].y) + region[i].x))
insideFlag = !insideFlag;
- }
}
return insideFlag;
namespace MediaVision {
namespace Image {
ImageObject::ImageObject() :
- m_features(),
- m_isEmpty(true),
- m_isLabeled(false),
- m_label(0)
+ __features(),
+ __isEmpty(true),
+ __isLabeled(false),
+ __label(0)
{
; /* NULL */
}
ImageObject::ImageObject(const cv::Mat& image, const FeaturesExtractingParams& params) :
- m_featureExtractingParams(),
- m_features(),
- m_isEmpty(true),
- m_isLabeled(false),
- m_label(0)
+ __featureExtractingParams(),
+ __features(),
+ __isEmpty(true),
+ __isLabeled(false),
+ __label(0)
{
fill(image, params);
}
ImageObject::ImageObject(const ImageObject& copy) :
- m_featureExtractingParams(copy.m_featureExtractingParams),
- m_features(copy.m_features),
- m_isEmpty(copy.m_isEmpty),
- m_isLabeled(copy.m_isLabeled),
- m_label(copy.m_label),
- m_boundingContour(copy.m_boundingContour)
+ __featureExtractingParams(copy.__featureExtractingParams),
+ __features(copy.__features),
+ __isEmpty(copy.__isEmpty),
+ __isLabeled(copy.__isLabeled),
+ __label(copy.__label),
+ __boundingContour(copy.__boundingContour)
{
; /* NULL */
}
ImageObject& ImageObject::operator=(const ImageObject& copy)
{
if (this != ©) {
- m_isEmpty = copy.m_isEmpty;
- m_isLabeled = copy.m_isLabeled;
- m_label = copy.m_label;
- m_boundingContour = copy.m_boundingContour;
+ __isEmpty = copy.__isEmpty;
+ __isLabeled = copy.__isLabeled;
+ __label = copy.__label;
+ __boundingContour = copy.__boundingContour;
- m_features = copy.m_features;
+ __features = copy.__features;
}
return *this;
const FeaturesExtractingParams& params,
const std::vector<cv::Point2f>& roi)
{
- m_isEmpty = false;
+ __isEmpty = false;
if (!roi.empty()) {
- m_boundingContour = roi;
+ __boundingContour = roi;
} else {
- m_boundingContour.resize(NumberOfQuadrangleCorners);
+ __boundingContour.resize(NumberOfQuadrangleCorners);
- m_boundingContour[0].x = 0.f;
- m_boundingContour[0].y = 0.f;
+ __boundingContour[0].x = 0.f;
+ __boundingContour[0].y = 0.f;
- m_boundingContour[1].x = image.cols;
- m_boundingContour[1].y = 0.f;
+ __boundingContour[1].x = image.cols;
+ __boundingContour[1].y = 0.f;
- m_boundingContour[2].x = image.cols;
- m_boundingContour[2].y = image.rows;
+ __boundingContour[2].x = image.cols;
+ __boundingContour[2].y = image.rows;
- m_boundingContour[3].x = 0.f;
- m_boundingContour[3].y = image.rows;
+ __boundingContour[3].x = 0.f;
+ __boundingContour[3].y = image.rows;
}
- extractFeatures(image, params, m_boundingContour);
+ extractFeatures(image, params, __boundingContour);
- m_featureExtractingParams = params;
+ __featureExtractingParams = params;
LOGI("[%s] Image object is filled.", __FUNCTION__);
}
float ImageObject::getRecognitionRate(void) const
{
- return m_features.m_recognitionRate;
+ return __features.__recognitionRate;
}
void ImageObject::extractFeatures(
}
if (!extractor.empty())
- extractor->extract(image, m_features, roi);
+ extractor->extract(image, __features, roi);
}
bool ImageObject::isEmpty() const
{
- return (m_features.m_objectKeypoints.empty() ||
- m_features.m_objectDescriptors.empty());
+ return (__features.__objectKeypoints.empty() ||
+ __features.__objectDescriptors.empty());
}
void ImageObject::setContour(const std::vector<cv::Point2f>& contour)
{
- m_boundingContour = contour;
+ __boundingContour = contour;
}
void ImageObject::setLabel(int label)
{
- m_isLabeled = true;
- m_label = label;
+ __isLabeled = true;
+ __label = label;
}
bool ImageObject::getLabel(int& label) const
{
- if (!m_isLabeled) {
+ if (!__isLabeled) {
LOGW("[%s] Image hasn't label.", __FUNCTION__);
return false;
}
- label = m_label;
+ label = __label;
return true;
}
{
os << std::setprecision(7);
- os << obj.m_isEmpty << '\n';
- os << obj.m_isLabeled << '\n';
- os << obj.m_label << '\n';
+ os << obj.__isEmpty << '\n';
+ os << obj.__isLabeled << '\n';
+ os << obj.__label << '\n';
- os << obj.m_boundingContour.size() << '\n';
- for (size_t pointNum = 0u; pointNum < obj.m_boundingContour.size(); ++pointNum) {
- os << obj.m_boundingContour[pointNum].x << ' ';
- os << obj.m_boundingContour[pointNum].y << '\n';
+ os << obj.__boundingContour.size() << '\n';
+ for (size_t pointNum = 0u; pointNum < obj.__boundingContour.size(); ++pointNum) {
+ os << obj.__boundingContour[pointNum].x << ' ';
+ os << obj.__boundingContour[pointNum].y << '\n';
}
- const size_t numberOfKeypoints = obj.m_features.m_objectKeypoints.size();
+ const size_t numberOfKeypoints = obj.__features.__objectKeypoints.size();
os << numberOfKeypoints << '\n';
for (size_t keypointNum = 0u; keypointNum < numberOfKeypoints; ++keypointNum) {
- os << obj.m_features.m_objectKeypoints[keypointNum].pt.x << ' ';
- os << obj.m_features.m_objectKeypoints[keypointNum].pt.y << ' ';
- os << obj.m_features.m_objectKeypoints[keypointNum].size << ' ';
- os << obj.m_features.m_objectKeypoints[keypointNum].response << ' ';
- os << obj.m_features.m_objectKeypoints[keypointNum].angle << ' ';
- os << obj.m_features.m_objectKeypoints[keypointNum].octave << ' ';
- os << obj.m_features.m_objectKeypoints[keypointNum].class_id << '\n';
+ os << obj.__features.__objectKeypoints[keypointNum].pt.x << ' ';
+ os << obj.__features.__objectKeypoints[keypointNum].pt.y << ' ';
+ os << obj.__features.__objectKeypoints[keypointNum].size << ' ';
+ os << obj.__features.__objectKeypoints[keypointNum].response << ' ';
+ os << obj.__features.__objectKeypoints[keypointNum].angle << ' ';
+ os << obj.__features.__objectKeypoints[keypointNum].octave << ' ';
+ os << obj.__features.__objectKeypoints[keypointNum].class_id << '\n';
}
- const int numberOfDescriptors = obj.m_features.m_objectDescriptors.rows;
- const int sizeOfDescriptor = obj.m_features.m_objectDescriptors.cols;
+ const int numberOfDescriptors = obj.__features.__objectDescriptors.rows;
+ const int sizeOfDescriptor = obj.__features.__objectDescriptors.cols;
os << numberOfDescriptors << ' ';
os << sizeOfDescriptor << ' ';
- os << obj.m_features.m_objectDescriptors.type() << '\n';
+ os << obj.__features.__objectDescriptors.type() << '\n';
for (int descriptorNum = 0; descriptorNum < numberOfDescriptors;
++descriptorNum, os << '\n') {
for (int featureNum = 0; featureNum < sizeOfDescriptor;
++featureNum) {
- os << (int)obj.m_features.m_objectDescriptors.at<uchar>(
+ os << (int)obj.__features.__objectDescriptors.at<uchar>(
descriptorNum,
featureNum) << ' ';
}
return is; \
}
- is >> temporal.m_isEmpty;
+ is >> temporal.__isEmpty;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_isLabeled;
+ is >> temporal.__isLabeled;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_label;
+ is >> temporal.__label;
MEDIA_VISION_CHECK_IFSTREAM
is >> numberOfContourPoints;
MEDIA_VISION_CHECK_IFSTREAM
- temporal.m_boundingContour.resize(numberOfContourPoints);
+ temporal.__boundingContour.resize(numberOfContourPoints);
for (size_t pointNum = 0; pointNum < numberOfContourPoints; ++pointNum) {
- is >> temporal.m_boundingContour[pointNum].x;
+ is >> temporal.__boundingContour[pointNum].x;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_boundingContour[pointNum].y;
+ is >> temporal.__boundingContour[pointNum].y;
MEDIA_VISION_CHECK_IFSTREAM
}
is >> numberOfKeypoints;
- temporal.m_features.m_objectKeypoints.resize(numberOfKeypoints);
+ temporal.__features.__objectKeypoints.resize(numberOfKeypoints);
for (size_t keypointNum = 0; keypointNum < numberOfKeypoints; ++keypointNum) {
- is >> temporal.m_features.m_objectKeypoints[keypointNum].pt.x;
+ is >> temporal.__features.__objectKeypoints[keypointNum].pt.x;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_features.m_objectKeypoints[keypointNum].pt.y;
+ is >> temporal.__features.__objectKeypoints[keypointNum].pt.y;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_features.m_objectKeypoints[keypointNum].size;
+ is >> temporal.__features.__objectKeypoints[keypointNum].size;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_features.m_objectKeypoints[keypointNum].response;
+ is >> temporal.__features.__objectKeypoints[keypointNum].response;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_features.m_objectKeypoints[keypointNum].angle;
+ is >> temporal.__features.__objectKeypoints[keypointNum].angle;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_features.m_objectKeypoints[keypointNum].octave;
+ is >> temporal.__features.__objectKeypoints[keypointNum].octave;
MEDIA_VISION_CHECK_IFSTREAM
- is >> temporal.m_features.m_objectKeypoints[keypointNum].class_id;
+ is >> temporal.__features.__objectKeypoints[keypointNum].class_id;
MEDIA_VISION_CHECK_IFSTREAM
}
MEDIA_VISION_CHECK_IFSTREAM
is >> descriptorType;
MEDIA_VISION_CHECK_IFSTREAM
- temporal.m_features.m_objectDescriptors = cv::Mat(rows, cols, descriptorType);
+ temporal.__features.__objectDescriptors = cv::Mat(rows, cols, descriptorType);
int value = 0;
for (int descriptorNum = 0; descriptorNum < rows; ++descriptorNum) {
for (int featureNum = 0; featureNum < cols; ++featureNum) {
is >> value;
MEDIA_VISION_CHECK_IFSTREAM
- temporal.m_features.m_objectDescriptors.at<uchar>(descriptorNum, featureNum) =
+ temporal.__features.__objectDescriptors.at<uchar>(descriptorNum, featureNum) =
(uchar)value;
}
}
namespace MediaVision {
namespace Image {
ImageRecognizer::ImageRecognizer(const ImageObject& scene) :
- m_scene(scene)
+ __scene(scene)
{
; /* NULL */
}
contour.clear();
- if (MinimumNumberOfFeatures > target.m_features.m_objectKeypoints.size()) {
+ if (MinimumNumberOfFeatures > target.__features.__objectKeypoints.size()) {
LOGW("[%s] Image object can't be recognized (Recognition rate is too small).", __FUNCTION__);
return false;
}
- if (MinimumNumberOfFeatures > m_scene.m_features.m_objectKeypoints.size()) {
+ if (MinimumNumberOfFeatures > __scene.__features.__objectKeypoints.size()) {
LOGW("[%s] Scene image can't be analyzed (Too few features for recognition).", __FUNCTION__);
return false;
}
return false;
}
- cv::perspectiveTransform(target.m_boundingContour, contour, homophraphyMatrix);
+ cv::perspectiveTransform(target.__boundingContour, contour, homophraphyMatrix);
- if (target.m_boundingContour.size() == NumberOfQuadrangleCorners) {
+ if (target.__boundingContour.size() == NumberOfQuadrangleCorners) {
if (!isPossibleQuadrangleCorners(contour.data())) {
LOGI("[%s] Image object isn't recognized.", __FUNCTION__);
contour.clear();
{
std::vector<cv::DMatch> matches;
- m_matcher.match(
- target.m_features.m_objectDescriptors,
- m_scene.m_features.m_objectDescriptors,
+ __matcher.match(
+ target.__features.__objectDescriptors,
+ __scene.__features.__objectDescriptors,
matches);
size_t matchesNumber = matches.size();
if (requiredMatchesNumber + allowableMatchesNumberError >
(size_t)params.mMinMatchesNumber) {
requiredMatchesNumber = ((size_t)params.mMinMatchesNumber +
- requiredMatchesNumber + allowableMatchesNumberError) / 2;
+ requiredMatchesNumber + allowableMatchesNumberError) / 2;
allowableMatchesNumberError = requiredMatchesNumber-
(size_t)params.mMinMatchesNumber +
for (size_t matchIdx = 0; matchIdx < matchesNumber; ++matchIdx) {
objectPoints[matchIdx] =
- target.m_features.m_objectKeypoints[matches[matchIdx].queryIdx].pt;
+ target.__features.__objectKeypoints[matches[matchIdx].queryIdx].pt;
scenePoints[matchIdx] =
- m_scene.m_features.m_objectKeypoints[matches[matchIdx].trainIdx].pt;
+ __scene.__features.__objectKeypoints[matches[matchIdx].trainIdx].pt;
}
if (ignoreFactor > FLT_EPSILON) {
const std::vector<cv::Point2f> significantArea = contourResize(
- target.m_boundingContour,
+ target.__boundingContour,
ignoreFactor);
for (size_t matchIdx = 0; matchIdx < objectPoints.size(); ++matchIdx) {
while (true) {
/* Search the leftmost element which have bigger confidence than support element */
while (examples[leftLimit].distance <= supportElement &&
- leftLimit < startRightLimit) {
+ leftLimit < startRightLimit)
++leftLimit;
- }
/* Search the rightmost element which have smaller confidence than support element */
while (examples[rightLimit].distance >= supportElement &&
- rightLimit >= startLeftLimit) {
+ rightLimit >= startLeftLimit)
--rightLimit;
- }
if (leftLimit >= rightLimit)
break;
bool ImageRecognizer::isPossibleQuadrangleCorners(
const cv::Point2f corners[NumberOfQuadrangleCorners])
{
- static const float Epsilon = 0.1f;
+ static const float __EPSILON = 0.1f;
- /* TODO: move the MinSizeOfDetectedArea out of the ImageRecognizer */
- static const float MinSizeOfDetectedArea = 64.f;
+ /* TODO: move the __MIN_SIZE_OF_DETECTED_AREA out of the ImageRecognizer */
+ static const float __MIN_SIZE_OF_DETECTED_AREA = 64.f;
const float firstSemiArea = getTriangleArea(corners[0], corners[2], corners[1]) +
getTriangleArea(corners[0], corners[2], corners[3]);
const float secondSemiArea = getTriangleArea(corners[1], corners[3], corners[2]) +
getTriangleArea(corners[1], corners[3], corners[0]);
- if (Epsilon < fabs(firstSemiArea - secondSemiArea) ||
- MinSizeOfDetectedArea > (firstSemiArea + secondSemiArea))
+ if (__EPSILON < fabs(firstSemiArea - secondSemiArea) ||
+ __MIN_SIZE_OF_DETECTED_AREA > (firstSemiArea + secondSemiArea))
return false;
return true;
#include "Tracking/AsyncTracker.h"
+#include <new>
+
namespace MediaVision {
namespace Image {
+
AsyncTracker::AsyncTracker(const AsyncTracker& copy) :
- m_baseTracker(copy.m_baseTracker.obj->clone()),
- m_result(copy.m_result),
- m_isRun(false),
- m_isUpdated(copy.m_isUpdated),
- m_copyingPolicy(copy.m_copyingPolicy),
- m_thread(0)
+ __baseTracker(copy.__baseTracker.obj->clone()),
+ __result(copy.__result),
+ __isRun(false),
+ __isUpdated(copy.__isUpdated),
+ __copyingPolicy(copy.__copyingPolicy),
+ __mvThread(0)
{
- pthread_mutex_init(&m_globalGuard, NULL);
- pthread_spin_init(&m_resultGuard, PTHREAD_PROCESS_SHARED);
- pthread_spin_init(&m_isRunGuard, PTHREAD_PROCESS_SHARED);
- pthread_spin_init(&m_isUpdatedGuard, PTHREAD_PROCESS_SHARED);
+ pthread_mutex_init(&__globalGuard, NULL);
+ pthread_spin_init(&__resultGuard, PTHREAD_PROCESS_SHARED);
+ pthread_spin_init(&__isRunGuard, PTHREAD_PROCESS_SHARED);
+ pthread_spin_init(&__isUpdatedGuard, PTHREAD_PROCESS_SHARED);
}
AsyncTracker::AsyncTracker(
cv::Ptr<ObjectTracker> baseTracker,
bool copyingPolicy) :
- m_baseTracker(baseTracker),
- m_result(),
- m_isRun(false),
- m_isUpdated(false),
- m_copyingPolicy(copyingPolicy),
- m_thread(0)
+ __baseTracker(baseTracker),
+ __result(),
+ __isRun(false),
+ __isUpdated(false),
+ __copyingPolicy(copyingPolicy),
+ __mvThread(0)
{
- pthread_mutex_init(&m_globalGuard, NULL);
- pthread_spin_init(&m_resultGuard, PTHREAD_PROCESS_SHARED);
- pthread_spin_init(&m_isRunGuard, PTHREAD_PROCESS_SHARED);
- pthread_spin_init(&m_isUpdatedGuard, PTHREAD_PROCESS_SHARED);
+ pthread_mutex_init(&__globalGuard, NULL);
+ pthread_spin_init(&__resultGuard, PTHREAD_PROCESS_SHARED);
+ pthread_spin_init(&__isRunGuard, PTHREAD_PROCESS_SHARED);
+ pthread_spin_init(&__isUpdatedGuard, PTHREAD_PROCESS_SHARED);
}
AsyncTracker::~AsyncTracker()
{
- if(isRun())
- pthread_join(m_thread, NULL);
+ if(isRun()) {
+ pthread_mutex_lock(&__globalGuard);
+ pthread_mutex_unlock(&__globalGuard);
+ }
- pthread_mutex_destroy(&m_globalGuard);
- pthread_spin_destroy(&m_resultGuard);
- pthread_spin_destroy(&m_isRunGuard);
- pthread_spin_destroy(&m_isUpdatedGuard);
+ pthread_mutex_destroy(&__globalGuard);
+ pthread_spin_destroy(&__resultGuard);
+ pthread_spin_destroy(&__isRunGuard);
+ pthread_spin_destroy(&__isUpdatedGuard);
}
bool AsyncTracker::track(
const cv::Mat& frame,
std::vector<cv::Point>& result)
{
- while (pthread_mutex_trylock(&m_globalGuard) != 0) {
+ while (pthread_mutex_trylock(&__globalGuard) != 0)
return getResult(result);
- }
- pthread_spin_lock(&m_isRunGuard);
- m_isRun = true;
- pthread_spin_unlock(&m_isRunGuard);
+ pthread_spin_lock(&__isRunGuard);
+ __isRun = true;
+ pthread_spin_unlock(&__isRunGuard);
- if (m_copyingPolicy)
- m_frame = frame.clone();
+ if (__copyingPolicy)
+ __frame = frame.clone();
else
- m_frame = frame;
+ __frame = frame;
- const int err = pthread_create(&m_thread, NULL, asyncTrack, this);
+ const int err = pthread_create(&__mvThread, NULL, asyncTrack, this);
if (0 == err) {
- pthread_join(m_thread, NULL);
+ pthread_detach(__mvThread);
return getResult(result);
}
- pthread_spin_lock(&m_isRunGuard);
- m_isRun = false;
- pthread_spin_unlock(&m_isRunGuard);
+ pthread_spin_lock(&__isRunGuard);
+ __isRun = false;
+ pthread_spin_unlock(&__isRunGuard);
- pthread_mutex_unlock(&m_globalGuard);
+ pthread_mutex_unlock(&__globalGuard);
return getResult(result);
}
void AsyncTracker::reinforcement(const std::vector<cv::Point>& location)
{
/* TODO: Unsafe. Need to redesign. */
- m_baseTracker->reinforcement(location);
+ __baseTracker->reinforcement(location);
- pthread_spin_lock(&m_resultGuard);
- m_result = location;
- pthread_spin_unlock(&m_resultGuard);
+ pthread_spin_lock(&__resultGuard);
+ __result = location;
+ pthread_spin_unlock(&__resultGuard);
}
cv::Ptr<ObjectTracker> AsyncTracker::clone() const
{
- return cv::Ptr<ObjectTracker>(new AsyncTracker(*this));
+ return cv::Ptr<ObjectTracker>(new (std::nothrow)AsyncTracker(*this));
}
bool AsyncTracker::baseTrack(std::vector<cv::Point>& result)
{
- return m_baseTracker->track(m_frame, result);
+ return __baseTracker->track(__frame, result);
}
void *AsyncTracker::asyncTrack(void *data)
std::vector<cv::Point> result;
tracker->baseTrack(result);
- pthread_spin_lock(&tracker->m_resultGuard);
- tracker->m_result = result;
- pthread_spin_unlock(&tracker->m_resultGuard);
+ pthread_spin_lock(&tracker->__resultGuard);
+ tracker->__result = result;
+ pthread_spin_unlock(&tracker->__resultGuard);
- pthread_spin_lock(&tracker->m_isUpdatedGuard);
- tracker->m_isUpdated = true;
- pthread_spin_unlock(&tracker->m_isUpdatedGuard);
+ pthread_spin_lock(&tracker->__isUpdatedGuard);
+ tracker->__isUpdated = true;
+ pthread_spin_unlock(&tracker->__isUpdatedGuard);
- pthread_mutex_unlock(&tracker->m_globalGuard);
+ pthread_mutex_unlock(&tracker->__globalGuard);
- pthread_spin_lock(&tracker->m_isRunGuard);
- tracker->m_isRun = false;
- pthread_spin_unlock(&tracker->m_isRunGuard);
+ pthread_spin_lock(&tracker->__isRunGuard);
+ tracker->__isRun = false;
+ pthread_spin_unlock(&tracker->__isRunGuard);
return NULL;
}
bool AsyncTracker::wait()
{
if(isRun()) {
- pthread_join(m_thread, NULL);
+ pthread_mutex_lock(&__globalGuard);
+ pthread_mutex_unlock(&__globalGuard);
return true;
}
return false;
{
bool result = false;
- pthread_spin_lock(&m_isRunGuard);
- result = m_isRun;
- pthread_spin_unlock(&m_isRunGuard);
+ pthread_spin_lock(&__isRunGuard);
+ result = __isRun;
+ pthread_spin_unlock(&__isRunGuard);
return result;
}
getResult(result);
- pthread_spin_lock(&m_isUpdatedGuard);
- isUpdated = m_isUpdated;
- m_isUpdated = false;
- pthread_spin_unlock(&m_isUpdatedGuard);
+ pthread_spin_lock(&__isUpdatedGuard);
+ isUpdated = __isUpdated;
+ __isUpdated = false;
+ pthread_spin_unlock(&__isUpdatedGuard);
return isUpdated;
}
{
bool isTracked = false;
- pthread_spin_lock(&m_resultGuard);
- isTracked = !m_result.empty();
- result = m_result;
- pthread_spin_unlock(&m_resultGuard);
+ pthread_spin_lock(&__resultGuard);
+ isTracked = !__result.empty();
+ result = __result;
+ pthread_spin_unlock(&__resultGuard);
return isTracked;
}
#include "Tracking/AsyncTracker.h"
#include "ImageMathUtil.h"
+#include <new>
namespace MediaVision {
namespace Image {
+
CascadeTracker::CascadeTracker(float minimumArea) :
- m_trackers(),
- m_minimumArea(minimumArea)
+ __trackers(),
+ __minimumArea(minimumArea)
{
; /* NULL */
}
CascadeTracker::CascadeTracker(const CascadeTracker& copy) :
- m_trackers(),
- m_minimumArea(copy.m_minimumArea)
+ __trackers(),
+ __minimumArea(copy.__minimumArea)
{
*this = copy;
}
{
internalReinforcement();
- std::set<TrackerInfo>::iterator it = m_trackers.begin();
+ std::set<TrackerInfo>::iterator it = __trackers.begin();
- for (; it != m_trackers.end(); ++it) {
- if (!it->mTracker.obj->track(frame, it->mResult)) {
+ for (; it != __trackers.end(); ++it)
+ if (!it->mTracker.obj->track(frame, it->mResult))
it->mResult.clear();
- }
- }
return mergeResults(result);
}
void CascadeTracker::reinforcement(const std::vector<cv::Point>& location)
{
- std::set<TrackerInfo>::iterator it = m_trackers.begin();
+ std::set<TrackerInfo>::iterator it = __trackers.begin();
- for (; it != m_trackers.end(); ++it)
+ for (; it != __trackers.end(); ++it)
it->mTracker.obj->reinforcement(location);
}
cv::Ptr<ObjectTracker> CascadeTracker::clone() const
{
- return cv::Ptr<ObjectTracker>(new CascadeTracker(*this));
+ return cv::Ptr<ObjectTracker>(new (std::nothrow)CascadeTracker(*this));
}
CascadeTracker& CascadeTracker::operator=(const CascadeTracker& copy)
{
if (this != ©) {
- this->m_minimumArea = copy.m_minimumArea;
- this->m_trackers.clear();
+ this->__minimumArea = copy.__minimumArea;
+ this->__trackers.clear();
- std::set<TrackerInfo>::iterator it = copy.m_trackers.begin();
- for (; it != copy.m_trackers.end(); ++it) {
+ std::set<TrackerInfo>::iterator it = copy.__trackers.begin();
+ for (; it != copy.__trackers.end(); ++it) {
TrackerInfo temp(it->mTracker.obj->clone(), it->mPriority);
temp.mResult = it->mResult;
- m_trackers.insert(temp);
+ __trackers.insert(temp);
}
}
TrackerInfo temp(tracker, priority);
std::set<TrackerInfo>::iterator it =
- std::find(m_trackers.begin(), m_trackers.end(), temp);
+ std::find(__trackers.begin(), __trackers.end(), temp);
- if (it != m_trackers.end())
- m_trackers.erase(it);
+ if (it != __trackers.end())
+ __trackers.erase(it);
- return m_trackers.insert(temp).second;
+ return __trackers.insert(temp).second;
}
bool CascadeTracker::disableTracker(cv::Ptr<ObjectTracker> tracker)
TrackerInfo target(tracker, 0);
std::set<TrackerInfo>::iterator it =
- std::find(m_trackers.begin(), m_trackers.end(), target);
+ std::find(__trackers.begin(), __trackers.end(), target);
- if (it == m_trackers.end())
+ if (it == __trackers.end())
return false;
- m_trackers.erase(it);
+ __trackers.erase(it);
return true;
}
void CascadeTracker::internalReinforcement()
{
- std::set<TrackerInfo>::iterator it1 = m_trackers.begin();
- for (; it1 != m_trackers.end(); ++it1) {
+ std::set<TrackerInfo>::iterator it1 = __trackers.begin();
+ for (; it1 != __trackers.end(); ++it1) {
bool isUpdated = true;
/* TODO: Redesign without dynamic_cast */
checkedArea[i].y = it1->mResult[i].y;
}
- if (getQuadrangleArea(checkedArea.data()) < m_minimumArea) {
+ if (getQuadrangleArea(checkedArea.data()) < __minimumArea) {
it1->mResult = std::vector<cv::Point>(0);
it1->mTracker.obj->reinforcement(it1->mResult);
}
float priority = it1->mPriority;
- std::set<TrackerInfo>::iterator it2 = m_trackers.begin();
+ std::set<TrackerInfo>::iterator it2 = __trackers.begin();
- for (; it2 != m_trackers.end(); ++it2) {
- if (it1 != it2 &&
- priority > it2->mPriority) {
+ for (; it2 != __trackers.end(); ++it2)
+ if (it1 != it2 && priority > it2->mPriority)
it2->mTracker.obj->reinforcement(it1->mResult);
- }
- }
}
}
}
{
result.clear();
- std::set<TrackerInfo>::iterator it = m_trackers.begin();
+ std::set<TrackerInfo>::iterator it = __trackers.begin();
float resPriotiry = 0.f;
- for (; it != m_trackers.end(); ++it) {
+ for (; it != __trackers.end(); ++it) {
if (result.empty() || resPriotiry > it->mPriority) {
resPriotiry = it->mPriority;
result = it->mResult;
#include "Recognition/ImageRecognizer.h"
+#include <new>
+
namespace MediaVision {
namespace Image {
+
FeatureSubstitutionTracker::FeatureSubstitutionTracker(
const FeaturesExtractingParams& featuresExtractingParams,
const RecognitionParams& recognitionParams,
float expectedOffset,
float sceneScalingFactor,
float objectScalingFactor) :
- m_isInit(false),
- m_target(),
- m_location(),
- m_featureExtractingParams(featuresExtractingParams),
- m_recogParams(recognitionParams),
- m_expectedOffset(expectedOffset),
- m_sceneScalingFactor(sceneScalingFactor),
- m_objectScalingFactor(objectScalingFactor)
+ __isInit(false),
+ __target(),
+ __location(),
+ __featureExtractingParams(featuresExtractingParams),
+ __recogParams(recognitionParams),
+ __expectedOffset(expectedOffset),
+ __sceneScalingFactor(sceneScalingFactor),
+ __objectScalingFactor(objectScalingFactor)
{
; /* NULL */
}
std::vector<cv::Point>& result)
{
std::vector<cv::Point2f> contour;
- size_t numberOfContourPoints = m_location.size();
+ size_t numberOfContourPoints = __location.size();
contour.resize(numberOfContourPoints);
- for(size_t i = 0u; i < numberOfContourPoints; ++i) {
- contour[i].x = m_location[i].x;
- contour[i].y = m_location[i].y;
+ for (size_t i = 0u; i < numberOfContourPoints; ++i) {
+ contour[i].x = __location[i].x;
+ contour[i].y = __location[i].y;
}
- if (!m_isInit) {
- if (m_location.empty()) {
+ if (!__isInit) {
+ if (__location.empty()) {
return false;
} else {
- m_target = new ImageObject;
- m_target->fill(
+ __target = new (std::nothrow)ImageObject;
+ if (__target == NULL)
+ return false;
+
+ __target->fill(
frame,
- m_featureExtractingParams,
- contourResize(contour, m_objectScalingFactor));
- m_target->setContour(contour);
- m_isInit = true;
- result = m_location;
+ __featureExtractingParams,
+ contourResize(contour, __objectScalingFactor));
+ __target->setContour(contour);
+ __isInit = true;
+ result = __location;
return true;
}
}
- cv::Ptr<ImageObject> sceneImageObject = new ImageObject;
+ cv::Ptr<ImageObject> sceneImageObject = new (std::nothrow)ImageObject;
+ if (sceneImageObject == NULL)
+ return false;
- sceneImageObject->fill(frame, m_featureExtractingParams, computeExpectedArea());
+ sceneImageObject->fill(frame, __featureExtractingParams, computeExpectedArea());
ImageRecognizer recognizer(*sceneImageObject.obj);
const bool isTracked =
recognizer.recognize(
- *m_target.obj,
- m_recogParams,
+ *__target.obj,
+ __recogParams,
contour,
- m_objectScalingFactor);
+ __objectScalingFactor);
if (isTracked) {
numberOfContourPoints = contour.size();
- m_location.resize(numberOfContourPoints);
- for(size_t i = 0u; i < numberOfContourPoints; ++i) {
- m_location[i].x = (int)contour[i].x;
- m_location[i].y = (int)contour[i].y;
+ __location.resize(numberOfContourPoints);
+ for (size_t i = 0u; i < numberOfContourPoints; ++i) {
+ __location[i].x = (int)contour[i].x;
+ __location[i].y = (int)contour[i].y;
}
- result = m_location;
- m_target = sceneImageObject;
- m_target->setContour(contour);
+ result = __location;
+ __target = sceneImageObject;
+ __target->setContour(contour);
} else {
- m_location.clear();
- m_isInit = false;
+ __location.clear();
+ __isInit = false;
}
return isTracked;
void FeatureSubstitutionTracker::reinforcement(const std::vector<cv::Point>& location)
{
- m_isInit = false;
+ __isInit = false;
if (location.size() < 3) {
- m_location.clear();
+ __location.clear();
return;
}
- m_location = location;
+ __location = location;
}
cv::Ptr<ObjectTracker> FeatureSubstitutionTracker::clone() const
{
- return cv::Ptr<ObjectTracker>(new FeatureSubstitutionTracker(*this));
+ return cv::Ptr<ObjectTracker>(new (std::nothrow)FeatureSubstitutionTracker(*this));
}
std::vector<cv::Point2f> FeatureSubstitutionTracker::computeExpectedArea()
{
std::vector<cv::Point2f> contour;
- const size_t numberOfContourPoints = m_location.size();
+ const size_t numberOfContourPoints = __location.size();
contour.resize(numberOfContourPoints);
- for(size_t i = 0u; i < numberOfContourPoints; ++i) {
- contour[i].x = m_location[i].x;
- contour[i].y = m_location[i].y;
+ for (size_t i = 0u; i < numberOfContourPoints; ++i) {
+ contour[i].x = __location[i].x;
+ contour[i].y = __location[i].y;
}
- return contourResize(contour, m_sceneScalingFactor);
+ return contourResize(contour, __sceneScalingFactor);
}
} /* Image */
namespace MediaVision {
namespace Image {
+
ImageContourStabilizator::ImageContourStabilizator() :
- m_movingHistory(),
- m_priorities()
+ __movingHistory(),
+ __priorities()
{
reset();
}
void ImageContourStabilizator::reset(void)
{
- m_tolerantShift = 0.0f;
- m_tolerantShiftExtra = 0.0f;
- m_isPrepared = false;
- m_tempContourIndex = -1;
- m_currentHistoryAmount = 0;
- m_historyAmount = 0;
- m_movingHistory.clear();
+ __tolerantShift = 0.0f;
+ __tolerantShiftExtra = 0.0f;
+ __isPrepared = false;
+ __tempContourIndex = -1;
+ __currentHistoryAmount = 0;
+ __historyAmount = 0;
+ __movingHistory.clear();
}
ImageContourStabilizator::StabilizationError ImageContourStabilizator::stabilize(
return UnsupportedContourType;
}
- m_currentCornersSpeed.resize(contour.size(), 0);
+ __currentCornersSpeed.resize(contour.size(), 0);
- if (m_lastStabilizedContour.empty())
- m_lastStabilizedContour = contour;
+ if (__lastStabilizedContour.empty())
+ __lastStabilizedContour = contour;
std::vector<cv::Point2f> stabilizedState;
/* history amount < 2 it's no sense */
- if (m_historyAmount >= 2) {
+ if (__historyAmount >= 2) {
/* first sample */
- if (m_tempContourIndex == -1) {
- m_movingHistory.push_back(contour);
- m_movingHistory.push_back(contour);
+ if (__tempContourIndex == -1) {
+ __movingHistory.push_back(contour);
+ __movingHistory.push_back(contour);
- m_tempContourIndex = 1;
- m_currentHistoryAmount = 2;
+ __tempContourIndex = 1;
+ __currentHistoryAmount = 2;
LOGI("Not stabilized. Too small moving history. (the first one)");
}
/* too short moving history */
- if (m_currentHistoryAmount < m_historyAmount) {
- ++m_currentHistoryAmount;
- ++m_tempContourIndex;
- m_movingHistory.push_back(contour);
+ if (__currentHistoryAmount < __historyAmount) {
+ ++__currentHistoryAmount;
+ ++__tempContourIndex;
+ __movingHistory.push_back(contour);
LOGI("Not stabilized. Too short moving history.");
}
/* saving into moving history */
- m_movingHistory.pop_front();
- m_movingHistory.push_back(contour);
+ __movingHistory.pop_front();
+ __movingHistory.push_back(contour);
- if (!m_isPrepared) {
- m_lastStabilizedContour = m_movingHistory[m_historyAmount - 2];
+ if (!__isPrepared) {
+ __lastStabilizedContour = __movingHistory[__historyAmount - 2];
LOGI("Not stabilized. Too small moving history. (the last one)");
- m_isPrepared = true;
+ __isPrepared = true;
}
/* stabilization */
stabilizedState = computeStabilizedQuadrangleContour();
if (stabilizedState.empty())
- stabilizedState = m_lastStabilizedContour;
+ stabilizedState = __lastStabilizedContour;
} else {
- stabilizedState = m_lastStabilizedContour;
+ stabilizedState = __lastStabilizedContour;
}
const float tolerantShift = getQuadrangleArea(contour.data()) *
- m_tolerantShift + m_tolerantShiftExtra;
+ __tolerantShift + __tolerantShiftExtra;
const size_t contourSize = stabilizedState.size();
for (size_t i = 0u; i < contourSize; ++i) {
if (fabs(getDistance(stabilizedState[i], contour[i])) > tolerantShift) {
- const float dirX = m_lastStabilizedContour[i].x - contour[i].x;
- const float dirY = m_lastStabilizedContour[i].y - contour[i].y;
+ const float dirX = __lastStabilizedContour[i].x - contour[i].x;
+ const float dirY = __lastStabilizedContour[i].y - contour[i].y;
- const float speedX = dirX * m_speeds[m_currentCornersSpeed[i]];
- const float speedY = dirY * m_speeds[m_currentCornersSpeed[i]];
+ const float speedX = dirX * __speeds[__currentCornersSpeed[i]];
+ const float speedY = dirY * __speeds[__currentCornersSpeed[i]];
/* final moving */
- m_lastStabilizedContour[i].x -= speedX;
- m_lastStabilizedContour[i].y -= speedY;
+ __lastStabilizedContour[i].x -= speedX;
+ __lastStabilizedContour[i].y -= speedY;
- if (m_currentCornersSpeed[i] < m_speeds.size() - 1) {
- ++m_currentCornersSpeed[i];
- }
+ if (__currentCornersSpeed[i] < __speeds.size() - 1)
+ ++__currentCornersSpeed[i];
} else {
- m_currentCornersSpeed[i] = 0;
+ __currentCornersSpeed[i] = 0;
}
}
- /* m_lastStabilizedContour = stabilizedState; */
- contour = m_lastStabilizedContour;
+ /* __lastStabilizedContour = stabilizedState; */
+ contour = __lastStabilizedContour;
LOGI("Contour successfully stabilized.");
if (params.mHistoryAmount < 1)
return false;
- m_tolerantShift = (float)params.mTolerantShift;
- m_tolerantShiftExtra = (float)params.mTolerantShiftExtra;
+ __tolerantShift = (float)params.mTolerantShift;
+ __tolerantShiftExtra = (float)params.mTolerantShiftExtra;
- if (m_historyAmount != (size_t)params.mHistoryAmount) {
- m_historyAmount = (size_t)params.mHistoryAmount;
+ if (__historyAmount != (size_t)params.mHistoryAmount) {
+ __historyAmount = (size_t)params.mHistoryAmount;
- m_priorities.resize(m_historyAmount);
+ __priorities.resize(__historyAmount);
/* calculation of priorities for positions in the moving history */
- for (size_t i = 0u; i < m_historyAmount; ++i) {
+ for (size_t i = 0u; i < __historyAmount; ++i) {
/* linear dependence on the elapsed time */
- m_priorities[i] = ((i + 1) * 2.0f) /
- ((m_historyAmount + 1) * m_historyAmount);
+ __priorities[i] = ((i + 1) * 2.0f) /
+ ((__historyAmount + 1) * __historyAmount);
}
}
- while (m_historyAmount > (size_t)params.mHistoryAmount) {
- m_movingHistory.pop_front();
- --m_historyAmount;
+ while (__historyAmount > (size_t)params.mHistoryAmount) {
+ __movingHistory.pop_front();
+ --__historyAmount;
}
- if ((size_t)params.mHistoryAmount > m_historyAmount) {
+ if ((size_t)params.mHistoryAmount > __historyAmount) {
/* TODO: save current moving history */
- m_tempContourIndex = -1;
- m_historyAmount = (size_t)params.mHistoryAmount;
- m_movingHistory.clear();
+ __tempContourIndex = -1;
+ __historyAmount = (size_t)params.mHistoryAmount;
+ __movingHistory.clear();
}
bool speedIsValid = false;
- if (m_speeds.size() > 1) {
- const static float Epsilon = 0.0001f;
- if (fabs(m_speeds[0] - params.mStabilizationSpeed) < Epsilon &&
- fabs((m_speeds[1] - m_speeds[0]) -
- params.mStabilizationAcceleration) < Epsilon) {
- speedIsValid = true;
+ if (__speeds.size() > 1) {
+ const static float __EPSILON = 0.0001f;
+ if (fabs(__speeds[0] - params.mStabilizationSpeed) < __EPSILON &&
+ fabs((__speeds[1] - __speeds[0]) -
+ params.mStabilizationAcceleration) < __EPSILON) {
+ speedIsValid = true;
}
}
if (!speedIsValid) {
- m_speeds.clear();
+ __speeds.clear();
int speedsSize = (int)((1 - params.mStabilizationSpeed) /
params.mStabilizationAcceleration) + 1;
if (speedsSize < 1) {
- m_speeds.push_back(1.0f);
+ __speeds.push_back(1.0f);
} else {
- static const int MaxSpeedsSize = 25;
+ static const int MAX_SPEED_SIZE = 25;
- if (speedsSize > MaxSpeedsSize)
- speedsSize = MaxSpeedsSize;
+ if (speedsSize > MAX_SPEED_SIZE)
+ speedsSize = MAX_SPEED_SIZE;
float speed = std::max(0.f,
std::min((float)params.mStabilizationSpeed, 1.0f));
for (int i = 0; i < speedsSize; ++i) {
- m_speeds.push_back(speed);
+ __speeds.push_back(speed);
speed += params.mStabilizationAcceleration;
}
}
std::vector<cv::Point2f> directionsToLastPos(NumberOfQuadrangleCorners);
for (size_t j = 0u; j < NumberOfQuadrangleCorners; ++j) {
/* calculation the moving directions and computing average direction */
- std::vector<cv::Point2f> trackDirections(m_historyAmount - 1);
+ std::vector<cv::Point2f> trackDirections(__historyAmount - 1);
cv::Point2f averageDirections(0.f, 0.f);
- for (size_t i = 0u; i < m_historyAmount - 1; ++i) {
+ for (size_t i = 0u; i < __historyAmount - 1; ++i) {
averageDirections.x += (trackDirections[i].x =
- m_movingHistory[i+1][j].x - m_movingHistory[i][j].x) /
- (m_historyAmount - 1);
+ __movingHistory[i+1][j].x - __movingHistory[i][j].x) /
+ (__historyAmount - 1);
averageDirections.y += (trackDirections[i].y =
- m_movingHistory[i+1][j].y - m_movingHistory[i][j].y) /
- (m_historyAmount - 1);
+ __movingHistory[i+1][j].y - __movingHistory[i][j].y) /
+ (__historyAmount - 1);
}
/* calculation a deviations and select outlier */
- std::vector<float> directionDistances(m_historyAmount - 1);
+ std::vector<float> directionDistances(__historyAmount - 1);
float maxDistance = 0.f, prevMaxDistance = 0.f;
int idxWithMaxDistance = 0;
int numExpressiveDirection = -1;
- for (size_t i = 0u; i < m_historyAmount - 1; ++i) {
+ for (size_t i = 0u; i < __historyAmount - 1; ++i) {
directionDistances[i] = getDistance(
trackDirections[i],
averageDirections);
/* final direction computing */
float summPriority = 0.f;
- for (size_t i = 0u; i < m_historyAmount - 1; ++i) {
+ for (size_t i = 0u; i < __historyAmount - 1; ++i) {
if ((int)i != numExpressiveDirection) {
- directions[j].x += trackDirections[i].x * m_priorities[i];
- directions[j].y += trackDirections[i].y * m_priorities[i];
- summPriority += m_priorities[i];
+ directions[j].x += trackDirections[i].x * __priorities[i];
+ directions[j].y += trackDirections[i].y * __priorities[i];
+ summPriority += __priorities[i];
}
}
- if (numExpressiveDirection == (int)(m_historyAmount - 1))
+ if (numExpressiveDirection == (int)(__historyAmount - 1))
expressiveTime = true;
summPriorityWithoutToLastPos[j] = summPriority;
- priorityToLastPos[j] = m_priorities[m_historyAmount - 1];
+ priorityToLastPos[j] = __priorities[__historyAmount - 1];
directions[j].x -= directionsToLastPos[j].x =
- (m_lastStabilizedContour[j].x -
- m_movingHistory[m_historyAmount - 1][j].x) *
+ (__lastStabilizedContour[j].x -
+ __movingHistory[__historyAmount - 1][j].x) *
priorityToLastPos[j];
directions[j].y -= directionsToLastPos[j].y =
- (m_lastStabilizedContour[j].y -
- m_movingHistory[m_historyAmount - 1][j].y) *
+ (__lastStabilizedContour[j].y -
+ __movingHistory[__historyAmount - 1][j].y) *
priorityToLastPos[j];
summPriority += priorityToLastPos[j];
directions[j].y /= summPriorityWithoutToLastPos[j];
}
- stabilizedState[j].x = m_lastStabilizedContour[j].x + directions[j].x;
- stabilizedState[j].y = m_lastStabilizedContour[j].y + directions[j].y;
+ stabilizedState[j].x = __lastStabilizedContour[j].x + directions[j].x;
+ stabilizedState[j].y = __lastStabilizedContour[j].y + directions[j].y;
}
return stabilizedState;
#include <fstream>
#include <unistd.h>
+#include <new>
namespace MediaVision {
namespace Image {
+
ImageTrackingModel::ImageTrackingModel() :
- m_target(),
- m_tracker(),
- m_stabilizator(),
- m_location(),
- m_stabilizationParams()
+ __target(),
+ __tracker(),
+ __stabilizator(),
+ __location(),
+ __stabilizationParams()
{
; /* NULL */
}
ImageTrackingModel::ImageTrackingModel(const ImageTrackingModel& copy) :
- m_target(copy.m_target),
- m_tracker(copy.m_tracker.empty()? NULL: copy.m_tracker->clone()),
- m_stabilizator(copy.m_stabilizator),
- m_location(copy.m_location),
- m_stabilizationParams(copy.m_stabilizationParams)
+ __target(copy.__target),
+ __tracker(copy.__tracker.empty()? NULL: copy.__tracker->clone()),
+ __stabilizator(copy.__stabilizator),
+ __location(copy.__location),
+ __stabilizationParams(copy.__stabilizationParams)
{
; /* NULL */
}
/* Parameters of stabilization */
- m_stabilizationParams.mIsEnabled = true;
- m_stabilizationParams.mHistoryAmount = 3;
- m_stabilizationParams.mTolerantShift = 0.00006;
- m_stabilizationParams.mTolerantShiftExtra = 1.3;
- m_stabilizationParams.mStabilizationSpeed = 0.3;
- m_stabilizationParams.mStabilizationAcceleration = 0.1;
+ __stabilizationParams.mIsEnabled = true;
+ __stabilizationParams.mHistoryAmount = 3;
+ __stabilizationParams.mTolerantShift = 0.00006;
+ __stabilizationParams.mTolerantShiftExtra = 1.3;
+ __stabilizationParams.mStabilizationSpeed = 0.3;
+ __stabilizationParams.mStabilizationAcceleration = 0.1;
/* Parameters definition is finished */
/* Creating a basic tracker which will have other trackers */
- cv::Ptr<CascadeTracker> mainTracker = new CascadeTracker;
+ cv::Ptr<CascadeTracker> mainTracker = new (std::nothrow)CascadeTracker;
+ if (mainTracker == NULL)
+ LOGE("Failed to create mainTracker");
/* Adding asynchronous recognition based tracker */
cv::Ptr<RecognitionBasedTracker> recogTracker =
- new RecognitionBasedTracker(
+ new (std::nothrow)RecognitionBasedTracker(
target,
orbFeatureExtractingParams,
orbRecogParams);
+ if (recogTracker == NULL)
+ LOGE("Failed to create Recognition Tracker");
cv::Ptr<AsyncTracker> asyncRecogTracker =
- new AsyncTracker(
+ new (std::nothrow)AsyncTracker(
recogTracker,
true);
+ if (asyncRecogTracker == NULL)
+ LOGE("Failed to create Async Recognition Tracker");
mainTracker->enableTracker(
asyncRecogTracker,
/* Adding asynchronous feature substitution based tracker */
cv::Ptr<FeatureSubstitutionTracker> substitutionTracker =
- new FeatureSubstitutionTracker(
+ new (std::nothrow)FeatureSubstitutionTracker(
gfttWbriefFeatureExtractingParams,
gfttWbriefRecogParams,
expectedOffset);
+ if (substitutionTracker == NULL)
+ LOGE("Failed to create Substitution Tracker");
cv::Ptr<AsyncTracker> asyncSubstitutionTracker =
- new AsyncTracker(
+ new (std::nothrow)AsyncTracker(
substitutionTracker,
true);
+ if (asyncSubstitutionTracker == NULL)
+ LOGE("Failed to create Async Substitution Tracker");
mainTracker->enableTracker(
asyncSubstitutionTracker,
/* Adding median flow tracker */
- cv::Ptr<MFTracker> mfTracker = new MFTracker(medianflowTrackingParams);
+ cv::Ptr<MFTracker> mfTracker = new (std::nothrow)MFTracker(
+ medianflowTrackingParams);
+ if (mfTracker == NULL)
+ LOGE("Failed to create MFTracker");
mainTracker->enableTracker(
mfTracker,
medianFlowTrackerPriotity);
- m_tracker = mainTracker;
- m_target = target;
+ __tracker = mainTracker;
+ __target = target;
}
bool ImageTrackingModel::isValid() const
{
- return !(m_target.isEmpty());
+ return !(__target.isEmpty());
}
bool ImageTrackingModel::track(const cv::Mat& frame, std::vector<cv::Point>& result)
{
result.clear();
- if (m_tracker.empty())
+ if (__tracker.empty())
return false;
- if (!(m_tracker->track(frame, m_location))) {
- m_stabilizator.reset();
+ if (!(__tracker->track(frame, __location))) {
+ __stabilizator.reset();
return false;
}
- const size_t numberOfContourPoints = m_location.size();
+ const size_t numberOfContourPoints = __location.size();
std::vector<cv::Point2f> stabilizedContour(numberOfContourPoints);
for (size_t i = 0; i < numberOfContourPoints; ++i) {
- stabilizedContour[i].x = (float)m_location[i].x;
- stabilizedContour[i].y = (float)m_location[i].y;
+ stabilizedContour[i].x = (float)__location[i].x;
+ stabilizedContour[i].y = (float)__location[i].y;
}
- m_stabilizator.stabilize(stabilizedContour, m_stabilizationParams);
+ __stabilizator.stabilize(stabilizedContour, __stabilizationParams);
for (size_t i = 0; i < numberOfContourPoints; ++i) {
- m_location[i].x = (int)stabilizedContour[i].x;
- m_location[i].y = (int)stabilizedContour[i].y;
+ __location[i].x = (int)stabilizedContour[i].x;
+ __location[i].y = (int)stabilizedContour[i].y;
}
- result = m_location;
+ result = __location;
return true;
}
void ImageTrackingModel::refresh(void)
{
- m_location.clear();
+ __location.clear();
}
ImageTrackingModel& ImageTrackingModel::operator=(const ImageTrackingModel& copy)
{
if (this != ©) {
- m_target = copy.m_target;
- if (!copy.m_tracker.empty())
- m_tracker = copy.m_tracker->clone();
+ __target = copy.__target;
+ if (!copy.__tracker.empty())
+ __tracker = copy.__tracker->clone();
else
- m_tracker.release();
+ __tracker.release();
- m_stabilizator = copy.m_stabilizator;
- m_location = copy.m_location;
- m_stabilizationParams = copy.m_stabilizationParams;
+ __stabilizator = copy.__stabilizator;
+ __location = copy.__location;
+ __stabilizationParams = copy.__stabilizationParams;
}
return *this;
{
os << std::setprecision(7);
- os << obj.m_target;
- os << obj.m_stabilizationParams.mIsEnabled << '\n';
- os << obj.m_stabilizationParams.mHistoryAmount << '\n';
- os << obj.m_stabilizationParams.mStabilizationSpeed << '\n';
- os << obj.m_stabilizationParams.mStabilizationAcceleration << '\n';
- os << obj.m_stabilizationParams.mTolerantShift << '\n';
- os << obj.m_stabilizationParams.mTolerantShiftExtra << '\n';
+ os << obj.__target;
+ os << obj.__stabilizationParams.mIsEnabled << '\n';
+ os << obj.__stabilizationParams.mHistoryAmount << '\n';
+ os << obj.__stabilizationParams.mStabilizationSpeed << '\n';
+ os << obj.__stabilizationParams.mStabilizationAcceleration << '\n';
+ os << obj.__stabilizationParams.mTolerantShift << '\n';
+ os << obj.__stabilizationParams.mTolerantShiftExtra << '\n';
- const size_t numberOfContourPoints = obj.m_location.size();
+ const size_t numberOfContourPoints = obj.__location.size();
os << numberOfContourPoints << '\n';
for (size_t pointNum = 0u; pointNum < numberOfContourPoints; ++pointNum)
- os << ' ' << obj.m_location[pointNum].x << ' ' << obj.m_location[pointNum].y;
+ os << ' ' << obj.__location[pointNum].x << ' ' << obj.__location[pointNum].y;
os << '\n';
std::istream& operator >> (std::istream& is, ImageTrackingModel& obj)
{
#define MEDIA_VISION_CHECK_IFSTREAM \
- if (!is.good()) { \
- return is; \
- }
+ if (!is.good()) \
+ return is;
ImageObject target;
std::vector<cv::Point> location;
#undef MEDIA_VISION_CHECK_IFSTREAM
- obj.m_stabilizationParams = params;
- obj.m_location = location;
+ obj.__stabilizationParams = params;
+ obj.__location = location;
if (!(target.isEmpty())) {
obj.setTarget(target);
- obj.m_tracker->reinforcement(location);
+ obj.__tracker->reinforcement(location);
}
return is;
namespace MediaVision {
namespace Image {
+
namespace {
- const float FloatEps = 10e-6f;
-
- template<typename T>
- T getMedian(std::vector<T>& values, int size = -1) {
- if (size == -1)
- size = (int)values.size();
-
- std::vector<T> copy(values.begin(), values.begin() + size);
- std::sort(copy.begin(), copy.end());
- if (size%2 == 0)
- return (copy[size/2-1]+copy[size/2])/((T)2.0);
- else
- return copy[(size - 1) / 2];
- }
+const float FLOATEPS = 10e-6f;
+
+template<typename T>
+T getMedian(std::vector<T>& values, int size = -1)
+{
+ if (size == -1)
+ size = (int)values.size();
- inline float l2distance(cv::Point2f p1, cv::Point2f p2) {
- const float dx = p1.x - p2.x;
- const float dy = p1.y - p2.y;
- return sqrtf(dx * dx + dy * dy);
+ std::vector<T> copy(values.begin(), values.begin() + size);
+ std::sort(copy.begin(), copy.end());
+ if (size%2 == 0) {
+ return (copy[size / 2 - 1] + copy[size/2]) / ((T)2.0);
+ } else {
+ return copy[(size - 1) / 2];
}
+}
+
+inline float l2distance(cv::Point2f p1, cv::Point2f p2)
+{
+ const float dx = p1.x - p2.x;
+ const float dy = p1.y - p2.y;
+ return sqrtf(dx * dx + dy * dy);
+}
} /* anonymous namespace */
MFTracker::Params::Params()
}
MFTracker::MFTracker(Params params) :
- m_isInit(false),
- m_params(params),
- m_termcrit(cv::TermCriteria::COUNT | cv::TermCriteria::EPS, 20, 0.3),
- m_confidence(0.0f)
+ __isInit(false),
+ __params(params),
+ __termcrit(cv::TermCriteria::COUNT | cv::TermCriteria::EPS, 20, 0.3),
+ __confidence(0.0f)
{
}
{
result.clear();
- if (!m_isInit) {
- if (m_startLocation.empty())
+ if (!__isInit) {
+ if (__startLocation.empty())
return false;
if (!init(frame))
return false;
} else {
if (!update(frame)) {
- m_isInit = false;
- m_startLocation.clear();
+ __isInit = false;
+ __startLocation.clear();
return false;
}
}
- const size_t numberOfContourPoints = m_startLocation.size();
+ const size_t numberOfContourPoints = __startLocation.size();
result.resize(numberOfContourPoints);
for (size_t i = 0; i < numberOfContourPoints; ++i) {
- result[i].x = (int)(m_boundingBox.x +
- m_startLocation[i].x * m_boundingBox.width);
- result[i].y = (int)(m_boundingBox.y +
- m_startLocation[i].y * m_boundingBox.height);
+ result[i].x = static_cast<int>(__boundingBox.x +
+ __startLocation[i].x * __boundingBox.width);
+ result[i].y = static_cast<int>(__boundingBox.y +
+ __startLocation[i].y * __boundingBox.height);
}
return true;
void MFTracker::reinforcement(const std::vector<cv::Point>& location)
{
- m_isInit = false;
+ __isInit = false;
if (location.size() < 3) {
- m_startLocation.clear();
- m_boundingBox.x = 0;
- m_boundingBox.y = 0;
- m_boundingBox.width = 0;
- m_boundingBox.height = 0;
+ __startLocation.clear();
+ __boundingBox.x = 0;
+ __boundingBox.y = 0;
+ __boundingBox.width = 0;
+ __boundingBox.height = 0;
return;
}
const cv::Rect_<float>& boundingBox = cv::boundingRect(location);
- m_boundingBox = boundingBox;
+ __boundingBox = boundingBox;
const size_t numberOfContourPoints = location.size();
- m_startLocation.resize(numberOfContourPoints);
+ __startLocation.resize(numberOfContourPoints);
for (size_t i = 0; i < numberOfContourPoints; ++i) {
- m_startLocation[i].x = (location[i].x - boundingBox.x) / boundingBox.width;
- m_startLocation[i].y = (location[i].y - boundingBox.y) / boundingBox.height;
+ __startLocation[i].x = (location[i].x - boundingBox.x) / boundingBox.width;
+ __startLocation[i].y = (location[i].y - boundingBox.y) / boundingBox.height;
}
}
cv::Ptr<ObjectTracker> MFTracker::clone() const
{
- return cv::Ptr<ObjectTracker>(new MFTracker(*this));
+ return cv::Ptr<ObjectTracker>(new (std::nothrow)MFTracker(*this));
}
bool MFTracker::init(const cv::Mat& image)
if (image.empty())
return false;
- image.copyTo(m_image);
+ image.copyTo(__image);
buildOpticalFlowPyramid(
- m_image,
- m_pyramid,
- m_params.mWindowSize,
- m_params.mPyrMaxLevel);
+ __image,
+ __pyramid,
+ __params.mWindowSize,
+ __params.mPyrMaxLevel);
- m_isInit = true;
- return m_isInit;
+ __isInit = true;
+ return __isInit;
}
bool MFTracker::update(const cv::Mat& image)
{
- if (!m_isInit || image.empty())
+ if (!__isInit || image.empty())
return false;
/* Handles such behaviour when preparation frame has the size
* different to the tracking frame size. In such case, we resize preparation
*frame and bounding box. Then, track as usually:
*/
- if (m_image.rows != image.rows || m_image.cols != image.cols) {
- const float xFactor = (float) image.cols / m_image.cols;
- const float yFactor = (float) image.rows / m_image.rows;
+ if (__image.rows != image.rows || __image.cols != image.cols) {
+ const float xFactor = static_cast<float>(image.cols) / __image.cols;
+ const float yFactor = static_cast<float>(image.rows) / __image.rows;
- resize(m_image, m_image, cv::Size(), xFactor, yFactor);
+ resize(__image, __image, cv::Size(), xFactor, yFactor);
- m_boundingBox.x *= xFactor;
- m_boundingBox.y *= yFactor;
- m_boundingBox.width *= xFactor;
- m_boundingBox.height *= yFactor;
+ __boundingBox.x *= xFactor;
+ __boundingBox.y *= yFactor;
+ __boundingBox.width *= xFactor;
+ __boundingBox.height *= yFactor;
}
- cv::Mat oldImage = m_image;
+ cv::Mat oldImage = __image;
- cv::Rect_<float> oldBox = m_boundingBox;
+ cv::Rect_<float> oldBox = __boundingBox;
if (!medianFlowImpl(oldImage, image, oldBox))
return false;
- image.copyTo(m_image);
- m_boundingBox = oldBox;
+ image.copyTo(__image);
+ __boundingBox = oldBox;
return true;
}
bool MFTracker::isInited() const
{
- return m_isInit;
+ return __isInit;
}
float MFTracker::getLastConfidence() const
{
- return m_confidence;
+ return __confidence;
}
cv::Rect_<float> MFTracker::getLastBoundingBox() const
{
- return m_boundingBox;
+ return __boundingBox;
}
bool MFTracker::medianFlowImpl(
{
std::vector<cv::Point2f> pointsToTrackOld, pointsToTrackNew;
- const float gridXStep = oldBox.width / m_params.mPointsInGrid;
- const float gridYStep = oldBox.height / m_params.mPointsInGrid;
- for (int i = 0; i < m_params.mPointsInGrid; i++) {
- for (int j = 0; j < m_params.mPointsInGrid; j++) {
+ const float gridXStep = oldBox.width / __params.mPointsInGrid;
+ const float gridYStep = oldBox.height / __params.mPointsInGrid;
+ for (int i = 0; i < __params.mPointsInGrid; i++)
+ for (int j = 0; j < __params.mPointsInGrid; j++)
pointsToTrackOld.push_back(
cv::Point2f(oldBox.x + .5f*gridXStep + 1.f*gridXStep*j,
oldBox.y + .5f*gridYStep + 1.f*gridYStep*i));
- }
- }
const size_t numberOfPointsToTrackOld = pointsToTrackOld.size();
std::vector<uchar> status(numberOfPointsToTrackOld);
cv::buildOpticalFlowPyramid(
newImage_gray,
tempPyramid,
- m_params.mWindowSize,
- m_params.mPyrMaxLevel);
+ __params.mWindowSize,
+ __params.mPyrMaxLevel);
- cv::calcOpticalFlowPyrLK(m_pyramid,
+ cv::calcOpticalFlowPyrLK(__pyramid,
tempPyramid,
pointsToTrackOld,
pointsToTrackNew,
status,
errors,
- m_params.mWindowSize,
- m_params.mPyrMaxLevel,
- m_termcrit);
+ __params.mWindowSize,
+ __params.mPyrMaxLevel,
+ __termcrit);
std::vector<cv::Point2f> di;
- for (size_t idx = 0u; idx < numberOfPointsToTrackOld; idx++) {
+ for (size_t idx = 0u; idx < numberOfPointsToTrackOld; idx++)
if (status[idx] == 1)
di.push_back(pointsToTrackNew[idx] - pointsToTrackOld[idx]);
- }
std::vector<bool> filter_status;
check_FB(tempPyramid,
displacements.push_back(sqrt(di[idx].ddot(di[idx])));
}
- m_confidence = (10.f - getMedian(displacements, (int)displacements.size())) / 10.f;
+ __confidence =
+ (10.f - getMedian(displacements, static_cast<int>(displacements.size()))) / 10.f;
- if (m_confidence < 0.f) {
- m_confidence = 0.f;
+ if (__confidence < 0.f) {
+ __confidence = 0.f;
return false;
}
- m_pyramid.swap(tempPyramid);
+ __pyramid.swap(tempPyramid);
oldBox = boxCandidate;
return true;
}
std::vector<cv::Point2f> pointsToTrackReprojection;
calcOpticalFlowPyrLK(newPyramid,
- m_pyramid,
+ __pyramid,
newPoints,
pointsToTrackReprojection,
LKstatus,
errors,
- m_params.mWindowSize,
- m_params.mPyrMaxLevel,
- m_termcrit);
+ __params.mWindowSize,
+ __params.mPyrMaxLevel,
+ __termcrit);
for (size_t idx = 0u; idx < numberOfOldPoints; idx++)
FBerror[idx] = l2distance(oldPoints[idx], pointsToTrackReprojection[idx]);
- float FBerrorMedian = getMedian(FBerror) + FloatEps;
+ float FBerrorMedian = getMedian(FBerror) + FLOATEPS;
for (size_t idx = 0u; idx < numberOfOldPoints; idx++)
status[idx] = (FBerror[idx] < FBerrorMedian);
}
NCC[idx] = (sq2 == 0 ? sq1 / std::abs(sq1) : (prod - s1 * s2 / N) / sq1 / sq2);
}
- float median = getMedian(NCC) - FloatEps;
+ float median = getMedian(NCC) - FLOATEPS;
for (size_t idx = 0u; idx < oldPoints.size(); idx++)
status[idx] = status[idx] && (NCC[idx] > median);
}
#include "Recognition/ImageRecognizer.h"
+#include <new>
+
namespace MediaVision {
namespace Image {
+
RecognitionBasedTracker::RecognitionBasedTracker(
const ImageObject& target,
const FeaturesExtractingParams& sceneFeaturesExtractingParams,
const RecognitionParams& recognitionParams) :
- m_target(target),
- m_sceneFeatureExtractingParams(sceneFeaturesExtractingParams),
- m_recogParams(recognitionParams)
+ __target(target),
+ __sceneFeatureExtractingParams(sceneFeaturesExtractingParams),
+ __recogParams(recognitionParams)
{
; /* NULL */
}
{
result.clear();
- ImageObject scene(frame, m_sceneFeatureExtractingParams);
+ ImageObject scene(frame, __sceneFeatureExtractingParams);
ImageRecognizer recognizer(scene);
std::vector<cv::Point2f> contour;
- bool isRecognized = recognizer.recognize(m_target, m_recogParams, contour);
+ bool isRecognized = recognizer.recognize(__target, __recogParams, contour);
if (isRecognized) {
size_t numberOfContourPoints = contour.size();
result.resize(numberOfContourPoints);
- for(size_t i = 0u; i < numberOfContourPoints; ++i) {
+ for (size_t i = 0u; i < numberOfContourPoints; ++i) {
result[i].x = (int)contour[i].x;
result[i].y = (int)contour[i].y;
}
return isRecognized;
}
-void RecognitionBasedTracker::reinforcement(const std::vector<cv::Point>& location)
+void RecognitionBasedTracker::reinforcement(const std::vector<cv::Point>& /*location*/)
{
; /* The tracker is based on the recognition on the entire image.
- *The reinforcement does not make a sense.*/
+ * The reinforcement does not make a sense.*/
}
cv::Ptr<ObjectTracker> RecognitionBasedTracker::clone() const
{
- return cv::Ptr<ObjectTracker>(new RecognitionBasedTracker(*this));
+ return cv::Ptr<ObjectTracker>(new (std::nothrow)RecognitionBasedTracker(*this));
}
} /* Image */
#include <opencv/cv.h>
namespace {
+
class DefaultConfiguration {
public:
static const DefaultConfiguration& getInstance();
private:
static DefaultConfiguration instance;
- MediaVision::Image::FeaturesExtractingParams m_objectFeaturesExtractingParams;
+ MediaVision::Image::FeaturesExtractingParams __objectFeaturesExtractingParams;
- MediaVision::Image::FeaturesExtractingParams m_sceneFeaturesExtractingParams;
+ MediaVision::Image::FeaturesExtractingParams __sceneFeaturesExtractingParams;
- MediaVision::Image::RecognitionParams m_recognitionParams;
+ MediaVision::Image::RecognitionParams __recognitionParams;
- MediaVision::Image::StabilizationParams m_stabilizationParams;
+ MediaVision::Image::StabilizationParams __stabilizationParams;
- MediaVision::Image::TrackingParams m_trackingParams;
+ MediaVision::Image::TrackingParams __trackingParams;
};
DefaultConfiguration DefaultConfiguration::instance;
DefaultConfiguration::DefaultConfiguration() :
- m_objectFeaturesExtractingParams(),
- m_sceneFeaturesExtractingParams(),
- m_recognitionParams(15, 0.33, 0.1),
- m_stabilizationParams(true, 3, 0.00006, 1.3, 2, 0.001),
- m_trackingParams()
+ __objectFeaturesExtractingParams(),
+ __sceneFeaturesExtractingParams(),
+ __recognitionParams(15, 0.33, 0.1),
+ __stabilizationParams(true, 3, 0.00006, 1.3, 2, 0.001),
+ __trackingParams()
{
- m_objectFeaturesExtractingParams.mKeypointType = MediaVision::Image::KT_ORB;
- m_objectFeaturesExtractingParams.mDescriptorType = MediaVision::Image::DT_ORB;
- m_objectFeaturesExtractingParams.ORB.mScaleFactor = 1.2;
- m_objectFeaturesExtractingParams.ORB.mMaximumFeaturesNumber = 1000;
-
- m_sceneFeaturesExtractingParams.mKeypointType = MediaVision::Image::KT_ORB;
- m_sceneFeaturesExtractingParams.mDescriptorType = MediaVision::Image::DT_ORB;
- m_sceneFeaturesExtractingParams.ORB.mScaleFactor = 1.2;
- m_sceneFeaturesExtractingParams.ORB.mMaximumFeaturesNumber = 5000;
-
- m_trackingParams.mFramesFeaturesExtractingParams = m_sceneFeaturesExtractingParams;
- m_trackingParams.mRecognitionParams = m_recognitionParams;
- m_trackingParams.mStabilizationParams = m_stabilizationParams;
- m_trackingParams.mExpectedOffset = 0.0;
+ __objectFeaturesExtractingParams.mKeypointType = MediaVision::Image::KT_ORB;
+ __objectFeaturesExtractingParams.mDescriptorType = MediaVision::Image::DT_ORB;
+ __objectFeaturesExtractingParams.ORB.mScaleFactor = 1.2;
+ __objectFeaturesExtractingParams.ORB.mMaximumFeaturesNumber = 1000;
+
+ __sceneFeaturesExtractingParams.mKeypointType = MediaVision::Image::KT_ORB;
+ __sceneFeaturesExtractingParams.mDescriptorType = MediaVision::Image::DT_ORB;
+ __sceneFeaturesExtractingParams.ORB.mScaleFactor = 1.2;
+ __sceneFeaturesExtractingParams.ORB.mMaximumFeaturesNumber = 5000;
+
+ __trackingParams.mFramesFeaturesExtractingParams = __sceneFeaturesExtractingParams;
+ __trackingParams.mRecognitionParams = __recognitionParams;
+ __trackingParams.mStabilizationParams = __stabilizationParams;
+ __trackingParams.mExpectedOffset = 0.0;
}
const DefaultConfiguration& DefaultConfiguration::getInstance()
MediaVision::Image::FeaturesExtractingParams
DefaultConfiguration::getObjectFeaturesExtractingParams() const
{
- return m_objectFeaturesExtractingParams;
+ return __objectFeaturesExtractingParams;
}
MediaVision::Image::FeaturesExtractingParams
DefaultConfiguration::getSceneFeaturesExtractingParams() const
{
- return m_sceneFeaturesExtractingParams;
+ return __sceneFeaturesExtractingParams;
}
MediaVision::Image::RecognitionParams
DefaultConfiguration::getRecognitionParams() const
{
- return m_recognitionParams;
+ return __recognitionParams;
}
MediaVision::Image::StabilizationParams
DefaultConfiguration::getStabilizationParams() const
{
- return m_stabilizationParams;
+ return __stabilizationParams;
}
MediaVision::Image::TrackingParams
DefaultConfiguration::getTrackingParams() const
{
- return m_trackingParams;
+ return __trackingParams;
}
void extractTargetFeaturesExtractingParams(
MV_IMAGE_RECOGNITION_OBJECT_MAX_KEYPOINTS_NUM,
&featuresExtractingParams.ORB.mMaximumFeaturesNumber);
- if (NULL == engine_cfg) {
+ if (NULL == engine_cfg)
mv_destroy_engine_config(working_cfg);
- }
}
void extractSceneFeaturesExtractingParams(
MV_IMAGE_RECOGNITION_SCENE_MAX_KEYPOINTS_NUM,
&featuresExtractingParams.ORB.mMaximumFeaturesNumber);
- if (NULL == engine_cfg) {
+ if (NULL == engine_cfg)
mv_destroy_engine_config(working_cfg);
- }
}
void extractRecognitionParams(
MV_IMAGE_RECOGNITION_TOLERANT_MATCH_PART_ERR,
&recognitionParams.mTolerantMatchesPartError);
- if (NULL == engine_cfg) {
+ if (NULL == engine_cfg)
mv_destroy_engine_config(working_cfg);
- }
}
void extractStabilizationParams(
MV_IMAGE_TRACKING_STABLIZATION_ACCELERATION,
&stabilizationParams.mStabilizationAcceleration);
- if (NULL == engine_cfg) {
+ if (NULL == engine_cfg)
mv_destroy_engine_config(working_cfg);
- }
}
void extractTrackingParams(
MV_IMAGE_TRACKING_EXPECTED_OFFSET,
&trackingParams.mExpectedOffset);
- if (NULL == engine_cfg) {
+ if (NULL == engine_cfg)
mv_destroy_engine_config(working_cfg);
- }
}
int convertSourceMV2GrayCV(mv_source_h mvSource, cv::Mat& cvSource)
{
MEDIA_VISION_INSTANCE_CHECK(source);
MEDIA_VISION_NULL_ARG_CHECK(image_objects);
- for (int objectNum = 0; objectNum < number_of_objects; ++objectNum) {
+ for (int objectNum = 0; objectNum < number_of_objects; ++objectNum)
MEDIA_VISION_INSTANCE_CHECK(image_objects[objectNum]);
- }
MEDIA_VISION_NULL_ARG_CHECK(recognized_cb);
cv::Mat scene;
MEDIA_VISION_NULL_ARG_CHECK(image_object);
(*image_object) = (mv_image_object_h)new (std::nothrow)MediaVision::Image::ImageObject();
- if (*image_object == NULL) {
+ if (*image_object == NULL)
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
- }
return MEDIA_VISION_ERROR_NONE;
}
MEDIA_VISION_NULL_ARG_CHECK(dst);
(*dst) = (mv_image_object_h)new (std::nothrow)MediaVision::Image::ImageObject();
- if (*dst == NULL) {
+ if (*dst == NULL)
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
- }
*(MediaVision::Image::ImageObject*)(*dst) =
*(MediaVision::Image::ImageObject*)src;
}
(*image_object) = (mv_image_object_h)new (std::nothrow)MediaVision::Image::ImageObject();
- if (*image_object == NULL) {
+ if (*image_object == NULL)
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
- }
int ret = ((MediaVision::Image::ImageObject*)(*image_object))->load(file_name);
if (ret != MEDIA_VISION_ERROR_NONE) {
(*image_tracking_model) = (mv_image_tracking_model_h)
new (std::nothrow)MediaVision::Image::ImageTrackingModel();
- if (*image_tracking_model == NULL) {
+ if (*image_tracking_model == NULL)
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
- }
return MEDIA_VISION_ERROR_NONE;
}
(*image_tracking_model) = (mv_image_tracking_model_h)
new (std::nothrow)MediaVision::Image::ImageTrackingModel();
- if (*image_tracking_model == NULL) {
+ if (*image_tracking_model == NULL)
return MEDIA_VISION_ERROR_OUT_OF_MEMORY;
- }
int ret = ((MediaVision::Image::ImageTrackingModel*)(*image_tracking_model))->load(file_name);
if (ret != MEDIA_VISION_ERROR_NONE) {
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_IMAGE_LIC_H__
-#define __TIZEN_MEDIAVISION_IMAGE_LIC_H__
+#ifndef __MEDIA_VISION_IMAGE_LIC_H__
+#define __MEDIA_VISION_IMAGE_LIC_H__
#include "mv_image.h"
* @see mv_engine_config_h
*/
int mv_image_recognize_lic(
- mv_source_h source,
- const mv_image_object_h *image_objects,
- int number_of_objects,
- mv_engine_config_h engine_cfg,
- mv_image_recognized_cb recognized_cb,
- void *user_data);
+ mv_source_h source,
+ const mv_image_object_h *image_objects,
+ int number_of_objects,
+ mv_engine_config_h engine_cfg,
+ mv_image_recognized_cb recognized_cb,
+ void *user_data);
/*************************/
/* Image object tracking */
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_track_lic(
- mv_source_h source,
- mv_image_tracking_model_h image_tracking_model,
- mv_engine_config_h engine_cfg,
- mv_image_tracked_cb tracked_cb,
- void *user_data);
+ mv_source_h source,
+ mv_image_tracking_model_h image_tracking_model,
+ mv_engine_config_h engine_cfg,
+ mv_image_tracked_cb tracked_cb,
+ void *user_data);
/**************************/
/* Image object behaviour */
* @see mv_image_object_destroy_lic()
*/
int mv_image_object_create_lic(
- mv_image_object_h *image_object);
+ mv_image_object_h *image_object);
/**
* @brief Destroys the image object.
* @see mv_image_object_create_lic()
*/
int mv_image_object_destroy_lic(
- mv_image_object_h image_object);
+ mv_image_object_h image_object);
/**
* @brief Fills the image object.
* @see mv_engine_config_h
*/
int mv_image_object_fill_lic(
- mv_image_object_h image_object,
- mv_engine_config_h engine_cfg,
- mv_source_h source,
- mv_rectangle_s *location);
+ mv_image_object_h image_object,
+ mv_engine_config_h engine_cfg,
+ mv_source_h source,
+ mv_rectangle_s *location);
/**
* @brief Gets a value that determines how well an image object can be recognized.
* @see mv_engine_config_h
*/
int mv_image_object_get_recognition_rate_lic(
- mv_image_object_h image_object,
- double *recognition_rate);
+ mv_image_object_h image_object,
+ double *recognition_rate);
/**
* @brief Sets a label for the image object.
* @see mv_image_object_destroy_lic()
*/
int mv_image_object_set_label_lic(
- mv_image_object_h image_object,
- int label);
+ mv_image_object_h image_object,
+ int label);
/**
* @brief Gets a label of image object.
* @see mv_image_object_destroy_lic()
*/
int mv_image_object_get_label_lic(
- mv_image_object_h image_object,
- int *label);
+ mv_image_object_h image_object,
+ int *label);
/**
* @brief Clones the image object.
* @see mv_image_object_destroy_lic()
*/
int mv_image_object_clone_lic(
- mv_image_object_h src,
- mv_image_object_h *dst);
+ mv_image_object_h src,
+ mv_image_object_h *dst);
/**
* @brief Saves the image object.
* @see mv_image_object_destroy_lic()
*/
int mv_image_object_save_lic(
- const char *file_name, mv_image_object_h image_object);
+ const char *file_name,
+ mv_image_object_h image_object);
/**
* @brief Loads an image object from the file.
* @see mv_image_object_destroy_lic()
*/
int mv_image_object_load_lic(
- const char *file_name, mv_image_object_h image_object);
+ const char *file_name,
+ mv_image_object_h *image_object);
/**********************************/
/* Image tracking model behaviour */
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_tracking_model_create_lic(
- mv_image_tracking_model_h *image_tracking_model);
+ mv_image_tracking_model_h *image_tracking_model);
/**
* @brief Sets target of image tracking model.
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_tracking_model_set_target_lic(
- mv_image_object_h image_object,
- mv_image_tracking_model_h image_tracking_model);
+ mv_image_object_h image_object,
+ mv_image_tracking_model_h image_tracking_model);
/**
* @brief Destroys the image tracking model.
* @see mv_image_tracking_model_create_lic()
*/
int mv_image_tracking_model_destroy_lic(
- mv_image_tracking_model_h image_tracking_model);
+ mv_image_tracking_model_h image_tracking_model);
/**
* @brief Refreshes the state of image tracking model.
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_tracking_model_refresh_lic(
- mv_image_tracking_model_h image_tracking_model,
- mv_engine_config_h engine_cfg);
+ mv_image_tracking_model_h image_tracking_model,
+ mv_engine_config_h engine_cfg);
/**
* @brief Clones the image tracking model.
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_tracking_model_clone_lic(
- mv_image_tracking_model_h src,
- mv_image_tracking_model_h *dst);
+ mv_image_tracking_model_h src,
+ mv_image_tracking_model_h *dst);
/**
* @brief Saves the image tracking model.
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_tracking_model_save_lic(
- const char *file_name, mv_image_tracking_model_h image_tracking_model);
+ const char *file_name,
+ mv_image_tracking_model_h image_tracking_model);
/**
* @brief Loads an image tracking model from the file.
* @see mv_image_tracking_model_destroy_lic()
*/
int mv_image_tracking_model_load_lic(
- const char *file_name, mv_image_tracking_model_h *image_tracking_model);
+ const char *file_name,
+ mv_image_tracking_model_h *image_tracking_model);
#ifdef __cplusplus
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_IMAGE_LIC_H__ */
+#endif /* __MEDIA_VISION_IMAGE_LIC_H__ */
}
int mv_image_object_save_lic(
- mv_image_object_h image_object,
- const char *file_name)
+ const char *file_name,
+ mv_image_object_h image_object)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
int mv_image_object_load_lic(
- mv_image_object_h image_object,
- const char *file_name)
+ const char *file_name,
+ mv_image_object_h image_object)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
}
int mv_image_tracking_model_save_lic(
- mv_image_tracking_model_h image_tracking_model,
- const char *file_name)
+ const char *file_name,
+ mv_image_tracking_model_h image_tracking_model)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
int mv_image_tracking_model_load_lic(
- mv_image_tracking_model_h image_tracking_model,
- const char *file_name)
+ const char *file_name,
+ mv_image_tracking_model_h *image_tracking_model)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
*/
class EventManagerDestroyer {
public:
+
/**
* @brief Default destructor.
*
void initialize(EventManager *pointer);
private:
+
EventManager *__pInstance;
};
class EventManager {
public:
+
/**
* @brief Gets EventManager instance.
*
* @param [in] user_data The user data to be passed to the callback function
* @param [in] numberOfPoints The number of ROI points
* @param [in] roi The intput array with ROI points
+ * @param [in] isInternal Interpretation event as internal in surveillance
* @return @c 0 on success, otherwise a negative error value
*/
int registerEvent(
mv_surveillance_event_occurred_cb callback,
void *user_data,
int numberOfPoints,
- mv_point_s *roi);
+ mv_point_s *roi,
+ bool isInternal);
/**
* @brief Unregisters event.
StringVector& eventResValNames);
private:
+
EventManager();
EventManager(const EventManager&);
friend class EventManagerDestroyer;
private:
+
static EventManager *__pInstance;
static EventManagerDestroyer Destroyer;
static EventTypesMap SupportedEventTypes;
private:
+
EventTriggersMap __eventTriggers;
};
* @param [in] user_data The user data to be passed to the callback function
* @param [in] numberOfPoints The number of ROI points
* @param [in] roi The intput array with ROI points
+ * @param [in] isInternal Interpretation event as internal in surveillance
*/
EventTrigger(
mv_surveillance_event_trigger_h eventTrigger,
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi);
+ mv_point_s *roi,
+ bool isInternal);
/**
* @brief Default destructor.
* @param [in] user_data The user data to be passed to the callback function
* @param [in] numberOfPoints The number of ROI points
* @param [in] roi The intput array with ROI points
+ * @param [in] isInternal Interpretation event as internal in surveillance
* @return @c true on success, false otherwise
*/
bool subscribeCallback(
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi);
+ mv_point_s *roi,
+ bool isInternal);
/**
* @brief Unsubscibes callback with unique identifier.
mv_surveillance_event_occurred_cb callback;
void *userData;
+
+ bool isInternal;
};
typedef std::map<long int, CallbackData> CallbackDataMap;
* @param [in] user_data The user data to be passed to the callback function
* @param [in] numberOfPoints The number of ROI points
* @param [in] roi The intput array with ROI points
+ * @param [in] isInternal Interpretation event as internal in surveillance
*/
EventTriggerMovementDetection(
mv_surveillance_event_trigger_h eventTrigger,
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi);
+ mv_point_s *roi,
+ bool isInternal);
/**
* @brief Default destructor.
*/
#include "EventTrigger.h"
+#include "MFTracker.h"
#include "EventResult.h"
#include "EventDefs.h"
#include <opencv/cv.h>
+#include <sys/time.h>
+
namespace mediavision {
namespace surveillance {
* @param [in] user_data The user data to be passed to the callback function
* @param [in] numberOfPoints The number of ROI points
* @param [in] roi The intput array with ROI points
+ * @param [in] isInternal Interpretation event as internal in surveillance
*/
EventTriggerPersonAppearance(
mv_surveillance_event_trigger_h eventTrigger,
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi);
+ mv_point_s *roi,
+ bool isInternal);
/**
* @brief Default destructor.
void *user_data);
private:
+
void runCallbacks(mv_source_h source);
+ std::vector<bool> reinforceTrackedPersons(const CVRectangles& appearedPersons);
+
private:
- struct TrackedRectangle {
- cv::Rect rect;
- int framesCount;
+ class TrackedRectangle {
+ public:
+ TrackedRectangle(cv::Rect _rect, struct timeval _appearanceTime);
+
+ cv::Rect_<float> rect;
+
+ struct timeval appearanceTime;
- TrackedRectangle(cv::Rect _rect, int _framesCount)
- {
- rect = _rect;
- framesCount = _framesCount;
- }
+ MFTracker tracker;
};
typedef std::list<TrackedRectangle> TrackedRectangles;
* @param [in] user_data The user data to be passed to the callback function
* @param [in] numberOfPoints The number of ROI points
* @param [in] roi The intput array with ROI points
+ * @param [in] isInternal Interpretation event as internal in surveillance
*/
EventTriggerPersonRecognition(
mv_surveillance_event_trigger_h eventTrigger,
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi);
+ mv_point_s *roi,
+ bool isInternal);
/**
* @brief Default destructor.
enum { L2Hys = 0 };
enum { DEFAULT_NLEVELS = 64 };
- // default constructor
+ /* default constructor */
HOGDescriptor() :
winSize(64, 128),
blockSize(16, 16),
histogramNormType(HOGDescriptor::L2Hys),
L2HysThreshold(0.2),
gammaCorrection(true),
- nlevels(HOGDescriptor::DEFAULT_NLEVELS) {}
+ nlevels(HOGDescriptor::DEFAULT_NLEVELS)
+ {}
- // constructor
+ /* constructor */
HOGDescriptor(
Size _winSize,
Size _blockSize,
histogramNormType(_histogramNormType),
L2HysThreshold(_L2HysThreshold),
gammaCorrection(_gammaCorrection),
- nlevels(_nlevels) {}
+ nlevels(_nlevels)
+ {}
- // default destructor
+ /* default destructor */
virtual ~HOGDescriptor() {}
size_t getDescriptorSize() const;
Size padding = Size(),
const vector<Point>& locations = vector<Point>()) const;
- //with found weights output
+ /* with found weights output */
virtual void detect(
const Mat& img,
CV_OUT vector<Point>& foundLocations,
Size padding = Size(),
const vector<Point>& searchLocations = vector<Point>()) const;
- //without found weights output
+ /* without found weights output */
virtual void detect(
const Mat& img,
CV_OUT vector<Point>& foundLocations,
Size padding = Size(),
const vector<Point>& searchLocations = vector<Point>()) const;
- //with result weights output
+ /* with result weights output */
virtual void detectMultiScale(
const Mat& img,
CV_OUT vector<Rect>& foundLocations,
double finalThreshold = 2.0,
bool useMeanshiftGrouping = false) const;
- //without found weights output
+ /* without found weights output */
virtual void detectMultiScale(
const Mat& img,
CV_OUT vector<Rect>& foundLocations,
Size paddingTL = Size(),
Size paddingBR = Size()) const;
+ static vector<float> getDefaultPeopleDetector();
+
+ static vector<float> getDaimlerPeopleDetector();
+
+ /* read/parse Dalal's alt model file */
+ void readALTModel(std::string modelfile);
+
void groupRectangles(
vector<cv::Rect>& rectList,
vector<double>& weights,
--- /dev/null
+/**
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __MEDIA_VISION_MFTRACKER_H__
+#define __MEDIA_VISION_MFTRACKER_H__
+
+#include <opencv2/core/core.hpp>
+
+namespace mediavision {
+namespace surveillance {
+
+/**
+ * @class MFTracker
+ * @brief Median Flow tracker implementation.
+ *
+ * @since_tizen 3.0
+ */
+class MFTracker {
+public:
+ struct Params {
+ /**
+ * @brief TrackerMedianFlow algorithm parameters constructor
+ */
+ Params();
+
+ int mPointsInGrid; /**< Square root of number of used keypoints.
+ Increase it to trade accurateness for speed.
+ Default value is sensible and recommended */
+
+ cv::Size mWindowSize; /**< Size of the search window at each pyramid level
+ for Lucas-Kanade optical flow search used for
+ tracking */
+
+ int mPyrMaxLevel; /**< Number of pyramid levels for Lucas-Kanade optical
+ flow search used for tracking */
+ };
+
+ /**
+ * @brief @ref MFTracker constructor based on tracking algorithm parameters.
+ *
+ * @since_tizen 3.0
+ * @param [in] params Parameters for objects tracking
+ */
+ MFTracker(Params params = Params());
+
+ /**
+ * @brief Tracks the target for the video stream consisting of frames.
+ *
+ * @since_tizen 3.0
+ * @remarks Call this function alternately for each frame
+ * @param [in] frame Current frame of the video stream
+ * @param [out] result Result contour
+ * @return true if object is tracked, otherwise return false
+ */
+ bool track(const cv::Mat& frame, cv::Rect_<float>& result);
+
+ /**
+ * @brief Provides the current location of a target.
+ *
+ * @since_tizen 3.0
+ * @param [in] location Current location of a target
+ */
+ void reinforcement(const cv::Rect_<float>& location);
+
+private:
+ bool isInited() const;
+
+ bool init(const cv::Mat& image);
+
+ bool update(const cv::Mat& image);
+
+ float getLastConfidence() const;
+
+ cv::Rect_<float> getLastBoundingBox() const;
+
+ bool medianFlowImpl(cv::Mat oldImage, cv::Mat newImage, cv::Rect_<float>& oldBox);
+
+ cv::Rect_<float> vote(
+ const std::vector<cv::Point2f>& oldPoints,
+ const std::vector<cv::Point2f>& newPoints,
+ const cv::Rect_<float>& oldRect,
+ cv::Point2f& mD);
+
+ void check_FB(
+ std::vector<cv::Mat> newPyramid,
+ const std::vector<cv::Point2f>& oldPoints,
+ const std::vector<cv::Point2f>& newPoints,
+ std::vector<bool>& status);
+
+ void check_NCC(
+ const cv::Mat& oldImage,
+ const cv::Mat& newImage,
+ const std::vector<cv::Point2f>& oldPoints,
+ const std::vector<cv::Point2f>& newPoints,
+ std::vector<bool>& status);
+
+private:
+ bool __isInit; /**< Flag is used to determine the model
+ initialization */
+
+ Params __params; /**< Parameters used during tracking, see
+ @ref TrackerMedianFlow::Params */
+
+ cv::TermCriteria __termcrit; /**< Terminating criteria for OpenCV
+ Lucas–Kanade optical flow algorithm used
+ during tracking */
+
+ cv::Rect_<float> __boundingBox; /**< Tracking object bounding box */
+
+ float __confidence; /**< Confidence that object was tracked
+ correctly at the last tracking iteration */
+
+ cv::Mat __image; /**< Last image for which tracking was
+ performed */
+
+ std::vector<cv::Mat> __pyramid; /**< The pyramid had been calculated for
+ the previous frame(or when
+ initialize the model) */
+};
+
+} /* surveillance */
+} /* mediavision */
+
+#endif /* __MEDIA_VISION_MFTRACKER_H__ */
*/
static int convertSourceMVRGB2GrayCVNeon(mv_source_h mvSource, cv::Mat& cvSource);
#endif
+
};
mv_surveillance_event_occurred_cb callback,
void *user_data,
int numberOfPoints,
- mv_point_s *roi)
+ mv_point_s *roi,
+ bool isInternal)
{
if (NULL == callback || NULL == eventType) {
LOGE("Input event trigger or callback is NULL. Event registering failed.");
callback,
user_data,
numberOfPoints,
- roi);
+ roi,
+ isInternal);
const int error = trigger->parseEngineConfig(engineCfg);
if (error != MEDIA_VISION_ERROR_NONE) {
callback,
user_data,
numberOfPoints,
- roi);
+ roi,
+ isInternal);
delete trigger;
} else {
callback,
user_data,
numberOfPoints,
- roi);
+ roi,
+ isInternal);
const int error = trigger->parseEngineConfig(engineCfg);
if (error != MEDIA_VISION_ERROR_NONE) {
callback,
user_data,
numberOfPoints,
- roi);
+ roi,
+ isInternal);
delete trigger;
} else {
callback,
user_data,
numberOfPoints,
- roi);
+ roi,
+ isInternal);
const int error = trigger->parseEngineConfig(engineCfg);
callback,
user_data,
numberOfPoints,
- roi);
+ roi,
+ isInternal);
delete trigger;
} else {
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi):
+ mv_point_s *roi,
+ bool isInternal):
__videoStreamId(videoStreamId),
__roi(numberOfPoints)
{
callbackData.eventTrigger = eventTrigger;
callbackData.callback = callback;
callbackData.userData = userData;
+ callbackData.isInternal = isInternal;
__callbackDataMap.insert(CallbackDataPair(triggerId, callbackData));
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi)
+ mv_point_s *roi,
+ bool isInternal)
{
if (isCallbackSubscribed(triggerId)) {
LOGE("Callback with id %d is already subscribed. "
callbackData.eventTrigger = eventTrigger;
callbackData.callback = callback;
callbackData.userData = userData;
+ callbackData.isInternal = isInternal;
__callbackDataMap.insert(CallbackDataPair(triggerId, callbackData));
if (intersectionArea != 0 &&
intersectionArea > std::min(area1, area2) / 2) {
- rects[i] |= rects[j];
- rects[j] = DEFAULT_RECT;
+ rects[j] |= rects[i];
+ rects[i] = DEFAULT_RECT;
+ break;
}
}
}
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi) : EventTrigger(
+ mv_point_s *roi,
+ bool isInternal) : EventTrigger(
eventTrigger,
triggerId,
videoStreamId,
callback,
userData,
numberOfPoints,
- roi),
+ roi,
+ isInternal),
__previousImage(),
__eventResult(new EventResultMovementDetection()),
__diffThreshold(DEFAULT_DIFF_THRESHOLD)
diffBuffer);
if (error != MEDIA_VISION_ERROR_NONE) {
+ free(diffBuffer);
LOGE("Absolute difference calculation failed. Pushing source failed.");
return error;
}
error = applyROIToImage(diffBuffer, image.cols, image.rows);
if (error != MEDIA_VISION_ERROR_NONE || image.empty()) {
+ free(diffBuffer);
LOGE("Applying ROI failed with error %d.", error);
return error;
}
CVRectangles rects(contoursSize);
for (size_t i = 0u; i < contoursSize; ++i)
- rects[i] = cv::boundingRect(cv::Mat(contours[i]));
+ rects[i] = cv::boundingRect(contours[i]);
mergeOverlappedRects(rects);
- const size_t roiSize = __roi.size();
- CVPoints roi(roiSize);
-
- cv::Rect roiRect(0, 0, imgDiff.cols, imgDiff.rows);
-
- if (roiSize >= 3u) {
- for (size_t i = 0u; i < roiSize; ++i)
- roi[i] = cv::Point(__roi[i].x, __roi[i].y);
-
- roiRect = cv::boundingRect(roi);
- }
-
const size_t rectsSize = rects.size();
- for (size_t i = 0u; i < rectsSize; ++i)
- if (rects[i] != DEFAULT_RECT &&
- roiRect.contains(rects[i].tl()) &&
- roiRect.contains(rects[i].br())) {
+ for (size_t i = 0u; i < rectsSize; ++i) {
+ if (rects[i] != DEFAULT_RECT) {
mv_rectangle_s rectMV;
convertRectCV2MV(rects[i], rectMV);
__eventResult->__movementRegions.push_back(rectMV);
}
+ }
__previousImage = image;
__eventResult->__grayImage = __previousImage;
// Don't invoke the callback if movement wasn't detected at the frame
- if (__eventResult->__movementRegions.size() > 0) {
- CallbackDataMapConstIter iter = __callbackDataMap.begin();
+ CallbackDataMapConstIter iter = __callbackDataMap.begin();
- for (; iter != __callbackDataMap.end(); ++iter) {
- mv_surveillance_event_occurred_cb callback = iter->second.callback;
+ for (; iter != __callbackDataMap.end(); ++iter) {
+ mv_surveillance_event_occurred_cb callback = iter->second.callback;
+
+ if (__eventResult->__movementRegions.size() > 0 || iter->second.isInternal)
callback(
iter->second.eventTrigger,
source,
__videoStreamId,
__eventResult,
iter->second.userData);
- }
}
return MEDIA_VISION_ERROR_NONE;
static const int DEFAULT_SKIP_FRAMES_COUNT = 6;
-static const int DEFAULT_FRAME_WIDTH = 640;
+static const int DEFAULT_FRAME_WIDTH = 320;
-static const int DEFAULT_FRAME_HEIGHT = 480;
+static const int DEFAULT_FRAME_HEIGHT = 240;
+
+static const time_t PERSON_LIFETIME = 2000000; /* usec */
static const cv::Size DEFAULT_FRAME_SIZE(DEFAULT_FRAME_WIDTH, DEFAULT_FRAME_HEIGHT);
static const cv::Size DEFAULT_DETECTION_STEPS = cv::Size(8, 8);
+static const float POSSIBLE_SIZE_DIFFERENCE = 0.3f;
+
+static const float MINIMAL_INTERSECTION = 0.1f;
+
+static const float TRACKING_MARGIN = 0.2f;
+
static const std::vector<float> DEFAULT_SVM_PEOPLE_DETECTOR =
cv::HOGDescriptor::getDefaultPeopleDetector();
namespace {
+cv::Rect operator&(cv::Rect r1, cv::Rect_<float> r2)
+{
+ cv::Rect r2int((int)r2.x, (int)r2.y, (int)r2.width, (int)r2.height);
+
+ return r1 & r2int;
+}
+
+cv::Rect operator|=(cv::Rect r1, cv::Rect_<float> r2)
+{
+ cv::Rect r2int((int)r2.x, (int)r2.y, (int)r2.width, (int)r2.height);
+
+ return r1 |= r2int;
+}
+
+cv::Rect_<float> cutRectForTracking(const cv::Rect_<float>& rect)
+{
+ cv::Rect_<float> res;
+
+ float widthCoof = rect.width * TRACKING_MARGIN;
+ float heightCoof = rect.height * TRACKING_MARGIN;
+
+ res.x = rect.x + widthCoof;
+ res.y = rect.y + heightCoof;
+ res.width = rect.width - widthCoof * 2;
+ res.height = rect.height - heightCoof * 2;
+
+ return res;
+}
+
+cv::Rect_<float> supplementRectAfterTracking(const cv::Rect_<float>& rect)
+{
+ cv::Rect_<float> res;
+
+ res.width = rect.width / (1 - TRACKING_MARGIN * 2);
+ res.height = rect.height / (1 - TRACKING_MARGIN * 2);
+ res.x = rect.x - (res.width - rect.width) / 2;
+ res.y = rect.y - (res.height - rect.height) / 2;
+
+ return res;
+}
+
+float sizeDifferenceFactor(const cv::Rect& r1, const cv::Rect& r2)
+{
+ float widthDiffFactor = r1.width / (float)r2.width;
+ float heightDiffFactor = r1.height / (float)r2.height;
+
+ if (widthDiffFactor > 1.f)
+ widthDiffFactor = 1.f / widthDiffFactor;
+ if (heightDiffFactor > 1.f)
+ heightDiffFactor = 1.f / heightDiffFactor;
+
+ return widthDiffFactor * heightDiffFactor *
+ (1.f - fabs(widthDiffFactor - heightDiffFactor));
+}
+
+bool isPossibleToMerge(const cv::Rect& r1, const cv::Rect& r2)
+{
+ return sizeDifferenceFactor(r1, r2) > POSSIBLE_SIZE_DIFFERENCE &&
+ ((r1.area() + r2.area()) * MINIMAL_INTERSECTION / 2.f) <
+ (r1 & r2).area();
+}
+
inline void convertRectMV2CV(const mv_rectangle_s& src, cv::Rect& dst)
{
dst.x = src.point.x;
} /* Anonymous namespace*/
+EventTriggerPersonAppearance::TrackedRectangle::TrackedRectangle(cv::Rect _rect,
+ struct timeval _appearanceTime)
+{
+ rect = _rect;
+ appearanceTime = _appearanceTime;
+ tracker.reinforcement(cutRectForTracking(rect));
+}
+
int EventResultPersonAppearance::getResultValue(const char *valueName,
void *value) const
{
EventTriggerPersonAppearance::EventTriggerPersonAppearance(
mv_surveillance_event_trigger_h eventTrigger, long int triggerId,
int videoStreamId, mv_surveillance_event_occurred_cb callback,
- void *userData, int numberOfPoints, mv_point_s *roi) :
+ void *userData, int numberOfPoints, mv_point_s *roi, bool isInternal) :
EventTrigger(eventTrigger, triggerId, videoStreamId, callback, userData,
- numberOfPoints, roi), __skipFramesCount(DEFAULT_SKIP_FRAMES_COUNT),
+ numberOfPoints, roi, isInternal),
+ __skipFramesCount(DEFAULT_SKIP_FRAMES_COUNT),
__frameCounter(0), __movementDetectedEventId(InternalTriggersCounter--),
__factorX(1.f), __factorY(1.f), __rectToDetect(ALL_IMAGE_RECT),
__rectToDetectPrevious(ALL_IMAGE_RECT), __trackedRects(),
{
__hogClassifier.setSVMDetector(DEFAULT_SVM_PEOPLE_DETECTOR);
- EventManager::getInstance().registerEvent(
- NULL, __movementDetectedEventId,
- MV_SURVEILLANCE_EVENT_TYPE_MOVEMENT_DETECTED, videoStreamId,
- NULL, movementDetectedCB, this, numberOfPoints, roi);
+ EventManager::getInstance().registerEvent(NULL, __movementDetectedEventId,
+ MV_SURVEILLANCE_EVENT_TYPE_MOVEMENT_DETECTED, videoStreamId, NULL,
+ movementDetectedCB, this, numberOfPoints, roi, true);
}
EventTriggerPersonAppearance::~EventTriggerPersonAppearance()
for (size_t j = 1u; j < numberOfMovementRegions; ++j)
trigger->__rectToDetect |= movementRegions[j];
- if (trigger->__rectToDetect.width
- < trigger->__hogClassifier.winSize.width
- || trigger->__rectToDetect.height
- < trigger->__hogClassifier.winSize.height)
+ if (trigger->__rectToDetect.width < trigger->__hogClassifier.winSize.width ||
+ trigger->__rectToDetect.height < trigger->__hogClassifier.winSize.height)
trigger->__rectToDetect |= trigger->__rectToDetectPrevious;
}
trigger->__rectToDetect &= ALL_IMAGE_RECT;
-
/* 4. Perform Hog detector or try to track using movement regions */
- if ((trigger->__skipFramesCount == 0 ||
- trigger->__frameCounter % trigger->__skipFramesCount == 0) &&
- (trigger->__rectToDetect != ALL_IMAGE_RECT)) {
+ if (trigger->__frameCounter % (trigger->__skipFramesCount + 1) == 0) {
+
+ trigger->__frameCounter = 0;
+
/* 4.1 Perform Hog detector */
TrackedRectanglesConstIter iter = trigger->__trackedRects.begin();
for (; iter != trigger->__trackedRects.end(); ++iter)
trigger->__rectToDetect |= iter->rect;
- // Slightly extend detection area...
+ /* Slightly extend detection area... */
const int xShift = .25f * trigger->__rectToDetect.width;
const int yShift = .25f * trigger->__rectToDetect.height;
trigger->__rectToDetect.x -= xShift / 2;
trigger->__rectToDetect.width += xShift;
trigger->__rectToDetect.height += yShift;
trigger->__rectToDetect &= ALL_IMAGE_RECT;
- // and fit it to the HOG cell size
+ /* and fit it to the HOG cell size */
const int xRest = trigger->__rectToDetect.width % 8;
const int yRest = trigger->__rectToDetect.height % 8;
trigger->__rectToDetect.x += xRest / 2;
trigger->__hogClassifier.detectMultiScale(
resizedImage(trigger->__rectToDetect), hogRects, 0,
- DEFAULT_DETECTION_STEPS, cv::Size(32, 32), 1.059, 2);
+ DEFAULT_DETECTION_STEPS, cv::Size(32, 32), 1.059, 5);
const size_t hogRectsSize = hogRects.size();
hogRects[i].y += trigger->__rectToDetect.y;
}
- std::vector<bool> trackChecks(hogRectsSize, false);
- TrackedRectanglesIter trackRectIter = trigger->__trackedRects.begin();
- for (; trackRectIter != trigger->__trackedRects.end();
- ++trackRectIter) {
- size_t bestArea = 0;
- size_t bestIdx = 0;
- for (size_t idx = 0u; idx < hogRectsSize; ++idx) {
- if (trackChecks[idx])
- continue;
- const size_t curArea =
- (hogRects[idx] & trackRectIter->rect).area();
- if (bestArea < curArea) {
- bestArea = curArea;
- bestIdx = idx;
- }
- }
- if (bestArea > 10) {
- trackChecks[bestIdx] = true;
- trackRectIter->rect = hogRects[bestIdx];
- }
- }
+ /* Merge appearance and tracked rectangles */
+ std::vector<bool> appearedBusyRects =
+ trigger->reinforceTrackedPersons(hogRects);
+ /* Person appearance */
trigger->__appearedRects.clear();
for (size_t idx = 0u; idx < hogRectsSize; ++idx)
- if (!trackChecks[idx])
+ if (!appearedBusyRects[idx])
trigger->__appearedRects.push_back(hogRects[idx]);
- } else {
- /* 4.2 Try to track */
- CVRectanglesConstIter appearedIter = trigger->__appearedRects.begin();
- for (; appearedIter != trigger->__appearedRects.end(); ++appearedIter)
- trigger->__trackedRects.push_back(
- TrackedRectangle(*appearedIter, 7));
- trigger->__appearedRects.clear();
+ /* Person disappearance */
+ struct timeval time;
+ gettimeofday(&time, NULL);
+ TrackedRectanglesIter trackRectIter = trigger->__trackedRects.begin();
+ for (; trackRectIter != trigger->__trackedRects.end(); ++trackRectIter) {
+
+ time_t currentLifetime = 1000000 *
+ (time.tv_sec - trackRectIter->appearanceTime.tv_sec) +
+ (time.tv_usec - trackRectIter->appearanceTime.tv_usec);
+ if (currentLifetime > PERSON_LIFETIME) {
+
+ trigger->__disappearedRects.push_back(trackRectIter->rect);
+ trackRectIter = trigger->__trackedRects.erase(trackRectIter);
+ }
+ }
+ } else {
+ /* 4.2 Try to track */
TrackedRectanglesIter iter = trigger->__trackedRects.begin();
while (iter != trigger->__trackedRects.end()) {
- bool tracked = false;
- for (size_t j = 0u; j < numberOfMovementRegions; ++j) {
- cv::Rect rect = iter->rect;
- if ((rect & movementRegions[j]).area() != 0 &&
- movementRegions[j].area() <= 3 * rect.area() / 2) {
- cv::Rect r1 = rect | movementRegions[j];
- const int dx = r1.width - rect.width;
- const int dy = r1.height - rect.height;
+ cv::Rect_<float> trackingResult;
+ if (iter->tracker.track(result->__grayImage, trackingResult))
+ iter->rect = supplementRectAfterTracking(trackingResult);
- if (r1.x < movementRegions[j].x)
- r1.x += dx;
- else if (r1.x > movementRegions[j].x)
- r1.x -= dx;
+ ++iter;
+ }
+ }
- if (r1.y < movementRegions[j].y)
- r1.y += dy;
- else if (r1.y > movementRegions[j].y)
- r1.y -= dy;
+ trigger->__rectToDetectPrevious = trigger->__rectToDetect;
+ ++trigger->__frameCounter;
- r1.height = rect.height;
- r1.width = rect.width;
+ /* 5. Update event result and run callbacks */
+ trigger->runCallbacks(source);
+
+ /* 6. Migrate appeared persons to array of tracking persons */
+ struct timeval time;
+ gettimeofday(&time, NULL);
+
+ CVRectanglesConstIter appearedIter = trigger->__appearedRects.begin();
+ for (; appearedIter != trigger->__appearedRects.end(); ++appearedIter)
+ trigger->__trackedRects.push_back(
+ TrackedRectangle(*appearedIter, time));
+ trigger->__appearedRects.clear();
- iter->rect = r1;
+ /* 7. Clear array of disappeared persons */
+ trigger->__disappearedRects.clear();
+}
- tracked = true;
+std::vector<bool> EventTriggerPersonAppearance::reinforceTrackedPersons(
+ const CVRectangles& appearedPersons)
+{
+ const size_t hogRectsSize = appearedPersons.size();
+ std::vector<bool> appearedBusyRects(hogRectsSize, false);
+ if (__trackedRects.size() > 0u && hogRectsSize > 0u) {
+
+ TrackedRectanglesIter trackRectIter = __trackedRects.begin();
+ std::vector<std::vector<size_t> > intersectionAreas(
+ __trackedRects.size(), std::vector<size_t>(hogRectsSize, 0u));
+ std::vector<std::vector<size_t> > confidence(
+ __trackedRects.size(), std::vector<size_t>(hogRectsSize, 0u));
+
+ /* Merge tracked -> appearance */
+ for (size_t trIdx = 0u; trackRectIter != __trackedRects.end();
+ ++trackRectIter, ++trIdx) {
+
+ size_t bestIdx = 0u;
+ bool haveRes = false;
+ for (size_t apIdx = 0u; apIdx < hogRectsSize; ++apIdx) {
+
+ intersectionAreas[trIdx][apIdx] =
+ (appearedPersons[apIdx] & trackRectIter->rect).area();
+
+ if (intersectionAreas[trIdx][apIdx] > 0 &&
+ (intersectionAreas[trIdx][apIdx] >
+ intersectionAreas[trIdx][bestIdx] || !haveRes)) {
+
+ bestIdx = apIdx;
+ haveRes = true;
}
}
- if (tracked) {
- ++iter;
- } else {
- if (iter->framesCount == 0) {
- trigger->__disappearedRects.push_back(iter->rect);
- iter = trigger->__trackedRects.erase(iter);
- } else {
- --(iter->framesCount);
- ++iter;
+ if (haveRes)
+ confidence[trIdx][bestIdx] += intersectionAreas[trIdx][bestIdx] *
+ sizeDifferenceFactor(trackRectIter->rect, appearedPersons[bestIdx]);
+ }
+
+ /* Merge appearance -> tracked */
+ for (size_t apIdx = 0u; apIdx < hogRectsSize; ++apIdx) {
+
+ trackRectIter = __trackedRects.begin();
+ size_t bestIdx = 0u;
+ bool haveRes = false;
+ cv::Rect bestTrackedRect = trackRectIter->rect;
+
+ for (size_t trIdx = 0u; trackRectIter != __trackedRects.end();
+ ++trackRectIter, ++trIdx) {
+
+ if (intersectionAreas[trIdx][apIdx] > 0 &&
+ (intersectionAreas[trIdx][apIdx] >
+ intersectionAreas[bestIdx][apIdx] || !haveRes)) {
+
+ bestIdx = trIdx;
+ bestTrackedRect = trackRectIter->rect;
+ haveRes = true;
}
}
+
+ if (haveRes)
+ confidence[bestIdx][apIdx] += intersectionAreas[bestIdx][apIdx] *
+ sizeDifferenceFactor(bestTrackedRect, appearedPersons[apIdx]);
}
- }
- trigger->__rectToDetectPrevious = trigger->__rectToDetect;
- ++trigger->__frameCounter;
+ /* Final merge */
+ trackRectIter = __trackedRects.begin();
+ for (size_t trIdx = 0u; trackRectIter != __trackedRects.end();
+ ++trackRectIter, ++trIdx) {
- /* 5. Update event result and run callbacks */
- trigger->runCallbacks(source);
+ bool haveRes = false;
+ size_t bestIdx = 0u;
- trigger->__disappearedRects.clear();
+ for (size_t apIdx = 0u; apIdx < hogRectsSize; ++apIdx) {
+ if (!appearedBusyRects[apIdx] && (!haveRes ||
+ confidence[trIdx][apIdx] > confidence[trIdx][bestIdx])) {
+
+ bestIdx = apIdx;
+ haveRes = true;
+ }
+ }
+
+ if (isPossibleToMerge(trackRectIter->rect, appearedPersons[bestIdx]) &&
+ haveRes) {
+
+ appearedBusyRects[bestIdx] = true;
+
+ struct timeval time;
+ gettimeofday(&time, NULL);
+
+ trackRectIter->appearanceTime = time;
+ trackRectIter->rect = appearedPersons[bestIdx];
+ trackRectIter->tracker.reinforcement(
+ cutRectForTracking(trackRectIter->rect));
+ }
+ }
+
+ for (size_t apIdx = 0u; apIdx < hogRectsSize; ++apIdx) {
+ if (!appearedBusyRects[apIdx]) {
+ trackRectIter = __trackedRects.begin();
+ for (;trackRectIter != __trackedRects.end();
+ ++trackRectIter) {
+ if (isPossibleToMerge(trackRectIter->rect,
+ appearedPersons[apIdx]) && (appearedPersons[apIdx].area() / 2.f) <
+ (appearedPersons[apIdx] & trackRectIter->rect).area()) {
+ appearedBusyRects[apIdx] = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return appearedBusyRects;
}
void EventTriggerPersonAppearance::runCallbacks(mv_source_h source)
__eventResult->__trackedLocations[i].height /= __factorY;
}
- // Don't invoke the callback if no appearance, disappearance or tracking
- if (appearedLocationsSize > 0 || disappearedLocationsSize > 0
- || trackedLocationsSize > 0) {
- CallbackDataMapConstIter iter = __callbackDataMap.begin();
+ /* Don't invoke the callback if no appearance, disappearance or tracking */
+ CallbackDataMapConstIter iter = __callbackDataMap.begin();
- for (; iter != __callbackDataMap.end(); ++iter) {
- mv_surveillance_event_occurred_cb callback = iter->second.callback;
+ for (; iter != __callbackDataMap.end(); ++iter) {
+ mv_surveillance_event_occurred_cb callback = iter->second.callback;
+
+
+ if (appearedLocationsSize > 0 || disappearedLocationsSize > 0
+ || trackedLocationsSize > 0 || iter->second.isInternal)
callback(iter->second.eventTrigger, source, __videoStreamId,
__eventResult, iter->second.userData);
- }
}
}
mv_surveillance_event_occurred_cb callback,
void *userData,
int numberOfPoints,
- mv_point_s *roi) : EventTrigger(eventTrigger,
+ mv_point_s *roi,
+ bool isInternal) : EventTrigger(eventTrigger,
triggerId,
videoStreamId,
callback,
userData,
numberOfPoints,
- roi),
+ roi,
+ isInternal),
__faceRecognitionModel(NULL),
__lastFrame(NULL),
__eventResult(new EventResultPersonRecognition())
return;
}
- EventTriggerPersonRecognition *recognitionTrigger =
+ EventTriggerPersonRecognition *trigger =
(EventTriggerPersonRecognition*)user_data;
int location_idx = 0;
const int error = mv_face_recognize(
source,
- recognitionTrigger->__faceRecognitionModel,
+ trigger->__faceRecognitionModel,
NULL,
&faces_locations[location_idx],
faceRecognizedCB,
- recognitionTrigger);
+ trigger);
if (error != MEDIA_VISION_ERROR_NONE) {
LOGW("Face recognition for one model failed. Continue");
LOGI("Face has been successfully recognized");
}
+
+ CallbackDataMapConstIter iter = trigger->__callbackDataMap.begin();
+
+ for (; iter != trigger->__callbackDataMap.end(); ++iter) {
+ mv_surveillance_event_occurred_cb callback = iter->second.callback;
+
+ if (trigger->__eventResult->__locations.size() > 0 || iter->second.isInternal)
+ callback(
+ iter->second.eventTrigger,
+ trigger->__lastFrame,
+ trigger->__videoStreamId,
+ trigger->__eventResult,
+ iter->second.userData);
+ }
}
void EventTriggerPersonRecognition::faceRecognizedCB(
(EventTriggerPersonRecognition*) user_data;
trigger->setEventResults(*face_location, *face_label, confidence);
-
- CallbackDataMapConstIter iter = trigger->__callbackDataMap.begin();
-
- for (; iter != trigger->__callbackDataMap.end(); ++iter) {
- mv_surveillance_event_occurred_cb callback = iter->second.callback;
- callback(
- iter->second.eventTrigger,
- trigger->__lastFrame,
- trigger->__videoStreamId,
- trigger->__eventResult,
- iter->second.userData);
- }
}
} /* surveillance */
--- /dev/null
+/**
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MFTracker.h"
+
+#include <opencv/cv.h>
+
+namespace mediavision {
+namespace surveillance {
+
+namespace {
+const float FLOATEPS = 10e-6f;
+
+template<typename T>
+T getMedian(std::vector<T>& values, int size = -1)
+{
+ if (size == -1)
+ size = (int)values.size();
+
+ std::vector<T> copy(values.begin(), values.begin() + size);
+ std::sort(copy.begin(), copy.end());
+ if (size%2 == 0) {
+ return (copy[size / 2 - 1] + copy[size/2]) / ((T)2.0);
+ } else {
+ return copy[(size - 1) / 2];
+ }
+}
+
+inline float l2distance(cv::Point2f p1, cv::Point2f p2)
+{
+ const float dx = p1.x - p2.x;
+ const float dy = p1.y - p2.y;
+ return sqrtf(dx * dx + dy * dy);
+}
+} /* anonymous namespace */
+
+MFTracker::Params::Params()
+{
+ mPointsInGrid = 10;
+ mWindowSize = cv::Size(3, 3);
+ mPyrMaxLevel = 5;
+}
+
+MFTracker::MFTracker(Params params) :
+ __isInit(false),
+ __params(params),
+ __termcrit(cv::TermCriteria::COUNT | cv::TermCriteria::EPS, 20, 0.3),
+ __confidence(0.0f)
+{
+}
+
+bool MFTracker::track(const cv::Mat& frame, cv::Rect_<float>& result)
+{
+ if (!__isInit) {
+ if (__boundingBox.width <= 0 || __boundingBox.height <= 0)
+ return false;
+ if (!init(frame))
+ return false;
+ } else {
+ if (!update(frame)) {
+ __isInit = false;
+ return false;
+ }
+ }
+
+ result = __boundingBox;
+
+ return true;
+}
+
+void MFTracker::reinforcement(const cv::Rect_<float>& location)
+{
+ __isInit = false;
+
+ __boundingBox = location;
+}
+
+bool MFTracker::init(const cv::Mat& image)
+{
+ if (image.empty())
+ return false;
+
+ image.copyTo(__image);
+ buildOpticalFlowPyramid(
+ __image,
+ __pyramid,
+ __params.mWindowSize,
+ __params.mPyrMaxLevel);
+
+ __isInit = true;
+ return __isInit;
+}
+
+bool MFTracker::update(const cv::Mat& image)
+{
+ if (!__isInit || image.empty())
+ return false;
+
+ /* Handles such behaviour when preparation frame has the size
+ * different to the tracking frame size. In such case, we resize preparation
+ * frame and bounding box. Then, track as usually: */
+ if (__image.rows != image.rows || __image.cols != image.cols) {
+ const float xFactor = static_cast<float>(image.cols) / __image.cols;
+ const float yFactor = static_cast<float>(image.rows) / __image.rows;
+
+ resize(__image, __image, cv::Size(), xFactor, yFactor);
+
+ __boundingBox.x *= xFactor;
+ __boundingBox.y *= yFactor;
+ __boundingBox.width *= xFactor;
+ __boundingBox.height *= yFactor;
+ }
+
+ cv::Mat oldImage = __image;
+
+ cv::Rect_<float> oldBox = __boundingBox;
+ if(!medianFlowImpl(oldImage, image, oldBox))
+ return false;
+
+ image.copyTo(__image);
+ __boundingBox = oldBox;
+ return true;
+}
+
+bool MFTracker::isInited() const
+{
+ return __isInit;
+}
+
+float MFTracker::getLastConfidence() const
+{
+ return __confidence;
+}
+
+cv::Rect_<float> MFTracker::getLastBoundingBox() const
+{
+ return __boundingBox;
+}
+
+bool MFTracker::medianFlowImpl(
+ cv::Mat oldImage_gray, cv::Mat newImage_gray, cv::Rect_<float>& oldBox)
+{
+ std::vector<cv::Point2f> pointsToTrackOld, pointsToTrackNew;
+
+ const float gridXStep = oldBox.width / __params.mPointsInGrid;
+ const float gridYStep = oldBox.height / __params.mPointsInGrid;
+ for (int i = 0; i < __params.mPointsInGrid; i++)
+ for (int j = 0; j < __params.mPointsInGrid; j++) {
+ pointsToTrackOld.push_back(
+ cv::Point2f(oldBox.x + .5f*gridXStep + 1.f*gridXStep*j,
+ oldBox.y + .5f*gridYStep + 1.f*gridYStep*i));
+ }
+
+ const size_t numberOfPointsToTrackOld = pointsToTrackOld.size();
+ std::vector<uchar> status(numberOfPointsToTrackOld);
+ std::vector<float> errors(numberOfPointsToTrackOld);
+
+ std::vector<cv::Mat> tempPyramid;
+ cv::buildOpticalFlowPyramid(
+ newImage_gray,
+ tempPyramid,
+ __params.mWindowSize,
+ __params.mPyrMaxLevel);
+
+ cv::calcOpticalFlowPyrLK(__pyramid,
+ tempPyramid,
+ pointsToTrackOld,
+ pointsToTrackNew,
+ status,
+ errors,
+ __params.mWindowSize,
+ __params.mPyrMaxLevel,
+ __termcrit);
+
+ std::vector<cv::Point2f> di;
+ for (size_t idx = 0u; idx < numberOfPointsToTrackOld; idx++)
+ if (status[idx] == 1)
+ di.push_back(pointsToTrackNew[idx] - pointsToTrackOld[idx]);
+
+ std::vector<bool> filter_status;
+ check_FB(tempPyramid,
+ pointsToTrackOld,
+ pointsToTrackNew,
+ filter_status);
+ check_NCC(oldImage_gray,
+ newImage_gray,
+ pointsToTrackOld,
+ pointsToTrackNew,
+ filter_status);
+
+ for (size_t idx = 0u; idx < pointsToTrackOld.size(); idx++)
+ if (!filter_status[idx]) {
+ pointsToTrackOld.erase(pointsToTrackOld.begin() + idx);
+ pointsToTrackNew.erase(pointsToTrackNew.begin() + idx);
+ filter_status.erase(filter_status.begin() + idx);
+ idx--;
+ }
+
+ if (pointsToTrackOld.empty() || di.empty())
+ return false;
+
+ cv::Point2f mDisplacement;
+ cv::Rect_<float> boxCandidate =
+ vote(pointsToTrackOld, pointsToTrackNew, oldBox, mDisplacement);
+
+ std::vector<float> displacements;
+ for (size_t idx = 0u; idx < di.size(); idx++) {
+ di[idx] -= mDisplacement;
+ displacements.push_back(sqrt(di[idx].ddot(di[idx])));
+ }
+
+ __confidence =
+ (10.f - getMedian(displacements, static_cast<int>(displacements.size()))) / 10.f;
+
+ if (__confidence < 0.f) {
+ __confidence = 0.f;
+ return false;
+ }
+
+ __pyramid.swap(tempPyramid);
+ oldBox = boxCandidate;
+ return true;
+}
+
+cv::Rect_<float> MFTracker::vote(
+ const std::vector<cv::Point2f>& oldPoints,
+ const std::vector<cv::Point2f>& newPoints,
+ const cv::Rect_<float>& oldRect,
+ cv::Point2f& mD)
+{
+ cv::Rect_<float> newRect;
+ cv::Point2f newCenter(
+ oldRect.x + oldRect.width / 2.f,
+ oldRect.y + oldRect.height / 2.f);
+
+ const int n = (int)oldPoints.size();
+ std::vector<float> buf(std::max(n*(n-1) / 2, 3), 0.f);
+
+ if(oldPoints.size() == 1) {
+ newRect.x = oldRect.x+newPoints[0].x-oldPoints[0].x;
+ newRect.y = oldRect.y+newPoints[0].y-oldPoints[0].y;
+ newRect.width = oldRect.width;
+ newRect.height = oldRect.height;
+
+ return newRect;
+ }
+
+ float xshift = 0.f;
+ float yshift = 0.f;
+ for (int i = 0; i < n; i++)
+ buf[i] = newPoints[i].x - oldPoints[i].x;
+
+ xshift = getMedian(buf, n);
+ newCenter.x += xshift;
+ for (int idx = 0; idx < n; idx++)
+ buf[idx] = newPoints[idx].y - oldPoints[idx].y;
+
+ yshift = getMedian(buf, n);
+ newCenter.y += yshift;
+ mD = cv::Point2f(xshift, yshift);
+
+ if (oldPoints.size() == 1) {
+ newRect.x = newCenter.x - oldRect.width / 2.f;
+ newRect.y = newCenter.y - oldRect.height / 2.f;
+ newRect.width = oldRect.width;
+ newRect.height = oldRect.height;
+
+ return newRect;
+ }
+
+ float nd = 0.f;
+ float od = 0.f;
+ for (int i = 0, ctr = 0; i < n; i++)
+ for (int j = 0; j < i; j++) {
+ nd = l2distance(newPoints[i], newPoints[j]);
+ od = l2distance(oldPoints[i], oldPoints[j]);
+ buf[ctr] = (od == 0.f ? 0.f : nd / od);
+ ctr++;
+ }
+
+ float scale = getMedian(buf, n*(n-1) / 2);
+ newRect.x = newCenter.x - scale * oldRect.width / 2.f;
+ newRect.y = newCenter.y-scale * oldRect.height / 2.f;
+ newRect.width = scale * oldRect.width;
+ newRect.height = scale * oldRect.height;
+
+ return newRect;
+}
+
+void MFTracker::check_FB(
+ std::vector<cv::Mat> newPyramid,
+ const std::vector<cv::Point2f>& oldPoints,
+ const std::vector<cv::Point2f>& newPoints,
+ std::vector<bool>& status)
+{
+ const size_t numberOfOldPoints = oldPoints.size();
+
+ if (status.empty())
+ status = std::vector<bool>(numberOfOldPoints, true);
+
+ std::vector<uchar> LKstatus(numberOfOldPoints);
+ std::vector<float> errors(numberOfOldPoints);
+ std::vector<float> FBerror(numberOfOldPoints);
+ std::vector<cv::Point2f> pointsToTrackReprojection;
+
+ calcOpticalFlowPyrLK(newPyramid,
+ __pyramid,
+ newPoints,
+ pointsToTrackReprojection,
+ LKstatus,
+ errors,
+ __params.mWindowSize,
+ __params.mPyrMaxLevel,
+ __termcrit);
+
+ for (size_t idx = 0u; idx < numberOfOldPoints; idx++)
+ FBerror[idx] = l2distance(oldPoints[idx], pointsToTrackReprojection[idx]);
+
+ float FBerrorMedian = getMedian(FBerror) + FLOATEPS;
+ for (size_t idx = 0u; idx < numberOfOldPoints; idx++)
+ status[idx] = (FBerror[idx] < FBerrorMedian);
+}
+
+void MFTracker::check_NCC(
+ const cv::Mat& oldImage,
+ const cv::Mat& newImage,
+ const std::vector<cv::Point2f>& oldPoints,
+ const std::vector<cv::Point2f>& newPoints,
+ std::vector<bool>& status)
+{
+ std::vector<float> NCC(oldPoints.size(), 0.f);
+ cv::Size patch(30, 30);
+ cv::Mat p1;
+ cv::Mat p2;
+
+ for (size_t idx = 0u; idx < oldPoints.size(); idx++) {
+ getRectSubPix(oldImage, patch, oldPoints[idx], p1);
+ getRectSubPix(newImage, patch, newPoints[idx], p2);
+
+ const int N = 900;
+ const float s1 = sum(p1)(0);
+ const float s2 = sum(p2)(0);
+ const float n1 = norm(p1);
+ const float n2 = norm(p2);
+ const float prod = p1.dot(p2);
+ const float sq1 = sqrt(n1 * n1 - s1 * s1 / N);
+ const float sq2 = sqrt(n2 * n2 - s2 * s2 / N);
+ NCC[idx] = (sq2 == 0 ? sq1 / std::abs(sq1)
+ : (prod - s1 * s2 / N) / sq1 / sq2);
+ }
+
+ float median = getMedian(NCC) - FLOATEPS;
+ for(size_t idx = 0u; idx < oldPoints.size(); idx++)
+ status[idx] = status[idx] && (NCC[idx] > median);
+}
+
+} /* surveillance */
+} /* mediavision */
callback,
user_data,
handle->number_of_roi_points,
- handle->roi);
+ handle->roi,
+ false);
}
int mv_surveillance_unsubscribe_event_trigger_open(
* limitations under the License.
*/
-#ifndef __TIZEN_MEDIAVISION_SURVEILLANCE_LIC_H__
-#define __TIZEN_MEDIAVISION_SURVEILLANCE_LIC_H__
+#ifndef __MEDIA_VISION_SURVEILLANCE_LIC_H__
+#define __MEDIA_VISION_SURVEILLANCE_LIC_H__
#include <mv_surveillance.h>
* @ref mv_surveillance_unsubscribe_event_trigger_lic().
* @param [in] event_trigger The event trigger activating calls of the
* @a callback function
+ * @param [in] video_stream_id The identifier of the video stream for which
+ * event trigger activation will be checked
* @param [in] engine_cfg The engine configuration of the event
* @param [in] callback Callback to be called each time when event
* occurrence is detected
* @see mv_surveillance_unsubscribe_event_trigger_lic()
*/
int mv_surveillance_subscribe_event_trigger_lic(
- mv_surveillance_event_trigger_h event_trigger,
- mv_engine_config_h engine_cfg,
- mv_surveillance_event_occurred_cb callback,
- void *user_data);
+ mv_surveillance_event_trigger_h event_trigger,
+ int video_stream_id, mv_engine_config_h engine_cfg,
+ mv_surveillance_event_occurred_cb callback,
+ void *user_data);
/**
* @brief Allows to unsubscribe from the event and stop calling @a callback.
* @since_tizen 3.0
* @remarks To start handling trigger activation use
@ref mv_surveillance_subscribe_event_trigger_lic().
- * @param [in] event_trigger The event trigger for which subscription will be
- * stopped
+ * @param [in] event_trigger The event trigger for which subscription will
+ * be stopped
+ * @param [in] video_stream_id The identifier of the video source for which
+ * subscription will be stopped
* @return @c 0 on success, otherwise a negative error value
* @retval #MEDIA_VISION_ERROR_NONE Successful
* @retval #MEDIA_VISION_ERROR_INVALID_PARAMETER Invalid parameter
* @see mv_surveillance_subscribe_event_trigger_lic()
*/
int mv_surveillance_unsubscribe_event_trigger_lic(
- mv_surveillance_event_trigger_h event_trigger);
+ mv_surveillance_event_trigger_h event_trigger,
+ int video_stream_id);
/**
* @brief Allows to push source to the event trigger and start calling @a callback.
* @see mv_surveillance_unsubscribe_event_trigger_lic()
*/
int mv_surveillance_push_source_lic(
- mv_source_h source,
- int video_stream_id);
+ mv_source_h source,
+ int video_stream_id);
/**
* @brief Starts traversing through list of supported event types.
* @see mv_surveillance_foreach_event_result_value_name_lic()
*/
int mv_surveillance_foreach_event_type_lic(
- mv_surveillance_event_type_cb callback,
- void *user_data);
+ mv_surveillance_event_type_cb callback,
+ void *user_data);
/**
* @brief Starts traversing through list of supported event result value names.
* @see mv_surveillance_get_result_value_lic()
*/
int mv_surveillance_foreach_event_result_value_name_lic(
- const char *event_type,
- mv_surveillance_event_result_value_name_cb callback,
- void *user_data);
+ const char *event_type,
+ mv_surveillance_event_result_value_name_cb callback,
+ void *user_data);
/**
* @brief Gets result value.
* @see mv_surveillance_query_events_lic()
*/
int mv_surveillance_get_result_value_lic(
- mv_surveillance_result_h result,
- const char *value_name,
- void *value);
+ mv_surveillance_result_h result,
+ const char *value_name,
+ void *value);
#ifdef __cplusplus
}
#endif /* __cplusplus */
-#endif /* __TIZEN_MEDIAVISION_SURVEILLANCE_LIC_H__ */
+#endif /* __MEDIA_VISION_SURVEILLANCE_LIC_H__ */
int mv_surveillance_subscribe_event_trigger_lic(
mv_surveillance_event_trigger_h event_trigger,
+ int video_stream_id,
mv_engine_config_h engine_cfg,
mv_surveillance_event_occurred_cb callback,
void *user_data)
}
int mv_surveillance_unsubscribe_event_trigger_lic(
- mv_surveillance_event_trigger_h event_trigger)
+ mv_surveillance_event_trigger_h event_trigger,
+ int video_stream_id)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
}
int mv_surveillance_foreach_event_result_value_name_lic(
const char *event_type,
- mv_surveillance_event_result_value_name_cb callback,
+ mv_surveillance_event_result_name_cb callback,
void *user_data)
{
return MEDIA_VISION_ERROR_NOT_SUPPORTED;
Name: capi-media-vision
Summary: Media Vision library for Tizen Native API
-Version: 0.3.20
-Release: 4
+Version: 0.3.21
+Release: 1
Group: Multimedia/Framework
License: Apache-2.0 and BSD-2.0
Source0: %{name}-%{version}.tar.gz
MEDIA_VISION_FUNCTION_ENTER();
if (image_path == NULL) {
- LOGE("image_path is NULL\n");
- return MEDIA_VISION_ERROR_INVALID_PATH;
+ LOGE("image_path is NULL");
+ return MEDIA_VISION_ERROR_INVALID_PATH;
}
if (type < MV_BARCODE_QR ||
MEDIA_VISION_NULL_ARG_CHECK(callback);
MEDIA_VISION_FUNCTION_ENTER();
- int ret =
- mv_engine_config_foreach_supported_attribute_c(callback, user_data);
+ int ret = mv_engine_config_foreach_supported_attribute_c(
+ callback, user_data);
MEDIA_VISION_FUNCTION_LEAVE();
return ret;
face_label);
#else
-ret = mv_face_recognition_model_add_open(
+ ret = mv_face_recognition_model_add_open(
source,
recognition_model,
example_location,
MEDIA_VISION_SUPPORT_CHECK(__mv_face_check_system_info_feature_supported());
MEDIA_VISION_INSTANCE_CHECK(recognition_model);
- MEDIA_VISION_FUNCTION_ENTER();
+ MEDIA_VISION_FUNCTION_ENTER();
int ret = MEDIA_VISION_ERROR_NONE;
#else
-ret = mv_face_recognition_model_reset_open(
+ ret = mv_face_recognition_model_reset_open(
recognition_model,
face_label);
#endif /* MEDIA_VISION_FACE_LICENSE_PORT */
-MEDIA_VISION_FUNCTION_LEAVE();
-return ret;
+ MEDIA_VISION_FUNCTION_LEAVE();
+ return ret;
}
int mv_face_tracking_model_create(
if (file_name == NULL) {
LOGE("File name is NULL. The file name has to be specified");
- return MEDIA_VISION_ERROR_INVALID_PATH;
+ return MEDIA_VISION_ERROR_INVALID_PATH;
}
MEDIA_VISION_FUNCTION_ENTER();
#ifdef MEDIA_VISION_FACE_LICENSE_PORT
-ret = mv_face_tracking_model_save_lic(
- file_name,
- tracking_model);
+ ret = mv_face_tracking_model_save_lic(
+ file_name,
+ tracking_model);
#else
ret = mv_face_tracking_model_save_open(
- file_name,
- tracking_model);
+ file_name,
+ tracking_model);
#endif /* MEDIA_VISION_FACE_LICENSE_PORT */
#ifdef MEDIA_VISION_FACE_LICENSE_PORT
ret = mv_face_tracking_model_load_lic(
- file_name,
- tracking_model);
+ file_name,
+ tracking_model);
#else
-ret = mv_face_tracking_model_load_open(
- file_name,
- tracking_model);
+ ret = mv_face_tracking_model_load_open(
+ file_name,
+ tracking_model);
#endif /* MEDIA_VISION_FACE_LICENSE_PORT */
#ifdef MEDIA_VISION_IMAGE_LICENSE_PORT
- /* Use licensed image functionality here. */
+ /* Use licensed image functionality here. */
int ret = mv_image_recognize_lic(source, image_objects,
number_of_objects, engine_cfg, recognized_cb, user_data);
#else
-/* Use open image functionality here. */
+ /* Use open image functionality here. */
int ret = mv_image_recognize_open(source, image_objects,
number_of_objects, engine_cfg, recognized_cb, user_data);
#ifdef MEDIA_VISION_IMAGE_LICENSE_PORT
/* Use licensed image functionality here. */
- int ret = mv_image_track_lic(source, image_tracking_model, engine_cfg, tracked_cb, user_data);
+ int ret = mv_image_track_lic(source, image_tracking_model, engine_cfg, tracked_cb, user_data);
#else
int mv_image_object_set_label(
mv_image_object_h image_object,
- int label)
+ int label)
{
MEDIA_VISION_SUPPORT_CHECK(__mv_image_check_system_info_feature_supported());
- MEDIA_VISION_INSTANCE_CHECK(image_object);
+ MEDIA_VISION_INSTANCE_CHECK(image_object);
MEDIA_VISION_FUNCTION_ENTER();
bool isFaceRecognitionSupported = false;
bool isImageRecognitionSupported = false;
- const int nRetVal1 = system_info_get_platform_bool("http://tizen.org/feature/vision.barcode_detection", &isBarcodeDetectionSupported);
+ const int nRetVal1 = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.barcode_detection",
+ &isBarcodeDetectionSupported);
if (nRetVal1 != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.barcode_detection");
return false;
}
- const int nRetVal2 = system_info_get_platform_bool("http://tizen.org/feature/vision.barcode_generation", &isBarcodeGenerationSupported);
+ const int nRetVal2 = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.barcode_generation",
+ &isBarcodeGenerationSupported);
if (nRetVal2 != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.barcode_generation");
return false;
}
- const int nRetVal3 = system_info_get_platform_bool("http://tizen.org/feature/vision.face_recognition", &isFaceRecognitionSupported);
+ const int nRetVal3 = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.face_recognition",
+ &isFaceRecognitionSupported);
if (nRetVal3 != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.face_recognition");
return false;
}
- const int nRetVal4 = system_info_get_platform_bool("http://tizen.org/feature/vision.image_recognition", &isImageRecognitionSupported);
+ const int nRetVal4 = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.image_recognition",
+ &isImageRecognitionSupported);
if (nRetVal4 != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.image_recognition");
{
bool isBarcodeDetectionSupported = false;
- const int nRetVal = system_info_get_platform_bool("http://tizen.org/feature/vision.barcode_detection", &isBarcodeDetectionSupported);
+ const int nRetVal = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.barcode_detection",
+ &isBarcodeDetectionSupported);
if (nRetVal != SYSTEM_INFO_ERROR_NONE) {
- LOGE("SYSTEM_INFO_ERROR: vision.barcode_detectio");
+ LOGE("SYSTEM_INFO_ERROR: vision.barcode_detection");
return false;
}
{
bool isBarcodeGenerationSupported = false;
- const int nRetVal = system_info_get_platform_bool("http://tizen.org/feature/vision.barcode_generation", &isBarcodeGenerationSupported);
+ const int nRetVal = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.barcode_generation",
+ &isBarcodeGenerationSupported);
if (nRetVal != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.barcode_generation");
{
bool isFaceRecognitionSupported = false;
- const int nRetVal = system_info_get_platform_bool("http://tizen.org/feature/vision.face_recognition", &isFaceRecognitionSupported);
+ const int nRetVal = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.face_recognition",
+ &isFaceRecognitionSupported);
if (nRetVal != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.face_recognition");
isFaceRecognitionSupported ?
LOGI("system_info_get_platform_bool returned "
- "Supported face recognition feature capability\n") :
+ "Supported face recognition feature capability\n") :
LOGE("system_info_get_platform_bool returned "
- "Unsupported face recognition feature capability\n");
+ "Unsupported face recognition feature capability\n");
return isFaceRecognitionSupported;
}
{
bool isImageRecognitionSupported = false;
- const int nRetVal = system_info_get_platform_bool("http://tizen.org/feature/vision.image_recognition", &isImageRecognitionSupported);
+ const int nRetVal = system_info_get_platform_bool(
+ "http://tizen.org/feature/vision.image_recognition",
+ &isImageRecognitionSupported);
if (nRetVal != SYSTEM_INFO_ERROR_NONE) {
LOGE("SYSTEM_INFO_ERROR: vision.image_recognition");
isImageRecognitionSupported ?
LOGI("system_info_get_platform_bool returned "
- "Supported image recognition feature capability\n") :
+ "Supported image recognition feature capability\n") :
LOGE("system_info_get_platform_bool returned "
- "Unsupported image recognition feature capability\n");
+ "Unsupported image recognition feature capability\n");
return isImageRecognitionSupported;
}
const int drawing_color[] = {255, 0, 0};
if (MEDIA_VISION_ERROR_NONE != draw_rectangle_on_buffer(
- minX,
- minY,
- maxX,
- maxY,
- 6,
- drawing_color,
- &image_data,
- draw_buffer)) {
+ minX,
+ minY,
+ maxX,
+ maxY,
+ 6,
+ drawing_color,
+ &image_data,
+ draw_buffer))
continue;
- }
}
}
if (file_name != NULL &&
- MEDIA_VISION_ERROR_NONE == save_image_from_buffer(file_name, draw_buffer, &image_data, 100)) {
+ MEDIA_VISION_ERROR_NONE == save_image_from_buffer(file_name, draw_buffer, &image_data, 100))
printf("Image was generated as %s\n", file_name);
- } else {
+ else
printf("ERROR: Failed to generate output file. Check file name and permissions. \n");
- }
printf("\n");
}
MEDIA_VISION_FUNCTION_ENTER();
if (model.message == NULL ||
- model.file_name == NULL) {
+ model.file_name == NULL) {
MEDIA_VISION_FUNCTION_LEAVE();
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
jpeg_file_name[strlen(model.file_name) + 4] = '\0';
}
- save_image_from_buffer(jpeg_file_name, data_buffer, &image_data, 100);
+ err = save_image_from_buffer(jpeg_file_name, data_buffer, &image_data, 100);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf("ERROR: Error occurred when try to save image from buffer."
+ "Error code: %i\n", err);
+ }
free(jpeg_file_name);
const int err2 = mv_destroy_source(source);
if (MEDIA_VISION_ERROR_NONE != err2) {
printf("ERROR: Error occurred when try to destroy Media Vision source."
- "Error code: %i\n", err2);
+ "Error code: %i\n", err2);
}
const int err3 = mv_destroy_engine_config(mv_engine_config);
mv_engine_config_foreach_supported_attribute(_mv_engine_config_supported_attribute, mv_engine_config);
- mv_engine_config_set_int_attribute(mv_engine_config, MV_BARCODE_DETECT_ATTR_TARGET, MV_BARCODE_DETECT_ATTR_TARGET_2D_BARCODE);
+ err = mv_engine_config_set_int_attribute(
+ mv_engine_config,
+ MV_BARCODE_DETECT_ATTR_TARGET,
+ MV_BARCODE_DETECT_ATTR_TARGET_2D_BARCODE);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf("ERROR: Errors were occurred during target attribute"
+ "configuration: %i\n", err);
+ }
mv_source_h source;
err = mv_create_source(&source);
while (true) {
int sel_opt = show_menu("Select colorspace to test detector on:", options, names, 11);
if (sel_opt < MEDIA_VISION_COLORSPACE_Y800 ||
- sel_opt > MEDIA_VISION_COLORSPACE_RGBA) {
+ sel_opt > MEDIA_VISION_COLORSPACE_RGBA)
continue;
- }
+
detect_model.colorspace = (mv_colorspace_e)sel_opt;
LOGI("User selection is %i", sel_opt);
break;
* limitations under the License.
*/
-#ifndef __IMAGEHELPER_H__
-#define __IMAGEHELPER_H__
+#ifndef __MEDIA_VISION_IMAGEHELPER_H__
+#define __MEDIA_VISION_IMAGEHELPER_H__
#include "mv_common.h"
* @brief ImageHelper class definition.
*/
-namespace cv
-{
- template<typename _Tp> class Scalar_;
- typedef Scalar_<double> Scalar;
+namespace cv {
+ template<typename _Tp> class Scalar_;
+ typedef Scalar_<double> Scalar;
- class VideoCapture;
- class VideoWriter;
+ class VideoCapture;
+ class VideoWriter;
}
-namespace MediaVision
-{
-namespace Common
-{
+namespace MediaVision {
+namespace Common {
/**
* @class ImageHelper
* @brief Helper class that provides set of useful methods
* for image management.
*/
-class ImageHelper
-{
+class ImageHelper {
public:
- /**
- * @brief Structure to keep information about width, height and colorspace of an image.
- */
- struct ImageData
- {
- unsigned int imageWidth; /**< Image width */
- unsigned int imageHeight; /**< Image height */
- mv_colorspace_e imageColorspace; /**< Image colorspace */
- };
-
- /**
- * @brief Loads image from file to the buffer of unsigned chars.
- *
- * @since_tizen 3.0
- * @param [in] filePath Path to the image file to be loaded to the
- * @a pDataBuffer
- * @param [out] pDataBuffer The buffer of unsigned chars where image data
- * will be stored
- * @param [out] pBufferSize The size of the @a pDataBuffer
- * @param [out] pImageData The image data (structure that keeps
- * information about image width, height,
- * and colorspace)
- * @return @c 0 on success, otherwise a negative error value
- *
- * @see ImageHelper::saveImageFromBuffer()
- * @see ImageHelper::destroyLoadedBuffer()
- */
- static int loadImageToBuffer(
- const char *filePath,
- unsigned char **pDataBuffer,
- unsigned long *pBufferSize,
- ImageData *pImageData);
-
- /**
- * @brief Saves image stored into @a pDataBuffer to the file in jpeg format.
- *
- * @since_tizen 3.0
- * @param [in] filePath The path to the file where image will be saved
- * @param [in] pDataBuffer Data buffer that contains image data
- * @param [in] imageData The image data (structure that keeps
- * information about image width, height,
- * and colorspace)
- * @param [in] quality Quality for the output jpeg file (0..100)
- * @return @c 0 on success, otherwise a negative error value
- *
- * @see ImageHelper::loadImageToBuffer()
- */
- static int saveImageFromBuffer(
- const char *filePath,
- unsigned char *pDataBuffer,
- const ImageData& imageData,
- int quality = 100);
-
- /**
- * @brief Destroys loaded buffer by loadImageToBuffer().
- *
- * @since_tizen 3.0
- * @param [out] pDataBuffer The buffer of unsigned chars where image data
- * will be stored
- * @return @c 0 on success, otherwise a negative error value
- *
- * @see ImageHelper::loadImageToBuffer()
- */
- static int destroyLoadedBuffer(
- unsigned char *pDataBuffer);
-
- /**
- * @brief Draws the rectangle of specified size on the image data buffer.
- *
- * @since_tizen 3.0
- * @param [in] topLeftVertexX The rectangle top left corner
- * x coordinate
- * @param [in] topLeftVertexY The rectangle top left corner
- * y coordinate
- * @param [in] bottomRightVertexX The rectangle bottom right corner
- * x coordinate
- * @param [in] bottomRightVertexY The rectangle bottom right corner
- * y coordinate
- * @param [in] thickness The thickness of the rectangle border
- * (negative value to draw filled rectangle)
- * @param [in] color The color of the rectangle border
- * @param [in] imageData The image data (structure that keeps
- * information about image width, height,
- * and colorspace). Colorspace has to be
- * @c MEDIA_VISION_COLORSPACE_RGB888
- * @param [in, out] pDataBuffer The pointer to the image data buffer
- * which will be used for rectangle drawing
- * @return @c 0 on success, otherwise a negative error value
- */
- static int drawRectangleOnBuffer(
- int topLeftVertexX,
- int topLeftVertexY,
- int bottomRightVertexX,
- int bottomRightVertexY,
- int thickness,
- const cv::Scalar& color,
- const ImageData& imageData,
- unsigned char *pDataBuffer);
-
- /**
- * @brief Draws the quadrangle of specified size on the image data buffer.
- *
- * @since_tizen 3.0
- * @param [in] location The quadrangle structure
- * @param [in] thickness The thickness of the quadrangle border
- * @param [in] color The color of the quadrangle border
- * @param [in] imageData The image data (structure that keeps
- * information about image width, height,
- * and colorspace). Colorspace has to be
- * @c MEDIA_VISION_COLORSPACE_RGB888
- * @param [in, out] pDataBuffer The pointer to the image data buffer
- * which will be used for quadrangle drawing
- * @return @c 0 on success, otherwise a negative error value
- */
- static int drawQuadrangleOnBuffer(
- mv_quadrangle_s location,
- int thickness,
- const cv::Scalar& color,
- const ImageData& imageData,
- unsigned char *pDataBuffer);
-
- /**
- * @brief Converts image data to the image data of RGB888 colorspace.
- *
- * @since_tizen 3.0
- * @param [in] pInBuffer Buffer with image data to be converted to
- * RGB888 colorspace
- * @param [in] imageData The image data (structure that keeps
- * information about image width, height,
- * and colorspace) for source image
- * @param [out] pOutBuffer Buffer with image data to be generated as
- * a result of the conversion
- * @return @c 0 on success, otherwise a negative error value
- */
- static int convertBufferToRGB888(
- const unsigned char *pInBuffer,
- const ImageData& imageData,
- unsigned char **pOutBuffer);
-
- /**
- * @brief Determines number of channels (components) for the colorspace.
- *
- * @since_tizen 3.0
- * @param [in] colorspace Colorspace for which number of
- * components will be determined
- * @param [out] pComponentsNumber Number of components to be determined
- * @return @c 0 on success, otherwise a negative error value
- */
- static int getNumberOfComponents(
- mv_colorspace_e colorspace,
- int *pComponentsNumber);
+ /**
+ * @brief Structure to keep information about width, height and colorspace of an image.
+ */
+ struct ImageData {
+ unsigned int imageWidth; /**< Image width */
+ unsigned int imageHeight; /**< Image height */
+ mv_colorspace_e imageColorspace; /**< Image colorspace */
+ };
+
+ /**
+ * @brief Loads image from file to the buffer of unsigned chars.
+ *
+ * @since_tizen 3.0
+ * @param [in] filePath Path to the image file to be loaded to the
+ * @a pDataBuffer
+ * @param [out] pDataBuffer The buffer of unsigned chars where image data
+ * will be stored
+ * @param [out] pBufferSize The size of the @a pDataBuffer
+ * @param [out] pImageData The image data (structure that keeps
+ * information about image width, height,
+ * and colorspace)
+ * @return @c 0 on success, otherwise a negative error value
+ *
+ * @see ImageHelper::saveImageFromBuffer()
+ * @see ImageHelper::destroyLoadedBuffer()
+ */
+ static int loadImageToBuffer(
+ const char *filePath,
+ unsigned char **pDataBuffer,
+ unsigned long *pBufferSize,
+ ImageData *pImageData);
+
+ /**
+ * @brief Saves image stored into @a pDataBuffer to the file in jpeg format.
+ *
+ * @since_tizen 3.0
+ * @param [in] filePath The path to the file where image will be saved
+ * @param [in] pDataBuffer Data buffer that contains image data
+ * @param [in] imageData The image data (structure that keeps
+ * information about image width, height,
+ * and colorspace)
+ * @param [in] quality Quality for the output jpeg file (0..100)
+ * @return @c 0 on success, otherwise a negative error value
+ *
+ * @see ImageHelper::loadImageToBuffer()
+ */
+ static int saveImageFromBuffer(
+ const char *filePath,
+ unsigned char *pDataBuffer,
+ const ImageData& imageData,
+ int quality = 100);
+
+ /**
+ * @brief Destroys loaded buffer by loadImageToBuffer().
+ *
+ * @since_tizen 3.0
+ * @param [out] pDataBuffer The buffer of unsigned chars where image data
+ * will be stored
+ * @return @c 0 on success, otherwise a negative error value
+ *
+ * @see ImageHelper::loadImageToBuffer()
+ */
+ static int destroyLoadedBuffer(unsigned char *pDataBuffer);
+
+ /**
+ * @brief Draws the rectangle of specified size on the image data buffer.
+ *
+ * @since_tizen 3.0
+ * @param [in] topLeftVertexX The rectangle top left corner
+ * x coordinate
+ * @param [in] topLeftVertexY The rectangle top left corner
+ * y coordinate
+ * @param [in] bottomRightVertexX The rectangle bottom right corner
+ * x coordinate
+ * @param [in] bottomRightVertexY The rectangle bottom right corner
+ * y coordinate
+ * @param [in] thickness The thickness of the rectangle border
+ * (negative value to draw filled rectangle)
+ * @param [in] color The color of the rectangle border
+ * @param [in] imageData The image data (structure that keeps
+ * information about image width, height,
+ * and colorspace). Colorspace has to be
+ * @c MEDIA_VISION_COLORSPACE_RGB888
+ * @param [in, out] pDataBuffer The pointer to the image data buffer
+ * which will be used for rectangle drawing
+ * @return @c 0 on success, otherwise a negative error value
+ */
+ static int drawRectangleOnBuffer(
+ int topLeftVertexX,
+ int topLeftVertexY,
+ int bottomRightVertexX,
+ int bottomRightVertexY,
+ int thickness,
+ const cv::Scalar& color,
+ const ImageData& imageData,
+ unsigned char *pDataBuffer);
+
+ /**
+ * @brief Draws the quadrangle of specified size on the image data buffer.
+ *
+ * @since_tizen 3.0
+ * @param [in] location The quadrangle structure
+ * @param [in] thickness The thickness of the quadrangle border
+ * @param [in] color The color of the quadrangle border
+ * @param [in] imageData The image data (structure that keeps
+ * information about image width, height,
+ * and colorspace). Colorspace has to be
+ * @c MEDIA_VISION_COLORSPACE_RGB888
+ * @param [in, out] pDataBuffer The pointer to the image data buffer
+ * which will be used for quadrangle drawing
+ * @return @c 0 on success, otherwise a negative error value
+ */
+ static int drawQuadrangleOnBuffer(
+ mv_quadrangle_s location,
+ int thickness,
+ const cv::Scalar& color,
+ const ImageData& imageData,
+ unsigned char *pDataBuffer);
+
+ /**
+ * @brief Converts image data to the image data of RGB888 colorspace.
+ *
+ * @since_tizen 3.0
+ * @param [in] pInBuffer Buffer with image data to be converted to
+ * RGB888 colorspace
+ * @param [in] imageData The image data (structure that keeps
+ * information about image width, height,
+ * and colorspace) for source image
+ * @param [out] pOutBuffer Buffer with image data to be generated as
+ * a result of the conversion
+ * @return @c 0 on success, otherwise a negative error value
+ */
+ static int convertBufferToRGB888(
+ const unsigned char *pInBuffer,
+ const ImageData& imageData,
+ unsigned char **pOutBuffer);
+
+ /**
+ * @brief Determines number of channels (components) for the colorspace.
+ *
+ * @since_tizen 3.0
+ * @param [in] colorspace Colorspace for which number of
+ * components will be determined
+ * @param [out] pComponentsNumber Number of components to be determined
+ * @return @c 0 on success, otherwise a negative error value
+ */
+ static int getNumberOfComponents(
+ mv_colorspace_e colorspace,
+ int *pComponentsNumber);
private:
- /**
- * @brief Converts buffer with image data in Y800 colorspace format
- * to the buffer with image data in RGB888 colorspace format.
- *
- * @since_tizen 3.0
- * @param [in] pInBuffer The buffer with data in Y800 colorspace format
- * @param [in] imageData The image data (structure that keeps
- * information about image width, height, and
- * colorspace) for source buffer
- * @param [out] pOutBuffer The buffer that will contain converted image
- * data in RGB888 colorspace format
- * @return @c 0 on success, otherwise a negative error value
- */
- static int convertY800ToRGB(
- const unsigned char *pInBuffer,
- const ImageData& imageData,
- unsigned char **pOutBuffer);
+ /**
+ * @brief Converts buffer with image data in Y800 colorspace format
+ * to the buffer with image data in RGB888 colorspace format.
+ *
+ * @since_tizen 3.0
+ * @param [in] pInBuffer The buffer with data in Y800 colorspace format
+ * @param [in] imageData The image data (structure that keeps
+ * information about image width, height, and
+ * colorspace) for source buffer
+ * @param [out] pOutBuffer The buffer that will contain converted image
+ * data in RGB888 colorspace format
+ * @return @c 0 on success, otherwise a negative error value
+ */
+ static int convertY800ToRGB(
+ const unsigned char *pInBuffer,
+ const ImageData& imageData,
+ unsigned char **pOutBuffer);
+
};
-} /* namespace Common */
-} /* namespace MediaVision */
+} /* Common */
+} /* MediaVision */
-#endif /* __IMAGEHELPER_H__ */
+#endif /* __MEDIA_VISION_IMAGEHELPER_H__ */
* limitations under the License.
*/
-#ifndef __IMAGE_HELPER_H__
-#define __IMAGE_HELPER_H__
+#ifndef __MEDIA_VISION_IMAGE_HELPER_H__
+#define __MEDIA_VISION_IMAGE_HELPER_H__
#ifdef __cplusplus
extern "C" {
*
* @since_tizen 3.0
*/
-typedef struct
-{
- unsigned int image_width; /**< Image width */
- unsigned int image_height; /**< Image height */
- mv_colorspace_e image_colorspace; /**< Image colorspace */
+typedef struct {
+ unsigned int image_width; /**< Image width */
+ unsigned int image_height; /**< Image height */
+ mv_colorspace_e image_colorspace; /**< Image colorspace */
} image_data_s;
/**
* @see destroy_loaded_buffer()
*/
int load_image_to_buffer(
- const char *file_path,
- unsigned char **data_buffer,
- unsigned long *buffer_size,
- image_data_s *image_data);
+ const char *file_path,
+ unsigned char **data_buffer,
+ unsigned long *buffer_size,
+ image_data_s *image_data);
/**
* @brief Saves image stored into @a pDataBuffer to the file in jpeg format.
* @see load_image_to_buffer()
*/
int save_image_from_buffer(
- const char *file_path,
- unsigned char *data_buffer,
- const image_data_s *image_data,
- int quality);
+ const char *file_path,
+ unsigned char *data_buffer,
+ const image_data_s *image_data,
+ int quality);
/**
* @brief Destroys loaded buffer by load_image_to_buffer().
* @return @c 0 on success, otherwise a negative error value
*/
int draw_rectangle_on_buffer(
- int tl_vertex_x,
- int tl_vertex_y,
- int br_vertex_x,
- int br_vertex_y,
- int thickness,
- const int rgb_color[3],
- const image_data_s *image_data,
- unsigned char *data_buffer);
+ int tl_vertex_x,
+ int tl_vertex_y,
+ int br_vertex_x,
+ int br_vertex_y,
+ int thickness,
+ const int rgb_color[3],
+ const image_data_s *image_data,
+ unsigned char *data_buffer);
/**
* @brief Draws the quadrangle of specified size on the image data buffer.
* @return @c 0 on success, otherwise a negative error value
*/
int draw_quadrangle_on_buffer(
- mv_quadrangle_s location,
- int thickness,
- const int rgb_color[3],
- const image_data_s *image_data,
- unsigned char *data_buffer);
+ mv_quadrangle_s location,
+ int thickness,
+ const int rgb_color[3],
+ const image_data_s *image_data,
+ unsigned char *data_buffer);
/**
* @brief Converts image data to the image data of RGB888 colorspace.
* @return @c 0 on success, otherwise a negative error value
*/
int convert_buffer_to_RGB888(
- const unsigned char *in_buffer,
- const image_data_s *image_data,
- unsigned char **out_buffer);
+ const unsigned char *in_buffer,
+ const image_data_s *image_data,
+ unsigned char **out_buffer);
/**
* @brief Determines number of channels (components) for the colorspace.
* @return @c 0 on success, otherwise a negative error value
*/
int get_number_of_components(
- mv_colorspace_e colorspace,
- int *components_number);
+ mv_colorspace_e colorspace,
+ int *components_number);
#ifdef __cplusplus
}
* @brief The ImageHelper class methods implementation.
*/
-namespace MediaVision
-{
-namespace Common
-{
+namespace MediaVision {
+namespace Common {
-namespace
-{
+namespace {
-static const int OpenCVChannels = 3;
-static const mv_colorspace_e OpenCVColor = MEDIA_VISION_COLORSPACE_RGB888;
-static const int QuadrangleVertices = 4;
+const int OPEN_CV_CHANNELS = 3;
+const mv_colorspace_e OPEN_CV_COLOR = MEDIA_VISION_COLORSPACE_RGB888;
+const int QUADRANGLE_VERTICES = 4;
std::vector<std::string> getJPGExtensions()
{
pImageData->imageWidth = image.cols;
pImageData->imageHeight = image.rows;
- pImageData->imageColorspace = OpenCVColor;
+ pImageData->imageColorspace = OPEN_CV_COLOR;
return MEDIA_VISION_ERROR_NONE;
}
if (filePath == NULL || pDataBuffer == NULL)
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- static const std::string defaultFilePath = "out";
- static const std::vector<std::string> jpgExtensions = getJPGExtensions();
+ static const std::string DEFAULT_FILE_PATH = "out";
+ static const std::vector<std::string> JPG_EXTENSIONS = getJPGExtensions();
bool rightExtensionFlag = false;
std::string resultFilePath(filePath);
if (resultFilePath.empty()) {
- resultFilePath = defaultFilePath;
+ resultFilePath = DEFAULT_FILE_PATH;
} else {
- for (size_t extNum = 0; extNum < jpgExtensions.size(); ++extNum) {
- if (resultFilePath.size() >= jpgExtensions[extNum].size()) {
+ for (size_t extNum = 0; extNum < JPG_EXTENSIONS.size(); ++extNum) {
+ if (resultFilePath.size() >= JPG_EXTENSIONS[extNum].size()) {
std::string givenExtension = resultFilePath.substr(
- resultFilePath.length() - jpgExtensions[extNum].size(),
- jpgExtensions[extNum].size());
+ resultFilePath.length() - JPG_EXTENSIONS[extNum].size(),
+ JPG_EXTENSIONS[extNum].size());
std::transform(
- givenExtension.begin(), givenExtension.end(),
- givenExtension.begin(), ::tolower);
+ givenExtension.begin(), givenExtension.end(),
+ givenExtension.begin(), ::tolower);
- if (givenExtension == jpgExtensions[extNum]) {
+ if (givenExtension == JPG_EXTENSIONS[extNum]) {
rightExtensionFlag = true;
break;
}
}
}
if (!rightExtensionFlag)
- resultFilePath += jpgExtensions[0];
+ resultFilePath += JPG_EXTENSIONS[0];
if (quality <= 0 || quality > 100)
quality = 100;
unsigned int width = imageData.imageWidth;
unsigned int height = imageData.imageHeight;
- /* Type of conversion from given colorspace to BGR */
- int conversionType = -1;
+ int conversionType = -1; // Type of conversion from given colorspace to BGR
unsigned int channelsNumber = 0;
switch (imageData.imageColorspace) {
case MEDIA_VISION_COLORSPACE_INVALID:
int ImageHelper::destroyLoadedBuffer(unsigned char *pDataBuffer)
{
- if (!pDataBuffer)
+ if (!pDataBuffer) {
return MEDIA_VISION_ERROR_NONE;
+ }
delete [] pDataBuffer;
pDataBuffer = NULL;
if (NULL == pDataBuffer)
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- cv::Mat cvImage(imageData.imageHeight, imageData.imageWidth, CV_8UC(OpenCVChannels), pDataBuffer);
+ cv::Mat cvImage(imageData.imageHeight, imageData.imageWidth, CV_8UC(OPEN_CV_CHANNELS), pDataBuffer);
cv::rectangle(
- cvImage,
- cv::Point(topLeftVertexX, topLeftVertexY),
- cv::Point(bottomRightVertexX, bottomRightVertexY),
- color,
- thickness);
+ cvImage,
+ cv::Point(topLeftVertexX, topLeftVertexY),
+ cv::Point(bottomRightVertexX, bottomRightVertexY),
+ color,
+ thickness);
return MEDIA_VISION_ERROR_NONE;
}
int ImageHelper::drawQuadrangleOnBuffer(
- mv_quadrangle_s location,
- int thickness,
- const cv::Scalar& color,
- const ImageData& imageData,
- unsigned char *pDataBuffer)
+ mv_quadrangle_s location,
+ int thickness,
+ const cv::Scalar& color,
+ const ImageData& imageData,
+ unsigned char *pDataBuffer)
{
if (NULL == pDataBuffer)
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- cv::Mat cvImage(imageData.imageHeight, imageData.imageWidth, CV_8UC(OpenCVChannels), pDataBuffer);
- for (int i = 0; i < QuadrangleVertices; ++i) {
+ cv::Mat cvImage(imageData.imageHeight, imageData.imageWidth, CV_8UC(OPEN_CV_CHANNELS), pDataBuffer);
+ for (int i = 0; i < QUADRANGLE_VERTICES; ++i) {
cv::line(
- cvImage,
- cv::Point(location.points[i].x, location.points[i].y),
- cv::Point(location.points[(i + 1) % QuadrangleVertices].x,
- location.points[(i + 1) % QuadrangleVertices].y),
- color,
- thickness);
+ cvImage,
+ cv::Point(location.points[i].x, location.points[i].y),
+ cv::Point(location.points[(i + 1) % QUADRANGLE_VERTICES].x,
+ location.points[(i + 1) % QUADRANGLE_VERTICES].y),
+ color,
+ thickness);
}
return MEDIA_VISION_ERROR_NONE;
}
return MEDIA_VISION_ERROR_NONE;
}
-} /* namespace Common */
-} /* namespace MediaVision */
+} /* Common */
+} /* MediaVision */
image_data_s convertToCData(ImageHelper::ImageData data)
{
- image_data_s ret;
- ret.image_width = data.imageWidth;
- ret.image_height = data.imageHeight;
- ret.image_colorspace = data.imageColorspace;
- return ret;
+ image_data_s ret;
+ ret.image_width = data.imageWidth;
+ ret.image_height = data.imageHeight;
+ ret.image_colorspace = data.imageColorspace;
+ return ret;
}
ImageHelper::ImageData convertToCppData(image_data_s data)
{
- ImageHelper::ImageData ret;
- ret.imageWidth = data.image_width;
- ret.imageHeight = data.image_height;
- ret.imageColorspace = data.image_colorspace;
- return ret;
+ ImageHelper::ImageData ret;
+ ret.imageWidth = data.image_width;
+ ret.imageHeight = data.image_height;
+ ret.imageColorspace = data.image_colorspace;
+ return ret;
}
int load_image_to_buffer(
- const char *file_path,
- unsigned char **data_buffer,
- unsigned long *buffer_size,
- image_data_s *image_data)
+ const char *file_path,
+ unsigned char **data_buffer,
+ unsigned long *buffer_size,
+ image_data_s *image_data)
{
- if (image_data == NULL)
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ if (image_data == NULL)
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- int err;
- ImageHelper::ImageData imageData;
- err = ImageHelper::loadImageToBuffer(file_path, data_buffer, buffer_size, &imageData);
+ int err;
+ ImageHelper::ImageData imageData;
+ err = ImageHelper::loadImageToBuffer(file_path, data_buffer, buffer_size, &imageData);
- if (err == MEDIA_VISION_ERROR_NONE)
- *image_data = convertToCData(imageData);
+ if (err == MEDIA_VISION_ERROR_NONE)
+ *image_data = convertToCData(imageData);
- return err;
+ return err;
}
int save_image_from_buffer(
- const char *file_path,
- unsigned char *data_buffer,
- const image_data_s *image_data,
- int quality)
+ const char *file_path,
+ unsigned char *data_buffer,
+ const image_data_s *image_data,
+ int quality)
{
- if (image_data == NULL)
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ if (image_data == NULL)
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- ImageHelper::ImageData imageData = convertToCppData(*image_data);
- return ImageHelper::saveImageFromBuffer(file_path, data_buffer, imageData, quality);
+ ImageHelper::ImageData imageData = convertToCppData(*image_data);
+ return ImageHelper::saveImageFromBuffer(file_path, data_buffer, imageData, quality);
}
int destroy_loaded_buffer(unsigned char *data_buffer)
}
int draw_rectangle_on_buffer(
- int tl_vertex_x,
- int tl_vertex_y,
- int br_vertex_x,
- int br_vertex_y,
- int thickness,
- const int rgb_color[3],
- const image_data_s *image_data,
- unsigned char *data_buffer)
+ int tl_vertex_x,
+ int tl_vertex_y,
+ int br_vertex_x,
+ int br_vertex_y,
+ int thickness,
+ const int rgb_color[3],
+ const image_data_s *image_data,
+ unsigned char *data_buffer)
{
- if (image_data == NULL)
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ if (image_data == NULL)
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- ImageHelper::ImageData imageData = convertToCppData(*image_data);
+ ImageHelper::ImageData imageData = convertToCppData(*image_data);
- cv::Scalar color(rgb_color[2], rgb_color[1], rgb_color[0]);
+ cv::Scalar color(rgb_color[2], rgb_color[1], rgb_color[0]);
- return ImageHelper::drawRectangleOnBuffer(
- tl_vertex_x, tl_vertex_y,
- br_vertex_x, br_vertex_y,
- thickness,
- color,
- imageData, data_buffer);
+ return ImageHelper::drawRectangleOnBuffer(
+ tl_vertex_x, tl_vertex_y,
+ br_vertex_x, br_vertex_y,
+ thickness,
+ color,
+ imageData, data_buffer);
}
int draw_quadrangle_on_buffer(
- mv_quadrangle_s location,
- int thickness,
- const int rgb_color[3],
- const image_data_s *image_data,
- unsigned char *data_buffer)
+ mv_quadrangle_s location,
+ int thickness,
+ const int rgb_color[3],
+ const image_data_s *image_data,
+ unsigned char *data_buffer)
{
- if (image_data == NULL)
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ if (image_data == NULL)
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- ImageHelper::ImageData imageData = convertToCppData(*image_data);
+ ImageHelper::ImageData imageData = convertToCppData(*image_data);
- cv::Scalar color(rgb_color[2], rgb_color[1], rgb_color[0]);
+ cv::Scalar color(rgb_color[2], rgb_color[1], rgb_color[0]);
- return ImageHelper::drawQuadrangleOnBuffer(
- location,
- thickness,
- color,
- imageData,
- data_buffer);
+ return ImageHelper::drawQuadrangleOnBuffer(
+ location,
+ thickness,
+ color,
+ imageData,
+ data_buffer);
}
int convert_buffer_to_RGB888(
- const unsigned char *in_buffer,
- const image_data_s *image_data,
- unsigned char **out_buffer)
+ const unsigned char *in_buffer,
+ const image_data_s *image_data,
+ unsigned char **out_buffer)
{
- if (image_data == NULL)
- return MEDIA_VISION_ERROR_INVALID_PARAMETER;
+ if (image_data == NULL)
+ return MEDIA_VISION_ERROR_INVALID_PARAMETER;
- ImageHelper::ImageData imageData = convertToCppData(*image_data);
- return ImageHelper::convertBufferToRGB888(in_buffer, imageData, out_buffer);
+ ImageHelper::ImageData imageData = convertToCppData(*image_data);
+ return ImageHelper::convertBufferToRGB888(in_buffer, imageData, out_buffer);
}
int get_number_of_components(
- mv_colorspace_e colorspace,
- int *components_number)
+ mv_colorspace_e colorspace,
+ int *components_number)
{
- return ImageHelper::getNumberOfComponents(colorspace, components_number);
+ return ImageHelper::getNumberOfComponents(colorspace, components_number);
}
* limitations under the License.
*/
-#ifndef __MV_TESTSUITE_COMMON_H__
-#define __MV_TESTSUITE_COMMON_H__
+#ifndef __MEDIA_VISION_MV_TESTSUITE_COMMON_H__
+#define __MEDIA_VISION_MV_TESTSUITE_COMMON_H__
#include "mv_common.h"
const char *path_to_image,
mv_source_h source);
-#endif /* __MV_TESTSUITE_COMMON_H__ */
+#endif /* __MEDIA_VISION_MV_TESTSUITE_COMMON_H__ */
* limitations under the License.
*/
-#ifndef __MV_LOG_CFG_H__
-#define __MV_LOG_CFG_H__
+#ifndef __MEDIA_VISION_MV_LOG_CFG_H__
+#define __MEDIA_VISION_MV_LOG_CFG_H__
#include <dlog.h>
#endif
-#endif /* __MV_LOG_CFG_H__ */
+#endif /* __MEDIA_VISON_MV_LOG_CFG_H__ */
GstVideoInfo info;
if (reader == NULL || path == NULL ||
- image_data == NULL || fps == NULL) {
+ image_data == NULL || fps == NULL) {
LOGE("NULL pointer passed");
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
}
/* Set input file location from path */
g_object_set(G_OBJECT(handle->filesrc),
- "location", path,
- NULL);
+ "location", path,
+ NULL);
/* Start playback */
if (_mv_video_reader_state_change(handle, GST_STATE_PLAYING)) {
handle->fps = fps;
g_object_set(G_OBJECT(handle->filesink),
- "location", path,
- NULL);
+ "location", path,
+ NULL);
err = _mv_video_writer_link_internals(handle);
if (MEDIA_VISION_ERROR_NONE != err) {
gst_buffer_unmap(buffer, &info);
if (GST_FLOW_OK !=
- gst_app_src_push_buffer(handle->appsrc, buffer)) {
+ gst_app_src_push_buffer(handle->appsrc, buffer)) {
LOGE("Failed to push buffer to appsrc");
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
reader->appsink = gst_element_factory_make("appsink", "appsink");
if ((!reader->pl) ||
- (!reader->filesrc) ||
- (!reader->decodebin) ||
- (!reader->videoconvert) ||
- (!reader->queue) ||
- (!reader->appsink)) {
+ (!reader->filesrc) ||
+ (!reader->decodebin) ||
+ (!reader->videoconvert) ||
+ (!reader->queue) ||
+ (!reader->appsink)) {
LOGE("Unable to create video read pipeline elements");
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
gst_bin_add_many(GST_BIN(reader->pl),
- reader->filesrc,
- reader->decodebin,
- reader->videoconvert,
- reader->queue,
- reader->appsink,
- NULL);
+ reader->filesrc,
+ reader->decodebin,
+ reader->videoconvert,
+ reader->queue,
+ reader->appsink,
+ NULL);
return MEDIA_VISION_ERROR_NONE;
}
/* Decodebin pad will be linked during state change */
g_signal_connect(reader->decodebin,
- "pad-added",
- G_CALLBACK(cb_newpad),
- reader);
+ "pad-added",
+ G_CALLBACK(cb_newpad),
+ reader);
if (!gst_element_link_many(reader->videoconvert,
- reader->queue,
- reader->appsink,
- NULL)) {
+ reader->queue, reader->appsink, NULL)) {
+
LOGE("Unable to link videocovnert-queue-appsink");
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
caps = gst_caps_new_simple("video/x-raw",
- "format", G_TYPE_STRING, "RGB",
- NULL);
+ "format", G_TYPE_STRING, "RGB",
+ NULL);
gst_app_sink_set_caps(GST_APP_SINK(reader->appsink), caps);
gst_caps_unref(caps);
/* Configure appsink */
gst_app_sink_set_emit_signals(GST_APP_SINK(reader->appsink), TRUE);
g_signal_connect(reader->appsink,
- "new-sample",
- G_CALLBACK(appsink_newsample),
- reader);
+ "new-sample",
+ G_CALLBACK(appsink_newsample),
+ reader);
g_signal_connect(reader->appsink,
- "eos",
- G_CALLBACK(appsink_eos),
- reader);
+ "eos",
+ G_CALLBACK(appsink_eos),
+ reader);
g_object_set(G_OBJECT(reader->appsink),
- "drop", TRUE,
- "enable-last-sample", TRUE,
- "sync", FALSE,
- NULL);
+ "drop", TRUE,
+ "enable-last-sample", TRUE,
+ "sync", FALSE,
+ NULL);
/* pad probe */
pad = gst_element_get_static_pad(reader->queue, "src");
gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_BUFFER,
- (GstPadProbeCallback)pad_probe_data_cb, reader, NULL);
+ (GstPadProbeCallback)pad_probe_data_cb, reader, NULL);
gst_object_unref(pad);
return MEDIA_VISION_ERROR_NONE;
GstState pipeline_state = GST_STATE_NULL;
state_ret = gst_element_set_state(handle->pl,
- state);
+ state);
if (GST_STATE_CHANGE_FAILURE == state_ret) {
LOGE("Set state failure");
}
LOGI("Set state [%d], change return [%d]",
- state, state_ret);
+ state, state_ret);
state_ret = gst_element_get_state(handle->pl,
- &pipeline_state,
- NULL,
- GST_CLOCK_TIME_NONE);
+ &pipeline_state,
+ NULL,
+ GST_CLOCK_TIME_NONE);
if (GST_STATE_CHANGE_FAILURE == state_ret) {
LOGE("get state failure");
writer->filesink = gst_element_factory_make("filesink", "filesink");
if ((!writer->pl) ||
- (!writer->appsrc) ||
- (!writer->capsfilter) ||
- (!writer->videoconvert) ||
- (!writer->encoder) ||
- (!writer->queue) ||
- (!writer->muxer) ||
- (!writer->filesink)) {
+ (!writer->appsrc) ||
+ (!writer->capsfilter) ||
+ (!writer->videoconvert) ||
+ (!writer->encoder) ||
+ (!writer->queue) ||
+ (!writer->muxer) ||
+ (!writer->filesink)) {
LOGE("Unable to create video read pipeline elements\n");
return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
}
g_object_set(G_OBJECT(writer->appsrc),
- "max-bytes", 0,
- "blocksize", writer->buffer_size,
- "stream-type", 0,
- "format", GST_FORMAT_BYTES,
- NULL);
+ "max-bytes", 0,
+ "blocksize", writer->buffer_size,
+ "stream-type", 0,
+ "format", GST_FORMAT_BYTES,
+ NULL);
if (_mv_video_writer_state_change(writer,
- GST_STATE_PLAYING)) {
- LOGE("Unable to change video writer state");
- return MEDIA_VISION_ERROR_INVALID_OPERATION;
+ GST_STATE_PLAYING)) {
+ LOGE("Unable to change video writer state");
+ return MEDIA_VISION_ERROR_INVALID_OPERATION;
}
return MEDIA_VISION_ERROR_NONE;
GstState pipeline_state = GST_STATE_NULL;
state_ret = gst_element_set_state(handle->pl,
- state);
+ state);
if (GST_STATE_CHANGE_FAILURE == state_ret) {
LOGE("Set state failure");
}
static GstPadProbeReturn pad_probe_data_cb(
- GstPad *pad,
- GstPadProbeInfo *info,
- gpointer user_data)
+ GstPad *pad,
+ GstPadProbeInfo *info,
+ gpointer user_data)
{
if (user_data == NULL)
return GST_PAD_PROBE_PASS;
* limitations under the License.
*/
-#ifndef __MV_VIDEO_HELPER_H__
-#define __MV_VIDEO_HELPER_H__
+#ifndef __MEDIA_VISION_MV_VIDEO_HELPER_H__
+#define __MEDIA_VISION_MV_VIDEO_HELPER_H__
#include "mv_common.h"
#include "image_helper.h"
* @see mv_video_reader_set_new_sample_cb()
*/
typedef void (*mv_video_reader_new_sample_cb) (
- char *buffer,
- unsigned int buffer_size,
- image_data_s image_data,
- void *user_data);
+ char *buffer,
+ unsigned int buffer_size,
+ image_data_s image_data,
+ void *user_data);
/**
* @brief Called when stream from video reader is finished.
* @see mv_video_reader_set_eos_cb()
*/
typedef void (*mv_video_reader_eos_cb) (
- void *user_data);
+ void *user_data);
/**
* @brief Creates a video reader handle.
* @see mv_destroy_video_reader()
*/
int mv_create_video_reader(
- mv_video_reader_h *reader);
+ mv_video_reader_h *reader);
/**
* @brief Destroys the video reader handle and releases all its resources.
* @see mv_create_video_reader()
*/
int mv_destroy_video_reader(
- mv_video_reader_h reader);
+ mv_video_reader_h reader);
/**
* @brief Loads video from file.
* @pre Create a video reader handle by calling @ref mv_create_video_reader()
*/
int mv_video_reader_load(
- mv_video_reader_h reader,
- const char *path,
- image_data_s *image_data,
- unsigned int *fps);
+ mv_video_reader_h reader,
+ const char *path,
+ image_data_s *image_data,
+ unsigned int *fps);
/**
* @brief Starts reader playback.
* @post Stop reader playback by calling @ref mv_video_reader_stop()
*/
int mv_video_reader_start(
- mv_video_reader_h reader);
+ mv_video_reader_h reader);
/**
* @brief Stops reader playback.
* and call @ref mv_video_reader_load()
*/
int mv_video_reader_stop(
- mv_video_reader_h reader);
+ mv_video_reader_h reader);
/**
* @brief Sets new sample callback to video reader.
*
*/
int mv_video_reader_set_new_sample_cb(
- mv_video_reader_h reader,
- mv_video_reader_new_sample_cb callback,
- void *user_data);
+ mv_video_reader_h reader,
+ mv_video_reader_new_sample_cb callback,
+ void *user_data);
/**
* @brief Sets end of stream callback to video reader.
*
*/
int mv_video_reader_set_eos_cb(
- mv_video_reader_h reader,
- mv_video_reader_eos_cb callback,
- void *user_data);
+ mv_video_reader_h reader,
+ mv_video_reader_eos_cb callback,
+ void *user_data);
/**
* @brief Creates a video writer handle.
* @see mv_destroy_video_writer()
*/
int mv_create_video_writer(
- mv_video_writer_h *writer);
+ mv_video_writer_h *writer);
/**
* @brief Destroys the video writer handle and releases all its resources.
* @see mv_create_video_writer()
*/
int mv_destroy_video_writer(
- mv_video_writer_h writer);
+ mv_video_writer_h writer);
/**
* @brief Sets path and frame size for video file to be stored.
* @pre Create a video writer handle by calling @ref mv_create_video_writer()
*/
int mv_video_writer_init(
- mv_video_writer_h writer,
- const char *path,
- image_data_s image_data,
- unsigned int fps);
+ mv_video_writer_h writer,
+ const char *path,
+ image_data_s image_data,
+ unsigned int fps);
/**
* @brief Writes consequently video frame to the file.
* and initialize video with @ref mv_video_writer_init()
*/
int mv_video_writer_write_frame(
- mv_video_writer_h writer,
- unsigned char *frame);
+ mv_video_writer_h writer,
+ unsigned char *frame);
-#endif /* __MV_VIDEO_HELPER_H__ */
+#endif /* __MEDIA_VISION_MV_VIDEO_HELPER_H__ */
unsigned int buf_size = 0;
image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
if (MEDIA_VISION_ERROR_NONE != mv_source_get_buffer(source, &out_buffer, &buf_size) ||
- MEDIA_VISION_ERROR_NONE != mv_source_get_width(source, &(image_data.image_width)) ||
- MEDIA_VISION_ERROR_NONE != mv_source_get_height(source, &(image_data.image_height)) ||
- MEDIA_VISION_ERROR_NONE != mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
- user_data == NULL) {
+ MEDIA_VISION_ERROR_NONE != mv_source_get_width(source, &(image_data.image_width)) ||
+ MEDIA_VISION_ERROR_NONE != mv_source_get_height(source, &(image_data.image_height)) ||
+ MEDIA_VISION_ERROR_NONE != mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
+ user_data == NULL) {
printf("ERROR: Creating out image is impossible.\n");
} else {
file_name = (char*)user_data;
int i = 0;
for (i = 0; i < number_of_faces; ++i) {
printf("\Face %i : x - %i, y - %i, width - %i, height - %i ", i,
- faces_locations[i].point.x, faces_locations[i].point.y,
+ faces_locations[i].point.x, faces_locations[i].point.y,
faces_locations[i].width, faces_locations[i].height);
if (Perform_eye_condition_recognize) {
if (MEDIA_VISION_ERROR_NONE != mv_face_eye_condition_recognize(
- source,
- engine_cfg,
- faces_locations[i],
- eye_condition_cb,
- user_data)) {
+ source,
+ engine_cfg,
+ faces_locations[i],
+ eye_condition_cb,
+ user_data)) {
printf(TEXT_RED "\nEye condition recognition for %i face failed"
TEXT_RESET "\n", i);
}
if (Perform_facial_expression_recognize) {
if (MEDIA_VISION_ERROR_NONE != mv_face_facial_expression_recognize(
- source,
- engine_cfg,
- faces_locations[i],
- face_expression_cb,
- user_data)) {
+ source,
+ engine_cfg,
+ faces_locations[i],
+ face_expression_cb,
+ user_data)) {
printf(TEXT_RED "\nFacial expression recognition for %i "
"face failed" TEXT_RESET "\n", i);
}
const int rectangle_thickness = 3;
const int drawing_color[] = {255, 0, 0};
if (MEDIA_VISION_ERROR_NONE != draw_rectangle_on_buffer(
- faces_locations[i].point.x,
- faces_locations[i].point.y,
- faces_locations[i].point.x + faces_locations[i].width,
- faces_locations[i].point.y + faces_locations[i].height,
- rectangle_thickness,
- drawing_color,
- &image_data,
- out_buffer)) {
+ faces_locations[i].point.x,
+ faces_locations[i].point.y,
+ faces_locations[i].point.x + faces_locations[i].width,
+ faces_locations[i].point.y + faces_locations[i].height,
+ rectangle_thickness,
+ drawing_color,
+ &image_data,
+ out_buffer)) {
continue;
}
}
"faces from images with face detection functionality.\n"
TEXT_RESET);
while (-1 == input_string(
- "Input file name with the face to be recognized:",
- 1024,
- &(in_file_name))) {
+ "Input file name with the face to be recognized:",
+ 1024,
+ &(in_file_name)))
printf(TEXT_RED "Incorrect input! Try again." TEXT_RESET "\n");
- }
err = load_mv_source_from_file(in_file_name, source);
TEXT_RESET);
while (-1 == input_int("Specify top left ROI x coordinate:",
- INT_MIN, INT_MAX, &(roi->point.x))) {
+ INT_MIN, INT_MAX, &(roi->point.x)))
printf("Incorrect input! Try again.\n");
- }
while (-1 == input_int("Specify top left ROI y coordinate:",
- INT_MIN, INT_MAX, &(roi->point.y))) {
+ INT_MIN, INT_MAX, &(roi->point.y)))
printf("Incorrect input! Try again.\n");
- }
while (-1 == input_int("Specify top left ROI width:",
- INT_MIN, INT_MAX, &(roi->width))) {
+ INT_MIN, INT_MAX, &(roi->width)))
printf("Incorrect input! Try again.\n");
- }
while (-1 == input_int("Specify top left ROI height:",
- INT_MIN, INT_MAX, &(roi->height))) {
+ INT_MIN, INT_MAX, &(roi->height)))
printf("Incorrect input! Try again.\n");
- }
} else {
roi = NULL;
}
printf("Incorrect input! You can use %i-%i labels only. Try again.\n",
MIN_ALLOWED_LABEL,
MAX_ALLOWED_LABEL);
- }
+ }
}
err = mv_face_recognition_model_add(source, model, roi, *face_label);
char *out_file_name = NULL;
while (input_string("Input file name to save the model:",
- 1024, &(out_file_name)) == -1) {
+ 1024, &(out_file_name)) == -1)
printf(TEXT_RED "Incorrect input! Try again." TEXT_RESET "\n");
- }
const int err = mv_face_recognition_model_save(out_file_name, model);
char *in_file_name = NULL;
while (input_string("Input file name to load model from:",
- 1024, &(in_file_name)) == -1) {
+ 1024, &(in_file_name)) == -1)
printf(TEXT_RED "Incorrect input! Try again." TEXT_RESET "\n");
- }
const int err = mv_face_recognition_model_load(in_file_name, model);
int dir_n = 0;
int label_count = 0;
while (show_confirm_dialog("Add test images directory?") &&
- dir_n < max_dir_allowed) {
+ dir_n < max_dir_allowed) {
char *in_file_name = NULL;
while (-1 == input_string("Specify path to the test images directory:", 1024, &(in_file_name)))
printf(TEXT_RED "Incorrect input! Try again." TEXT_RESET "\n");
if (MEDIA_VISION_ERROR_NONE != err) {
printf(TEXT_RED "ERROR: Errors were occurred during creating the video "
"reader! Error code: %i\n" TEXT_RESET, err);
- return err;
+ return err;
}
err = mv_video_reader_set_new_sample_cb(
snprintf(str_prompt, 100, "Specify point %i x coordinate: x%i = ",
idx - 1, idx);
while (-1 == input_int(str_prompt, INT_MIN, INT_MAX,
- &(roi.points[idx - 1].x))) {
+ &(roi.points[idx - 1].x)))
printf("Incorrect input! Try again.\n");
- }
+
snprintf(str_prompt, 100, "Specify point %i y coordinate: y%i = ",
idx - 1, idx);
while (-1 == input_int(str_prompt, INT_MIN, INT_MAX,
- &(roi.points[idx - 1].y))) {
+ &(roi.points[idx - 1].y)))
printf("Incorrect input! Try again.\n");
- }
}
err = mv_face_tracking_model_prepare(
return err;
}
-static char *track_output_dir = NULL;
-
-static int track_frame_counter = 0;
+typedef struct {
+ mv_face_tracking_model_h target;
+ mv_video_writer_h writer;
+ int frame_number;
+} tracking_cb_data;
void track_cb(
mv_source_h source,
double confidence,
void *user_data)
{
+ tracking_cb_data *cb_data = user_data;
static bool track_catch_face = false;
- ++track_frame_counter;
-
unsigned char *out_buffer = NULL;
unsigned int buf_size = 0;
image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
if (MEDIA_VISION_ERROR_NONE !=
- mv_source_get_buffer(source, &out_buffer, &buf_size) ||
- MEDIA_VISION_ERROR_NONE !=
- mv_source_get_width(source, &(image_data.image_width)) ||
- MEDIA_VISION_ERROR_NONE !=
- mv_source_get_height(source, &(image_data.image_height)) ||
- MEDIA_VISION_ERROR_NONE !=
- mv_source_get_colorspace(source, &(image_data.image_colorspace))) {
+ mv_source_get_buffer(source, &out_buffer, &buf_size) ||
+ MEDIA_VISION_ERROR_NONE !=
+ mv_source_get_width(source, &(image_data.image_width)) ||
+ MEDIA_VISION_ERROR_NONE !=
+ mv_source_get_height(source, &(image_data.image_height)) ||
+ MEDIA_VISION_ERROR_NONE !=
+ mv_source_get_colorspace(source, &(image_data.image_colorspace))) {
printf("ERROR: Creating out image is impossible.\n");
return;
if (NULL != location) {
if (!track_catch_face) {
printf(TEXT_GREEN "Frame %i : Tracked object is appeared" TEXT_RESET "\n",
- track_frame_counter);
+ cb_data->frame_number);
track_catch_face = true;
} else {
printf(TEXT_YELLOW "Frame %i : Tracked object is tracked" TEXT_RESET "\n",
- track_frame_counter);
+ cb_data->frame_number);
}
const int rectangle_thickness = 3;
} else {
if (track_catch_face) {
printf(TEXT_RED "Frame %i : Tracked object is lost" TEXT_RESET "\n",
- track_frame_counter);
+ cb_data->frame_number);
track_catch_face = false;
} else {
printf(TEXT_YELLOW "Frame %i : Tracked object isn't detected" TEXT_RESET "\n",
- track_frame_counter);
+ cb_data->frame_number);
}
}
- char file_path[1024];
- snprintf(file_path, 1024, "%s/%05d.jpg", track_output_dir, track_frame_counter);
- if (MEDIA_VISION_ERROR_NONE == save_image_from_buffer(
- file_path, out_buffer, &image_data, 100)) {
- printf("Frame %i was outputted as %s\n", track_frame_counter, file_path);
- } else {
- printf(TEXT_RED "ERROR: Failed to generate output file %s. "
- "Check file name and permissions.\n" TEXT_RESET, file_path);
+ const int err = mv_video_writer_write_frame(cb_data->writer, out_buffer);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf(TEXT_RED "ERROR: Errors were occurred during writing frame #%i"
+ "to the result video file; code %i" TEXT_RESET "\n",
+ cb_data->frame_number,
+ err);
+ return;
}
}
return;
}
- mv_face_tracking_model_h tracking_model =
- (mv_face_tracking_model_h)user_data;
+ tracking_cb_data *cb_data = (tracking_cb_data*)user_data;
+ ++(cb_data->frame_number);
- err = mv_face_track(source, tracking_model, NULL, track_cb, false, NULL);
+ err = mv_face_track(
+ source,
+ cb_data->target,
+ NULL,
+ track_cb,
+ false,
+ cb_data);
if (MEDIA_VISION_ERROR_NONE != err) {
printf(TEXT_RED "ERROR: Errors were occurred during tracking the face "
- TEXT_RESET "on the video frame! Error code: %i\n", err);
-
- return;
+ TEXT_RESET "on the video frame #%i! Error code: %i\n",
+ cb_data->frame_number,
+ err);
}
+
+ return;
}
/* end of stream callback */
pthread_mutex_unlock((pthread_mutex_t*)user_data);
}
-int generate_image_sequence(
- mv_face_tracking_model_h tracking_model,
- const char *track_target_file_name)
+inline void release_resources_for_process_video_file_function(
+ mv_video_reader_h *reader,
+ mv_video_writer_h *writer)
+{
+ int err = MEDIA_VISION_ERROR_NONE;
+ if (*reader) {
+ err = mv_destroy_video_reader(*reader);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf(TEXT_RED "ERROR: Errors were occurred during video reader"
+ "destroying; code %i" TEXT_RESET "\n",
+ err);
+ }
+ *reader = NULL;
+ }
+ if (*writer) {
+ err = mv_destroy_video_writer(*writer);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf(TEXT_RED "ERROR: Errors were occurred during video writer"
+ "destroying; code %i" TEXT_RESET "\n",
+ err);
+ }
+ *writer = NULL;
+ }
+}
+
+int process_video_file(
+ mv_face_tracking_model_h tracking_model,
+ const char *track_target_file_name,
+ const char *track_result_file_name)
{
mv_video_reader_h reader = NULL;
+ mv_video_writer_h writer = NULL;
+
int err = mv_create_video_reader(&reader);
if (MEDIA_VISION_ERROR_NONE != err) {
printf(TEXT_RED
"ERROR: Errors were occurred during creating the video "
"reader! Error code: %i" TEXT_RESET "\n", err);
+ release_resources_for_process_video_file_function(&reader, &writer);
+
+ return err;
+ }
+
+ err = mv_create_video_writer(&writer);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf(TEXT_RED
+ "ERROR: Errors were occurred during creating the video "
+ "writer! Error code: %i" TEXT_RESET "\n", err);
+ release_resources_for_process_video_file_function(&reader, &writer);
+
return err;
}
if (MEDIA_VISION_ERROR_NONE != err) {
printf(TEXT_RED "ERROR: Errors were occurred during loading the video "
"by reader! Error code: %i" TEXT_RESET "\n", err);
+ release_resources_for_process_video_file_function(&reader, &writer);
- const int err2 = mv_destroy_video_reader(reader);
- if (MEDIA_VISION_ERROR_NONE != err2) {
- printf(TEXT_RED "ERROR: Errors were occurred during video reader "
- "destroy! Error code: %i" TEXT_RESET "\n", err);
- }
+ return err;
+ }
- return err;
+ video_info.image_colorspace = MEDIA_VISION_COLORSPACE_RGB888;
+
+ err = mv_video_writer_init(
+ writer,
+ track_result_file_name,
+ video_info,
+ fps);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf(TEXT_RED "\nERROR: Errors were occurred during video writer"
+ "initializing; code %i" TEXT_RESET "\n", err);
+ release_resources_for_process_video_file_function(&reader, &writer);
+
+ return err;
}
+ tracking_cb_data cb_data;
+ cb_data.target = tracking_model;
+ cb_data.writer = writer;
+ cb_data.frame_number = 0;
err = mv_video_reader_set_new_sample_cb(
- reader,
- track_on_sample_cb,
- tracking_model);
-
+ reader,
+ track_on_sample_cb,
+ &cb_data);
if (MEDIA_VISION_ERROR_NONE != err) {
printf(TEXT_RED
"ERROR: Errors were occurred during new sample callback set!"
" Error code: %i" TEXT_RESET "\n", err);
-
- const int err2 = mv_destroy_video_reader(reader);
- if (MEDIA_VISION_ERROR_NONE != err2) {
- printf(TEXT_RED "ERROR: Errors were occurred during video reader "
- "destroy! Error code: %i" TEXT_RESET "\n", err);
- }
+ release_resources_for_process_video_file_function(&reader, &writer);
return err;
}
printf(TEXT_RED
"ERROR: Errors were occurred during setting the eos "
"callback for reader! Error code: %i" TEXT_RESET "\n", err);
-
- const int err2 = mv_destroy_video_reader(reader);
- if (MEDIA_VISION_ERROR_NONE != err2) {
- printf(TEXT_RED
- "ERROR: Errors were occurred during video reader destroy!"
- " Error code: %i" TEXT_RESET "\n", err);
- }
+ release_resources_for_process_video_file_function(&reader, &writer);
pthread_mutex_unlock(&block_during_tracking_mutex);
pthread_mutex_destroy(&block_during_tracking_mutex);
if (MEDIA_VISION_ERROR_NONE != err) {
printf(TEXT_RED "ERROR: Errors were occurred during starting the "
"video reader! Error code: %i" TEXT_RESET "\n", err);
-
- const int err2 = mv_destroy_video_reader(reader);
- if (MEDIA_VISION_ERROR_NONE != err2) {
- printf(TEXT_RED
- "ERROR: Errors were occurred during video reader destroy!"
- " Error code: %i" TEXT_RESET "\n", err);
- }
+ release_resources_for_process_video_file_function(&reader, &writer);
pthread_mutex_unlock(&block_during_tracking_mutex);
pthread_mutex_destroy(&block_during_tracking_mutex);
TEXT_RESET, err);
}
- err = mv_destroy_video_reader(reader);
- if (MEDIA_VISION_ERROR_NONE != err) {
- printf(TEXT_RED "ERROR: Errors were occurred during video "
- "reader destroy! Error code: %i\n" TEXT_RESET, err);
- }
+ release_resources_for_process_video_file_function(&reader, &writer);
return MEDIA_VISION_ERROR_NONE;
}
TEXT_RESET "\n");
char *track_target_file_name = NULL;
+ char *track_result_file_name = NULL;
while (input_string("Input video file name to track on:",
- 1024, &(track_target_file_name)) == -1) {
+ 1024, &(track_target_file_name)) == -1)
printf(TEXT_RED "Incorrect input! Try again." TEXT_RESET "\n");
- }
- while (input_string("Input directory to save tracking results:",
- 1024, &(track_output_dir)) == -1) {
+ while (input_string("Input video file name to save tracking results:",
+ 1024, &(track_result_file_name)) == -1)
printf(TEXT_RED "Incorrect input! Try again." TEXT_RESET "\n");
- }
- track_frame_counter = 0;
+ const int res = process_video_file(
+ tracking_model,
+ track_target_file_name,
+ track_result_file_name);
+
+ free(track_target_file_name);
+ free(track_result_file_name);
- return generate_image_sequence(tracking_model, track_target_file_name);
+ return res;
}
int perform_track()
image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
if (MEDIA_VISION_ERROR_NONE != mv_source_get_buffer(source, &(out_buffer), &buffer_size) ||
- MEDIA_VISION_ERROR_NONE != mv_source_get_width(source, &(image_data.image_width)) ||
- MEDIA_VISION_ERROR_NONE != mv_source_get_height(source, &(image_data.image_height)) ||
- MEDIA_VISION_ERROR_NONE != mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
- NULL == file_name) {
- printf("ERROR: Creating out image is impossible.\n");
+ MEDIA_VISION_ERROR_NONE != mv_source_get_width(source, &(image_data.image_width)) ||
+ MEDIA_VISION_ERROR_NONE != mv_source_get_height(source, &(image_data.image_height)) ||
+ MEDIA_VISION_ERROR_NONE != mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
+ NULL == file_name) {
+ printf("ERROR: Creating out image is impossible.\n");
} else {
is_source_data_loaded = 1;
}
int err2 = mv_destroy_source(source);
if (MEDIA_VISION_ERROR_NONE != err2) {
- printf("\nERROR: Errors were occurred during source "
+ printf("\nERROR: Errors were occurred during source "
"destroying; code %i\n", err2);
}
char *path_to_generated_image = NULL;
while (input_string("Input file name with image for recognizing:",
- 1024, &path_to_image) == -1) {
+ 1024, &path_to_image) == -1)
printf("Incorrect input! Try again.\n");
- }
while (input_string("Input file name for generated image:",
- 1024, &path_to_generated_image) == -1) {
+ 1024, &path_to_generated_image) == -1)
printf("Incorrect input! Try again.\n");
- }
const int err = recognize_image(path_to_image, path_to_generated_image, targets,
- number_of_targets);
+ number_of_targets);
free(path_to_image);
free(path_to_generated_image);
}
while (input_string("Input file name with image object to be loaded:",
- 1024, path_to_object) == -1) {
+ 1024, path_to_object) == -1)
printf("Incorrect input! Try again.\n");
- }
- int err = mv_image_object_load(result, *path_to_object);
+ int err = mv_image_object_load(*path_to_object, result);
- if (MEDIA_VISION_ERROR_NONE != err && NULL != (*result)) {
+ if (MEDIA_VISION_ERROR_NONE != err || NULL == (*result)) {
printf("Error: object isn't loaded with error code %i\n", err);
return err;
}
char *path_to_object = NULL;
while (input_string("Input file name to be generated for image object storing:",
- 1024, &path_to_object) == -1) {
+ 1024, &path_to_object) == -1)
printf("Incorrect input! Try again.\n");
- }
err = mv_image_object_save(path_to_object, object);
return MEDIA_VISION_ERROR_INVALID_PARAMETER;
while (input_string("Input file name with image to be analyzed:",
- 1024, path_to_image) == -1) {
+ 1024, path_to_image) == -1)
printf("Incorrect input! Try again.\n");
- }
mv_rectangle_s roi;
const bool sel_roi = show_confirm_dialog("Select if you want to set ROI");
if (sel_roi) {
printf("\nInput ROI coordinates\n");
while (input_int("Input x coordinate:", INT_MIN, INT_MAX,
- &(roi.point.x)) == -1) {
+ &(roi.point.x)) == -1)
printf("Incorrect input! Try again.\n");
- }
while (input_int("Input y coordinate:", INT_MIN, INT_MAX,
- &(roi.point.y)) == -1) {
+ &(roi.point.y)) == -1)
printf("Incorrect input! Try again.\n");
- }
while (input_int("Input ROI width:", INT_MIN, INT_MAX,
- &(roi.width)) == -1) {
+ &(roi.width)) == -1)
printf("Incorrect input! Try again.\n");
- }
while (input_int("Input ROI height:", INT_MIN, INT_MAX,
- &(roi.height)) == -1) {
+ &(roi.height)) == -1)
printf("Incorrect input! Try again.\n");
- }
}
return err;
}
} else {
- usleep(1000000);
+ usleep(33000);
printf("Frame #%i: object isn't found.\n", frame_number);
}
break;
}
- testing_object_h added_object;
+ testing_object_h added_object = NULL;
testing_object_create(&added_object);
testing_object_fill(added_object, temporary,
- OBJECT_TYPE_IMAGE_OBJECT, SOURCE_TYPE_GENERATION, path_to_image);
+ OBJECT_TYPE_IMAGE_OBJECT, SOURCE_TYPE_GENERATION,
+ path_to_image);
if (NULL != path_to_image)
free(path_to_image);
int sel_opt = show_menu("Select action:", options, names, number_of_options);
switch (sel_opt) {
- case 1: {
- /* Show created set of tracking models */
- show_testing_objects("Set of image tracking models", image_tracking_models);
- break;
- }
- case 2: {
- /* Create empty tracking model (mv_image_tracking_model_create) */
- mv_image_tracking_model_h temporary_image_tracking_model = NULL;
-
- int err = mv_image_tracking_model_create(&temporary_image_tracking_model);
+ case 1: {
+ /* Show created set of tracking models */
+ show_testing_objects("Set of image tracking models", image_tracking_models);
+ break;
+ }
+ case 2: {
+ /* Create empty tracking model (mv_image_tracking_model_create) */
+ mv_image_tracking_model_h temporary_image_tracking_model = NULL;
- if (MEDIA_VISION_ERROR_NONE != err) {
- printf("ERROR: tracking model creation is failed with code %i\n", err);
- break;
- }
+ int err = mv_image_tracking_model_create(&temporary_image_tracking_model);
- testing_object_h added_object = NULL;
- testing_object_create(&added_object);
- testing_object_fill(
- added_object,
- temporary_image_tracking_model,
- OBJECT_TYPE_IMAGE_TRACKING_MODEL,
- SOURCE_TYPE_EMPTY,
- NULL);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf("ERROR: tracking model creation is failed with code %i\n", err);
+ break;
+ }
- add_testing_object(image_tracking_models, added_object);
- printf("\nTracking model successfully created\n");
+ testing_object_h added_object = NULL;
+ testing_object_create(&added_object);
+ testing_object_fill(
+ added_object,
+ temporary_image_tracking_model,
+ OBJECT_TYPE_IMAGE_TRACKING_MODEL,
+ SOURCE_TYPE_EMPTY,
+ NULL);
+
+ add_testing_object(image_tracking_models, added_object);
+ printf("\nTracking model successfully created\n");
+ break;
+ }
+ case 3: {
+ /* Generate model based on image object (mv_image_tracking_model_set_target) */
+ if (image_objects->len <= 0) {
+ printf("\nFirstly you must create at least one image object.\n");
break;
}
- case 3: {
- /* Generate model based on image object (mv_image_tracking_model_set_target) */
- if (image_objects->len <= 0) {
- printf("\nFirstly you must create at least one image object.\n");
- break;
- }
- mv_image_tracking_model_h temporary_image_tracking_model = NULL;
- err = mv_image_tracking_model_create(&temporary_image_tracking_model);
- if (MEDIA_VISION_ERROR_NONE != err) {
- printf("Error: tracking model isn't created with error code %i\n", err);
- break;
- }
+ mv_image_tracking_model_h temporary_image_tracking_model = NULL;
+ err = mv_image_tracking_model_create(&temporary_image_tracking_model);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf("Error: tracking model isn't created with error code %i\n", err);
+ break;
+ }
- testing_object_h temporary_testing_object = NULL;
- select_testing_object(
- image_objects,
- &temporary_testing_object,
- "Select the image object for tracking");
+ testing_object_h temporary_testing_object = NULL;
+ select_testing_object(
+ image_objects,
+ &temporary_testing_object,
+ "Select the image object for tracking");
- err = mv_image_tracking_model_set_target(
- (mv_image_object_h)(temporary_testing_object->entity),
+ err = mv_image_tracking_model_set_target(
+ (mv_image_object_h)(temporary_testing_object->entity),
+ temporary_image_tracking_model);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf("Error: target isn't set with error code %i\n", err);
+ int err2 = mv_image_tracking_model_destroy(
temporary_image_tracking_model);
- if (MEDIA_VISION_ERROR_NONE != err) {
- printf("Error: target isn't set with error code %i\n", err);
- break;
- }
-
- testing_object_h added_object = NULL;
- testing_object_create(&added_object);
- testing_object_fill(
- added_object,
- temporary_image_tracking_model,
- OBJECT_TYPE_IMAGE_TRACKING_MODEL,
- SOURCE_TYPE_GENERATION,
- temporary_testing_object);
-
- add_testing_object(image_tracking_models, added_object);
- printf("\nTracking model successfully generated\n");
+ if (MEDIA_VISION_ERROR_NONE != err2)
+ printf("Error: tracking model destroying return"
+ "error code %i\n", err);
break;
}
- case 4: {
- /* Load existed tracking model from file (mv_image_tracking_model_load) */
- mv_image_tracking_model_h temporary_image_tracking_model = NULL;
- char *path_to_object = NULL;
- err = perform_load_image_tracking_model(
- &path_to_object, &temporary_image_tracking_model);
+ testing_object_h added_object = NULL;
+ testing_object_create(&added_object);
+ testing_object_fill(
+ added_object,
+ temporary_image_tracking_model,
+ OBJECT_TYPE_IMAGE_TRACKING_MODEL,
+ SOURCE_TYPE_GENERATION,
+ temporary_testing_object);
+
+ add_testing_object(image_tracking_models, added_object);
+ printf("\nTracking model successfully generated\n");
+ break;
+ }
+ case 4: {
+ /* Load existed tracking model from file (mv_image_tracking_model_load) */
+ mv_image_tracking_model_h temporary_image_tracking_model = NULL;
+ char *path_to_object = NULL;
- if (MEDIA_VISION_ERROR_NONE != err) {
- printf("Loading failed (error code - %i)\n", err);
- break;
- }
+ err = perform_load_image_tracking_model(
+ &path_to_object, &temporary_image_tracking_model);
- testing_object_h added_object = NULL;
- testing_object_create(&added_object);
- testing_object_fill(
- added_object,
- temporary_image_tracking_model,
- OBJECT_TYPE_IMAGE_TRACKING_MODEL,
- SOURCE_TYPE_LOADING,
- path_to_object);
+ if (MEDIA_VISION_ERROR_NONE != err) {
+ printf("Loading failed (error code - %i)\n", err);
+ break;
+ }
- free(path_to_object);
+ testing_object_h added_object = NULL;
+ testing_object_create(&added_object);
+ testing_object_fill(
+ added_object,
+ temporary_image_tracking_model,
+ OBJECT_TYPE_IMAGE_TRACKING_MODEL,
+ SOURCE_TYPE_LOADING,
+ path_to_object);
+
+ free(path_to_object);
- add_testing_object(image_tracking_models, added_object);
+ add_testing_object(image_tracking_models, added_object);
+ break;
+ }
+ case 5: {
+ /* Clone existed tracking model (mv_image_tracking_model_clone) */
+ if (image_tracking_models->len <= 0) {
+ printf(
+ "\nFirstly you must create at least one image "
+ "tracking model.\n");
break;
}
- case 5: {
- /* Clone existed tracking model (mv_image_tracking_model_clone) */
- if (image_tracking_models->len <= 0) {
- printf(
- "\nFirstly you must create at least one image "
- "tracking model.\n");
- break;
- }
- testing_object_h temporary_testing_object = NULL;
- select_testing_object(
- image_tracking_models,
- &temporary_testing_object,
- "Select the tracking model you want to clone");
+ testing_object_h temporary_testing_object = NULL;
+ select_testing_object(
+ image_tracking_models,
+ &temporary_testing_object,
+ "Select the tracking model you want to clone");
- mv_image_tracking_model_h temporary_image_tracking_model = NULL;
- perform_clone_image_tracking_model(
- temporary_testing_object->entity,
- &temporary_image_tracking_model);
+ mv_image_tracking_model_h temporary_image_tracking_model = NULL;
+ perform_clone_image_tracking_model(
+ temporary_testing_object->entity,
+ &temporary_image_tracking_model);
- testing_object_h added_object = NULL;
- testing_object_create(&added_object);
- testing_object_fill(
- added_object,
- temporary_image_tracking_model,
- OBJECT_TYPE_IMAGE_TRACKING_MODEL,
- SOURCE_TYPE_CLONING,
- temporary_testing_object);
+ testing_object_h added_object = NULL;
+ testing_object_create(&added_object);
+ testing_object_fill(
+ added_object,
+ temporary_image_tracking_model,
+ OBJECT_TYPE_IMAGE_TRACKING_MODEL,
+ SOURCE_TYPE_CLONING,
+ temporary_testing_object);
- add_testing_object(image_tracking_models, added_object);
- break;
+ add_testing_object(image_tracking_models, added_object);
+ break;
+ }
+ case 6: {
+ /* Save existed tracking model to the file (mv_image_tracking_model_save) */
+ if (image_tracking_models->len <= 0) {
+ printf(
+ "\nFirstly you must create at least one image "
+ "tracking model.\n");
+ break;
}
- case 6: {
- /* Save existed tracking model to the file (mv_image_tracking_model_save) */
- if (image_tracking_models->len <= 0) {
- printf(
- "\nFirstly you must create at least one image "
- "tracking model.\n");
- break;
- }
- testing_object_h temporary_testing_object = NULL;
- select_testing_object(
- image_tracking_models,
- &temporary_testing_object,
- "Select the tracking model you want to save");
+ testing_object_h temporary_testing_object = NULL;
+ select_testing_object(
+ image_tracking_models,
+ &temporary_testing_object,
+ "Select the tracking model you want to save");
- perform_save_image_tracking_model(temporary_testing_object->entity);
+ perform_save_image_tracking_model(temporary_testing_object->entity);
+ break;
+ }
+ case 7: {
+ /* Remove tracking model from created set (mv_image_tracking_model_destroy) */
+ if (image_tracking_models->len <= 0) {
+ printf(
+ "\nFirstly you must create at least one image "
+ "tracking model.\n");
break;
}
- case 7: {
- /* Remove tracking model from created set (mv_image_tracking_model_destroy) */
- if (image_tracking_models->len <= 0) {
- printf(
- "\nFirstly you must create at least one image "
- "tracking model.\n");
- break;
- }
- guint selected_index;
- err = select_testing_object_index(
- image_tracking_models,
- &selected_index,
- "Select the object you want to remove");
+ guint selected_index;
+ err = select_testing_object_index(
+ image_tracking_models,
+ &selected_index,
+ "Select the object you want to remove");
- if (MEDIA_VISION_ERROR_NONE == err) {
- remove_testing_object(image_tracking_models, selected_index);
- printf("\nTracking model successfully removed\n");
- }
- break;
+ if (MEDIA_VISION_ERROR_NONE == err) {
+ remove_testing_object(image_tracking_models, selected_index);
+ printf("\nTracking model successfully removed\n");
+ }
+ break;
+ }
+ case 8: {
+ /* Refresh tracking model (mv_image_tracking_model_refresh) */
+ if (image_tracking_models->len <= 0) {
+ printf(
+ "\nFirstly you must create at least one image "
+ "tracking model.\n");
+ break;
}
- case 8: {
- /* Refresh tracking model (mv_image_tracking_model_refresh) */
- if (image_tracking_models->len <= 0) {
- printf(
- "\nFirstly you must create at least one image "
- "tracking model.\n");
- break;
- }
- testing_object_h temporary_testing_object = NULL;
- select_testing_object(
- image_tracking_models,
- &temporary_testing_object,
- "Select the tracking model you want to refresh");
+ testing_object_h temporary_testing_object = NULL;
+ select_testing_object(
+ image_tracking_models,
+ &temporary_testing_object,
+ "Select the tracking model you want to refresh");
- perform_refresh_image_tracking_model(temporary_testing_object->entity);
+ perform_refresh_image_tracking_model(temporary_testing_object->entity);
+ break;
+ }
+ case 9: {
+ /* Track (mv_image_track) */
+ if (image_tracking_models->len <= 0) {
+ printf(
+ "\nFirstly you must create at least one image "
+ "tracking model.\n");
break;
}
- case 9: {
- /* Track (mv_image_track) */
- if (image_tracking_models->len <= 0) {
- printf(
- "\nFirstly you must create at least one image "
- "tracking model.\n");
- break;
- }
-
- testing_object_h temporary_testing_object = NULL;
- err = select_testing_object(
- image_tracking_models,
- &temporary_testing_object,
- "Select the object which you want to track on video");
- if (MEDIA_VISION_ERROR_NONE == err)
- perform_track(temporary_testing_object->entity);
+ testing_object_h temporary_testing_object = NULL;
+ err = select_testing_object(
+ image_tracking_models,
+ &temporary_testing_object,
+ "Select the object which you want to track on video");
- break;
- }
- case 10: {
- /* Back to the main menu */
- return;
- }
+ if (MEDIA_VISION_ERROR_NONE == err)
+ perform_track(temporary_testing_object->entity);
+ break;
+ }
+ case 10: {
+ /* Back to the main menu */
+ return;
+ }
}
}
}
image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
if (save_results_to_image &&
- (mv_source_get_buffer(source, &out_buffer, &buf_size) ||
- mv_source_get_width(source, &(image_data.image_width)) ||
- mv_source_get_height(source, &(image_data.image_height)) ||
- mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
- out_buffer == NULL ||
- buf_size == 0)) {
+ (mv_source_get_buffer(source, &out_buffer, &buf_size) ||
+ mv_source_get_width(source, &(image_data.image_width)) ||
+ mv_source_get_height(source, &(image_data.image_height)) ||
+ mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
+ out_buffer == NULL ||
+ buf_size == 0)) {
PRINT_R("ERROR: Creating out image is impossible.");
return;
image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
if (save_results_to_image &&
- (mv_source_get_buffer(source, &out_buffer, &buf_size) ||
- mv_source_get_width(source, &(image_data.image_width)) ||
- mv_source_get_height(source, &(image_data.image_height)) ||
- mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
- out_buffer == NULL ||
- buf_size == 0)) {
+ (mv_source_get_buffer(source, &out_buffer, &buf_size) ||
+ mv_source_get_width(source, &(image_data.image_width)) ||
+ mv_source_get_height(source, &(image_data.image_height)) ||
+ mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
+ out_buffer == NULL ||
+ buf_size == 0)) {
PRINT_R("ERROR: Creating out image is impossible.");
return;
image_data_s image_data = { 0, 0, MEDIA_VISION_COLORSPACE_INVALID };
if (save_results_to_image &&
- (mv_source_get_buffer(source, &out_buffer, &buf_size) ||
- mv_source_get_width(source, &(image_data.image_width)) ||
- mv_source_get_height(source, &(image_data.image_height)) ||
- mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
- out_buffer == NULL ||
- buf_size == 0)) {
+ (mv_source_get_buffer(source, &out_buffer, &buf_size) ||
+ mv_source_get_width(source, &(image_data.image_width)) ||
+ mv_source_get_height(source, &(image_data.image_height)) ||
+ mv_source_get_colorspace(source, &(image_data.image_colorspace)) ||
+ out_buffer == NULL ||
+ buf_size == 0)) {
PRINT_R("ERROR: Creating out image is impossible.");
if (movement_regions != NULL)
projects / platform / core / api / mediavision.git / commitdiff