code
stringlengths 3
1.01M
| repo_name
stringlengths 5
116
| path
stringlengths 3
311
| language
stringclasses 30
values | license
stringclasses 15
values | size
int64 3
1.01M
|
|---|---|---|---|---|---|
/*
** Copyright 2019-2020 Centreon
**
** 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.
**
** For more information : contact@centreon.com
*/
#include "com/centreon/broker/storage/conflict_manager.hh"
#include <cassert>
#include <cstring>
#include "com/centreon/broker/database/mysql_result.hh"
#include "com/centreon/broker/log_v2.hh"
#include "com/centreon/broker/multiplexing/publisher.hh"
#include "com/centreon/broker/neb/events.hh"
#include "com/centreon/broker/storage/index_mapping.hh"
#include "com/centreon/broker/storage/perfdata.hh"
#include "com/centreon/exceptions/msg_fmt.hh"
using namespace com::centreon::exceptions;
using namespace com::centreon::broker;
using namespace com::centreon::broker::database;
using namespace com::centreon::broker::storage;
conflict_manager* conflict_manager::_singleton = nullptr;
conflict_manager::instance_state conflict_manager::_state{
conflict_manager::not_started};
std::mutex conflict_manager::_init_m;
std::condition_variable conflict_manager::_init_cv;
void (conflict_manager::*const conflict_manager::_neb_processing_table[])(
std::tuple<std::shared_ptr<io::data>, uint32_t, bool*>&) = {
nullptr,
&conflict_manager::_process_acknowledgement,
&conflict_manager::_process_comment,
&conflict_manager::_process_custom_variable,
&conflict_manager::_process_custom_variable_status,
&conflict_manager::_process_downtime,
&conflict_manager::_process_event_handler,
&conflict_manager::_process_flapping_status,
&conflict_manager::_process_host_check,
&conflict_manager::_process_host_dependency,
&conflict_manager::_process_host_group,
&conflict_manager::_process_host_group_member,
&conflict_manager::_process_host,
&conflict_manager::_process_host_parent,
&conflict_manager::_process_host_status,
&conflict_manager::_process_instance,
&conflict_manager::_process_instance_status,
&conflict_manager::_process_log,
&conflict_manager::_process_module,
&conflict_manager::_process_service_check,
&conflict_manager::_process_service_dependency,
&conflict_manager::_process_service_group,
&conflict_manager::_process_service_group_member,
&conflict_manager::_process_service,
&conflict_manager::_process_service_status,
&conflict_manager::_process_instance_configuration,
&conflict_manager::_process_responsive_instance,
};
conflict_manager& conflict_manager::instance() {
assert(_singleton);
return *_singleton;
}
conflict_manager::conflict_manager(database_config const& dbcfg,
uint32_t loop_timeout,
uint32_t instance_timeout)
: _exit{false},
_broken{false},
_loop_timeout{loop_timeout},
_max_pending_queries(dbcfg.get_queries_per_transaction()),
_mysql{dbcfg},
_instance_timeout{instance_timeout},
_store_in_db{true},
_rrd_len{0},
_interval_length{0},
_max_perfdata_queries{0},
_max_metrics_queries{0},
_max_cv_queries{0},
_stats{stats::center::instance().register_conflict_manager()},
_max_log_queries{0},
_events_handled{0},
_speed{},
_stats_count_pos{0},
_ref_count{0},
_oldest_timestamp{std::numeric_limits<time_t>::max()} {
log_v2::sql()->debug("conflict_manager: class instanciation");
stats::center::instance().update(&ConflictManagerStats::set_loop_timeout,
_stats, _loop_timeout);
stats::center::instance().update(
&ConflictManagerStats::set_max_pending_events, _stats,
_max_pending_queries);
}
conflict_manager::~conflict_manager() {
log_v2::sql()->debug("conflict_manager: destruction");
}
/**
* For the connector that does not initialize the conflict_manager, this
* function is useful to wait.
*
* @param store_in_db A boolean to specify if perfdata should be stored in
* database.
* @param rrd_len The rrd length in seconds
* @param interval_length The length of an elementary time interval.
* @param queries_per_transaction The number of perfdata to store before sending
* them to database.
*
* @return true if all went OK.
*/
bool conflict_manager::init_storage(bool store_in_db,
uint32_t rrd_len,
uint32_t interval_length,
uint32_t queries_per_transaction) {
log_v2::sql()->debug("conflict_manager: storage stream initialization");
int count;
std::unique_lock<std::mutex> lk(_init_m);
for (count = 0; count < 10; count++) {
/* Let's wait for 10s for the conflict_manager to be initialized */
if (_init_cv.wait_for(lk, std::chrono::seconds(1), [&] {
return _singleton != nullptr || _state == finished;
})) {
if (_state == finished)
return false;
std::lock_guard<std::mutex> lk(_singleton->_loop_m);
_singleton->_store_in_db = store_in_db;
_singleton->_rrd_len = rrd_len;
_singleton->_interval_length = interval_length;
_singleton->_max_perfdata_queries = queries_per_transaction;
_singleton->_max_metrics_queries = queries_per_transaction;
_singleton->_max_cv_queries = queries_per_transaction;
_singleton->_max_log_queries = queries_per_transaction;
_singleton->_ref_count++;
_singleton->_thread =
std::move(std::thread(&conflict_manager::_callback, _singleton));
pthread_setname_np(_singleton->_thread.native_handle(), "conflict_mngr");
return true;
}
log_v2::sql()->info(
"conflict_manager: Waiting for the sql stream initialization for {} "
"seconds",
count);
}
log_v2::sql()->error(
"conflict_manager: not initialized after 10s. Probably "
"an issue in the sql output configuration.");
return false;
}
/**
* @brief This fonction is the one that initializes the conflict_manager.
*
* @param dbcfg The database configuration
* @param loop_timeout A duration in seconds. During this interval received
* events are handled. If there are no more events to handle, new
* available ones are taken from the fifo. If none, the loop waits during
* 500ms. After this loop others things are done, cleanups, etc. And then
* the loop is started again.
* @param instance_timeout A duration in seconds. This interval is used for
* sending data in bulk. We wait for this interval at least between two
* bulks.
*
* @return A boolean true if the function went good, false otherwise.
*/
bool conflict_manager::init_sql(database_config const& dbcfg,
uint32_t loop_timeout,
uint32_t instance_timeout) {
log_v2::sql()->debug("conflict_manager: sql stream initialization");
std::lock_guard<std::mutex> lk(_init_m);
_singleton = new conflict_manager(dbcfg, loop_timeout, instance_timeout);
if (!_singleton) {
_state = finished;
return false;
}
_state = running;
_singleton->_action.resize(_singleton->_mysql.connections_count());
_init_cv.notify_all();
_singleton->_ref_count++;
return true;
}
void conflict_manager::_load_deleted_instances() {
_cache_deleted_instance_id.clear();
std::string query{"SELECT instance_id FROM instances WHERE deleted=1"};
std::promise<mysql_result> promise;
_mysql.run_query_and_get_result(query, &promise);
try {
mysql_result res(promise.get_future().get());
while (_mysql.fetch_row(res))
_cache_deleted_instance_id.insert(res.value_as_u32(0));
} catch (std::exception const& e) {
throw msg_fmt("could not get list of deleted instances: {}", e.what());
}
}
void conflict_manager::_load_caches() {
// Fill index cache.
std::lock_guard<std::mutex> lk(_loop_m);
/* get deleted cache of instance ids => _cache_deleted_instance_id */
_load_deleted_instances();
/* get all outdated instances from the database => _stored_timestamps */
{
std::string query{"SELECT instance_id FROM instances WHERE outdated=TRUE"};
std::promise<mysql_result> promise;
_mysql.run_query_and_get_result(query, &promise);
try {
mysql_result res(promise.get_future().get());
while (_mysql.fetch_row(res)) {
uint32_t instance_id = res.value_as_i32(0);
_stored_timestamps.insert(
{instance_id,
stored_timestamp(instance_id, stored_timestamp::unresponsive)});
stored_timestamp& ts = _stored_timestamps[instance_id];
ts.set_timestamp(timestamp(std::numeric_limits<time_t>::max()));
}
} catch (std::exception const& e) {
throw msg_fmt(
"conflict_manager: could not get the list of outdated instances: {}",
e.what());
}
}
/* index_data => _index_cache */
{
// Execute query.
std::promise<database::mysql_result> promise;
_mysql.run_query_and_get_result(
"SELECT "
"id,host_id,service_id,host_name,rrd_retention,service_description,"
"special,locked FROM index_data",
&promise);
try {
database::mysql_result res(promise.get_future().get());
// Loop through result set.
while (_mysql.fetch_row(res)) {
index_info info{.host_name = res.value_as_str(3),
.index_id = res.value_as_u64(0),
.locked = res.value_as_bool(7),
.rrd_retention = res.value_as_u32(4)
? res.value_as_u32(4)
: _rrd_len,
.service_description = res.value_as_str(5),
.special = res.value_as_u32(6) == 2};
uint32_t host_id(res.value_as_u32(1));
uint32_t service_id(res.value_as_u32(2));
log_v2::perfdata()->debug(
"storage: loaded index {} of ({}, {}) with rrd_len={}",
info.index_id, host_id, service_id, info.rrd_retention);
_index_cache[{host_id, service_id}] = std::move(info);
// Create the metric mapping.
std::shared_ptr<storage::index_mapping> im{
std::make_shared<storage::index_mapping>(info.index_id, host_id,
service_id)};
multiplexing::publisher pblshr;
pblshr.write(im);
}
} catch (std::exception const& e) {
throw msg_fmt("storage: could not fetch index list from data DB: {}",
e.what());
}
}
/* hosts => _cache_host_instance */
{
_cache_host_instance.clear();
std::promise<mysql_result> promise;
_mysql.run_query_and_get_result("SELECT host_id,instance_id FROM hosts",
&promise);
try {
mysql_result res(promise.get_future().get());
while (_mysql.fetch_row(res))
_cache_host_instance[res.value_as_u32(0)] = res.value_as_u32(1);
} catch (std::exception const& e) {
throw msg_fmt("SQL: could not get the list of host/instance pairs: {}",
e.what());
}
}
/* hostgroups => _hostgroup_cache */
{
_hostgroup_cache.clear();
std::promise<mysql_result> promise;
_mysql.run_query_and_get_result("SELECT hostgroup_id FROM hostgroups",
&promise);
try {
mysql_result res(promise.get_future().get());
while (_mysql.fetch_row(res))
_hostgroup_cache.insert(res.value_as_u32(0));
} catch (std::exception const& e) {
throw msg_fmt("SQL: could not get the list of hostgroups id: {}",
e.what());
}
}
/* servicegroups => _servicegroup_cache */
{
_servicegroup_cache.clear();
std::promise<mysql_result> promise;
_mysql.run_query_and_get_result("SELECT servicegroup_id FROM servicegroups",
&promise);
try {
mysql_result res(promise.get_future().get());
while (_mysql.fetch_row(res))
_servicegroup_cache.insert(res.value_as_u32(0));
} catch (std::exception const& e) {
throw msg_fmt("SQL: could not get the list of servicegroups id: {}",
e.what());
}
}
_cache_svc_cmd.clear();
_cache_hst_cmd.clear();
/* metrics => _metric_cache */
{
std::lock_guard<std::mutex> lock(_metric_cache_m);
_metric_cache.clear();
_metrics.clear();
std::promise<mysql_result> promise;
_mysql.run_query_and_get_result(
"SELECT "
"metric_id,index_id,metric_name,unit_name,warn,warn_low,"
"warn_threshold_mode,crit,crit_low,crit_threshold_mode,min,max,"
"current_value,data_source_type FROM metrics",
&promise);
try {
mysql_result res{promise.get_future().get()};
while (_mysql.fetch_row(res)) {
metric_info info;
info.metric_id = res.value_as_u32(0);
info.locked = false;
info.unit_name = res.value_as_str(3);
info.warn = res.value_as_f32(4);
info.warn_low = res.value_as_f32(5);
info.warn_mode = res.value_as_i32(6);
info.crit = res.value_as_f32(7);
info.crit_low = res.value_as_f32(8);
info.crit_mode = res.value_as_i32(9);
info.min = res.value_as_f32(10);
info.max = res.value_as_f32(11);
info.value = res.value_as_f32(12);
info.type = res.value_as_str(13)[0] - '0';
info.metric_mapping_sent = false;
_metric_cache[{res.value_as_u64(1), res.value_as_str(2)}] = info;
}
} catch (std::exception const& e) {
throw msg_fmt("conflict_manager: could not get the list of metrics: {}",
e.what());
}
}
}
void conflict_manager::update_metric_info_cache(uint64_t index_id,
uint32_t metric_id,
std::string const& metric_name,
short metric_type) {
auto it = _metric_cache.find({index_id, metric_name});
if (it != _metric_cache.end()) {
log_v2::perfdata()->info(
"conflict_manager: updating metric '{}' of id {} at index {} to "
"metric_type {}",
metric_name, metric_id, index_id,
perfdata::data_type_name[metric_type]);
std::lock_guard<std::mutex> lock(_metric_cache_m);
it->second.type = metric_type;
if (it->second.metric_id != metric_id) {
it->second.metric_id = metric_id;
// We need to repopulate a new metric_mapping
it->second.metric_mapping_sent = false;
}
}
}
/**
* The main loop of the conflict_manager
*/
void conflict_manager::_callback() {
try {
_load_caches();
} catch (std::exception const& e) {
log_v2::sql()->error("error while loading caches: {}", e.what());
_broken = true;
}
do {
std::chrono::system_clock::time_point time_to_deleted_index =
std::chrono::system_clock::now();
size_t pos = 0;
std::deque<std::tuple<std::shared_ptr<io::data>, uint32_t, bool*>> events;
try {
while (!_should_exit()) {
/* Time to send perfdatas to rrd ; no lock needed, it is this thread
* that fill this queue. */
_insert_perfdatas();
/* Time to send metrics to database */
_update_metrics();
/* Time to send customvariables to database */
_update_customvariables();
/* Time to send logs to database */
_insert_logs();
log_v2::sql()->trace(
"conflict_manager: main loop initialized with a timeout of {} "
"seconds.",
_loop_timeout);
std::chrono::system_clock::time_point now0 =
std::chrono::system_clock::now();
/* Are there index_data to remove? */
if (now0 >= time_to_deleted_index) {
try {
_check_deleted_index();
time_to_deleted_index += std::chrono::minutes(5);
} catch (std::exception const& e) {
log_v2::sql()->error(
"conflict_manager: error while checking deleted indexes: {}",
e.what());
_broken = true;
break;
}
}
int32_t count = 0;
int32_t timeout = 0;
int32_t timeout_limit = _loop_timeout * 1000;
/* This variable is incremented 1000 by 1000 and represents
* milliseconds. Each time the duration reaches this value, we make
* stuffs. We make then a timer cadenced at 1000ms. */
int32_t duration = 1000;
time_t next_insert_perfdatas = time(nullptr);
time_t next_update_metrics = next_insert_perfdatas;
time_t next_update_cv = next_insert_perfdatas;
time_t next_update_log = next_insert_perfdatas;
auto empty_caches = [this, &next_insert_perfdatas, &next_update_metrics,
&next_update_cv, &next_update_log](
std::chrono::system_clock::time_point now) {
/* If there are too many perfdata to send, let's send them... */
if (std::chrono::system_clock::to_time_t(now) >=
next_insert_perfdatas ||
_perfdata_queue.size() > _max_perfdata_queries) {
next_insert_perfdatas =
std::chrono::system_clock::to_time_t(now) + 10;
_insert_perfdatas();
}
/* If there are too many metrics to send, let's send them... */
if (std::chrono::system_clock::to_time_t(now) >=
next_update_metrics ||
_metrics.size() > _max_metrics_queries) {
next_update_metrics =
std::chrono::system_clock::to_time_t(now) + 10;
_update_metrics();
}
/* Time to send customvariables to database */
if (std::chrono::system_clock::to_time_t(now) >= next_update_cv ||
_cv_queue.size() + _cvs_queue.size() > _max_cv_queries) {
next_update_cv = std::chrono::system_clock::to_time_t(now) + 10;
_update_customvariables();
}
/* Time to send logs to database */
if (std::chrono::system_clock::to_time_t(now) >= next_update_log ||
_log_queue.size() > _max_log_queries) {
next_update_log = std::chrono::system_clock::to_time_t(now) + 10;
_insert_logs();
}
};
/* During this loop, connectors still fill the queue when they receive
* new events.
* The loop is hold by three conditions that are:
* - events.empty() no more events to treat.
* - count < _max_pending_queries: we don't want to commit everytimes,
* so we keep this count to know if we reached the
* _max_pending_queries parameter.
* - timeout < timeout_limit: If the loop lives too long, we interrupt
* it it is necessary for cleanup operations.
*/
while (count < _max_pending_queries && timeout < timeout_limit) {
if (events.empty())
events = _fifo.first_events();
if (events.empty()) {
// Let's wait for 500ms.
if (_should_exit())
break;
std::this_thread::sleep_for(std::chrono::milliseconds(500));
/* Here, just before looping, we commit. */
std::chrono::system_clock::time_point now =
std::chrono::system_clock::now();
empty_caches(now);
_finish_actions();
continue;
}
while (!events.empty()) {
auto tpl = events.front();
events.pop_front();
std::shared_ptr<io::data>& d = std::get<0>(tpl);
uint32_t type{d->type()};
uint16_t cat{io::events::category_of_type(type)};
uint16_t elem{io::events::element_of_type(type)};
if (std::get<1>(tpl) == sql && cat == io::events::neb)
(this->*(_neb_processing_table[elem]))(tpl);
else if (std::get<1>(tpl) == storage && cat == io::events::neb &&
type == neb::service_status::static_type())
_storage_process_service_status(tpl);
else {
log_v2::sql()->trace(
"conflict_manager: event of type {} thrown away ; no need to "
"store it in the database.",
type);
*std::get<2>(tpl) = true;
}
++count;
_stats_count[pos]++;
std::chrono::system_clock::time_point now1 =
std::chrono::system_clock::now();
empty_caches(now1);
timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
now1 - now0)
.count();
/* Get some stats each second */
if (timeout >= duration) {
do {
duration += 1000;
pos++;
if (pos >= _stats_count.size())
pos = 0;
_stats_count[pos] = 0;
} while (timeout > duration);
_events_handled = events.size();
float s = 0.0f;
for (const auto& c : _stats_count)
s += c;
std::lock_guard<std::mutex> lk(_stat_m);
_speed = s / _stats_count.size();
stats::center::instance().update(&ConflictManagerStats::set_speed,
_stats,
static_cast<double>(_speed));
}
}
}
log_v2::sql()->debug("{} new events to treat", count);
/* Here, just before looping, we commit. */
_finish_actions();
if (_fifo.get_pending_elements() == 0)
log_v2::sql()->debug(
"conflict_manager: acknowledgement - no pending events");
else
log_v2::sql()->debug(
"conflict_manager: acknowledgement - still {} not acknowledged",
_fifo.get_pending_elements());
/* Are there unresonsive instances? */
_update_hosts_and_services_of_unresponsive_instances();
/* Get some stats */
{
std::lock_guard<std::mutex> lk(_stat_m);
_events_handled = events.size();
stats::center::instance().update(
&ConflictManagerStats::set_events_handled, _stats,
_events_handled);
stats::center::instance().update(
&ConflictManagerStats::set_max_perfdata_events, _stats,
_max_perfdata_queries);
stats::center::instance().update(
&ConflictManagerStats::set_waiting_events, _stats,
static_cast<int32_t>(_fifo.get_events().size()));
stats::center::instance().update(
&ConflictManagerStats::set_sql, _stats,
static_cast<int32_t>(_fifo.get_timeline(sql).size()));
stats::center::instance().update(
&ConflictManagerStats::set_storage, _stats,
static_cast<int32_t>(_fifo.get_timeline(storage).size()));
}
}
} catch (std::exception const& e) {
log_v2::sql()->error("conflict_manager: error in the main loop: {}",
e.what());
if (strstr(e.what(), "server has gone away")) {
// The case where we must restart the connector.
_broken = true;
}
}
} while (!_should_exit());
if (_broken) {
std::unique_lock<std::mutex> lk(_loop_m);
/* Let's wait for the end */
log_v2::sql()->info(
"conflict_manager: waiting for the end of the conflict manager main "
"loop.");
_loop_cv.wait(lk, [this]() { return !_exit; });
}
}
/**
* Tell if the main loop can exit. Two conditions are needed:
* * _exit = true
* * _events is empty.
*
* This methods takes the lock on _loop_m, so don't call it if you already have
* it.
*
* @return True if the loop can be interrupted, false otherwise.
*/
bool conflict_manager::_should_exit() const {
std::lock_guard<std::mutex> lock(_loop_m);
return _broken || (_exit && _fifo.get_events().empty());
}
/**
* Method to send event to the conflict manager.
*
* @param c The connector responsible of the event (sql or storage)
* @param e The event
*
* @return The number of events to ack.
*/
int32_t conflict_manager::send_event(conflict_manager::stream_type c,
std::shared_ptr<io::data> const& e) {
assert(e);
if (_broken)
throw msg_fmt("conflict_manager: events loop interrupted");
log_v2::sql()->trace(
"conflict_manager: send_event category:{}, element:{} from {}",
e->type() >> 16, e->type() & 0xffff, c == 0 ? "sql" : "storage");
return _fifo.push(c, e);
}
/**
* This method is called from the stream and returns how many events should
* be released. By the way, it removes those objects from the queue.
*
* @param c a stream_type (we have two kinds of data arriving in the
* conflict_manager, those from the sql connector and those from the storage
* connector, so this stream_type is an enum containing those types).
*
* @return the number of events to ack.
*/
int32_t conflict_manager::get_acks(stream_type c) {
if (_broken)
throw msg_fmt("conflict_manager: events loop interrupted");
return _fifo.get_acks(c);
}
/**
* Take a look if a given action is done on a mysql connection. If it is
* done, the method waits for tasks on this connection to be finished and
* clear the flag.
* In case of a conn < 0, the methods checks all the connections.
*
* @param conn The connection number or a negative number to check all the
* connections
* @param action An action.
*/
void conflict_manager::_finish_action(int32_t conn, uint32_t action) {
if (conn < 0) {
for (std::size_t i = 0; i < _action.size(); i++) {
if (_action[i] & action) {
_mysql.commit(i);
_action[i] = actions::none;
}
}
} else if (_action[conn] & action) {
_mysql.commit(conn);
_action[conn] = actions::none;
}
}
/**
* The main goal of this method is to commit queries sent to the db.
* When the commit is done (all the connections commit), we count how
* many events can be acknowledged. So we can also update the number of pending
* events.
*/
void conflict_manager::_finish_actions() {
log_v2::sql()->trace("conflict_manager: finish actions");
_mysql.commit();
for (uint32_t& v : _action)
v = actions::none;
_fifo.clean(sql);
_fifo.clean(storage);
log_v2::sql()->debug("conflict_manager: still {} not acknowledged",
_fifo.get_pending_elements());
}
/**
* Add an action on the connection conn in the list of current actions.
* If conn < 0, the action is added to all the connections.
*
* @param conn The connection number or a negative number to add to all the
* connections
* @param action An action.
*/
void conflict_manager::_add_action(int32_t conn, actions action) {
if (conn < 0) {
for (uint32_t& v : _action)
v |= action;
} else
_action[conn] |= action;
}
void conflict_manager::__exit() {
{
std::lock_guard<std::mutex> lock(_loop_m);
_exit = true;
_loop_cv.notify_all();
}
if (_thread.joinable())
_thread.join();
}
/**
* @brief Returns statistics about the conflict_manager. Those statistics
* are stored directly in a json tree.
*
* @return A nlohmann::json with the statistics.
*/
nlohmann::json conflict_manager::get_statistics() {
nlohmann::json retval;
retval["max pending events"] = static_cast<int32_t>(_max_pending_queries);
retval["max perfdata events"] = static_cast<int32_t>(_max_perfdata_queries);
retval["loop timeout"] = static_cast<int32_t>(_loop_timeout);
if (auto lock = std::unique_lock<std::mutex>(_stat_m, std::try_to_lock)) {
retval["waiting_events"] = static_cast<int32_t>(_fifo.get_events().size());
retval["events_handled"] = _events_handled;
retval["sql"] = static_cast<int32_t>(_fifo.get_timeline(sql).size());
retval["storage"] =
static_cast<int32_t>(_fifo.get_timeline(storage).size());
retval["speed"] = fmt::format("{} events/s", _speed);
}
return retval;
}
/**
* @brief Delete the conflict_manager singleton.
*/
int32_t conflict_manager::unload(stream_type type) {
if (!_singleton) {
log_v2::sql()->info("conflict_manager: already unloaded.");
return 0;
} else {
uint32_t count = --_singleton->_ref_count;
int retval;
if (count == 0) {
__exit();
retval = _fifo.get_acks(type);
{
std::lock_guard<std::mutex> lck(_init_m);
_state = finished;
delete _singleton;
_singleton = nullptr;
}
log_v2::sql()->info(
"conflict_manager: no more user of the conflict manager.");
} else {
log_v2::sql()->info(
"conflict_manager: still {} stream{} using the conflict manager.",
count, count > 1 ? "s" : "");
retval = _fifo.get_acks(type);
log_v2::sql()->info(
"conflict_manager: still {} events handled but not acknowledged.",
retval);
}
return retval;
}
}
|
centreon/centreon-broker
|
storage/src/conflict_manager.cc
|
C++
|
apache-2.0
| 29,683
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.sysml.api.mlcontext;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.sysml.runtime.controlprogram.LocalVariableMap;
import org.apache.sysml.runtime.controlprogram.caching.CacheableData;
import org.apache.sysml.runtime.instructions.cp.Data;
import scala.Tuple2;
import scala.Tuple3;
import scala.collection.JavaConversions;
/**
* A Script object encapsulates a DML or PYDML script.
*
*/
public class Script {
/**
* The type of script ({@code ScriptType.DML} or {@code ScriptType.PYDML}).
*/
private ScriptType scriptType;
/**
* The script content.
*/
private String scriptString;
/**
* The optional name of the script.
*/
private String name;
/**
* All inputs (input parameters ($) and input variables).
*/
private Map<String, Object> inputs = new LinkedHashMap<String, Object>();
/**
* The input parameters ($).
*/
private Map<String, Object> inputParameters = new LinkedHashMap<String, Object>();
/**
* The input variables.
*/
private Set<String> inputVariables = new LinkedHashSet<String>();
/**
* The input matrix or frame metadata if present.
*/
private Map<String, Metadata> inputMetadata = new LinkedHashMap<String, Metadata>();
/**
* The output variables.
*/
private Set<String> outputVariables = new LinkedHashSet<String>();
/**
* The symbol table containing the data associated with variables.
*/
private LocalVariableMap symbolTable = new LocalVariableMap();
/**
* The ScriptExecutor which is used to define the execution of the script.
*/
private ScriptExecutor scriptExecutor;
/**
* The results of the execution of the script.
*/
private MLResults results;
/**
* Script constructor, which by default creates a DML script.
*/
public Script() {
scriptType = ScriptType.DML;
}
/**
* Script constructor, specifying the type of script ({@code ScriptType.DML}
* or {@code ScriptType.PYDML}).
*
* @param scriptType
* {@code ScriptType.DML} or {@code ScriptType.PYDML}
*/
public Script(ScriptType scriptType) {
this.scriptType = scriptType;
}
/**
* Script constructor, specifying the script content. By default, the script
* type is DML.
*
* @param scriptString
* the script content as a string
*/
public Script(String scriptString) {
this.scriptString = scriptString;
this.scriptType = ScriptType.DML;
}
/**
* Script constructor, specifying the script content and the type of script
* (DML or PYDML).
*
* @param scriptString
* the script content as a string
* @param scriptType
* {@code ScriptType.DML} or {@code ScriptType.PYDML}
*/
public Script(String scriptString, ScriptType scriptType) {
this.scriptString = scriptString;
this.scriptType = scriptType;
}
/**
* Obtain the script type.
*
* @return {@code ScriptType.DML} or {@code ScriptType.PYDML}
*/
public ScriptType getScriptType() {
return scriptType;
}
/**
* Set the type of script (DML or PYDML).
*
* @param scriptType
* {@code ScriptType.DML} or {@code ScriptType.PYDML}
*/
public void setScriptType(ScriptType scriptType) {
this.scriptType = scriptType;
}
/**
* Obtain the script string.
*
* @return the script string
*/
public String getScriptString() {
return scriptString;
}
/**
* Set the script string.
*
* @param scriptString
* the script string
* @return {@code this} Script object to allow chaining of methods
*/
public Script setScriptString(String scriptString) {
this.scriptString = scriptString;
return this;
}
/**
* Obtain the input variable names as an unmodifiable set of strings.
*
* @return the input variable names
*/
public Set<String> getInputVariables() {
return Collections.unmodifiableSet(inputVariables);
}
/**
* Obtain the output variable names as an unmodifiable set of strings.
*
* @return the output variable names
*/
public Set<String> getOutputVariables() {
return Collections.unmodifiableSet(outputVariables);
}
/**
* Obtain the symbol table, which is essentially a
* {@code HashMap<String, Data>} representing variables and their values.
*
* @return the symbol table
*/
public LocalVariableMap getSymbolTable() {
return symbolTable;
}
/**
* Obtain an unmodifiable map of all inputs (parameters ($) and variables).
*
* @return all inputs to the script
*/
public Map<String, Object> getInputs() {
return Collections.unmodifiableMap(inputs);
}
/**
* Obtain an unmodifiable map of input matrix/frame metadata.
*
* @return input matrix/frame metadata
*/
public Map<String, Metadata> getInputMetadata() {
return Collections.unmodifiableMap(inputMetadata);
}
/**
* Pass a map of inputs to the script.
*
* @param inputs
* map of inputs (parameters ($) and variables).
* @return {@code this} Script object to allow chaining of methods
*/
public Script in(Map<String, Object> inputs) {
for (Entry<String, Object> input : inputs.entrySet()) {
in(input.getKey(), input.getValue());
}
return this;
}
/**
* Pass a Scala Map of inputs to the script.
* <p>
* Note that the {@code Map} value type is not explicitly specified on this
* method because {@code [String, Any]} can't be recognized on the Java side
* since {@code Any} doesn't have an equivalent in the Java class hierarchy
* ({@code scala.Any} is a superclass of {@code scala.AnyRef}, which is
* equivalent to {@code java.lang.Object}). Therefore, specifying
* {@code scala.collection.Map<String, Object>} as an input parameter to
* this Java method is not encompassing enough and would require types such
* as a {@code scala.Double} to be cast using {@code asInstanceOf[AnyRef]}.
*
* @param inputs
* Scala Map of inputs (parameters ($) and variables).
* @return {@code this} Script object to allow chaining of methods
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public Script in(scala.collection.Map<String, ?> inputs) {
Map javaMap = JavaConversions.mapAsJavaMap(inputs);
in(javaMap);
return this;
}
/**
* Pass a Scala Seq of inputs to the script. The inputs are either two-value
* or three-value tuples, where the first value is the variable name, the
* second value is the variable value, and the third optional value is the
* metadata.
*
* @param inputs
* Scala Seq of inputs (parameters ($) and variables).
* @return {@code this} Script object to allow chaining of methods
*/
public Script in(scala.collection.Seq<Object> inputs) {
List<Object> list = JavaConversions.seqAsJavaList(inputs);
for (Object obj : list) {
if (obj instanceof Tuple3) {
@SuppressWarnings("unchecked")
Tuple3<String, Object, MatrixMetadata> t3 = (Tuple3<String, Object, MatrixMetadata>) obj;
in(t3._1(), t3._2(), t3._3());
} else if (obj instanceof Tuple2) {
@SuppressWarnings("unchecked")
Tuple2<String, Object> t2 = (Tuple2<String, Object>) obj;
in(t2._1(), t2._2());
} else {
throw new MLContextException("Only Tuples of 2 or 3 values are permitted");
}
}
return this;
}
/**
* Obtain an unmodifiable map of all input parameters ($).
*
* @return input parameters ($)
*/
public Map<String, Object> getInputParameters() {
return inputParameters;
}
/**
* Register an input (parameter ($) or variable).
*
* @param name
* name of the input
* @param value
* value of the input
* @return {@code this} Script object to allow chaining of methods
*/
public Script in(String name, Object value) {
return in(name, value, null);
}
/**
* Register an input (parameter ($) or variable) with optional matrix
* metadata.
*
* @param name
* name of the input
* @param value
* value of the input
* @param metadata
* optional matrix/frame metadata
* @return {@code this} Script object to allow chaining of methods
*/
public Script in(String name, Object value, Metadata metadata) {
if ((value != null) && (value instanceof Long)) {
// convert Long to Integer since Long not a supported value type
Long lng = (Long) value;
value = lng.intValue();
}
MLContextUtil.checkInputValueType(name, value);
if (inputs == null) {
inputs = new LinkedHashMap<String, Object>();
}
inputs.put(name, value);
if (name.startsWith("$")) {
MLContextUtil.checkInputParameterType(name, value);
if (inputParameters == null) {
inputParameters = new LinkedHashMap<String, Object>();
}
inputParameters.put(name, value);
}
else {
Data data = MLContextUtil.convertInputType(name, value, metadata);
if (data != null) {
//store input variable name and data
symbolTable.put(name, data);
inputVariables.add(name);
//store matrix/frame meta data and disable variable cleanup
if( data instanceof CacheableData ) {
if( metadata != null )
inputMetadata.put(name, metadata);
((CacheableData<?>)data).enableCleanup(false);
}
}
}
return this;
}
/**
* Register an output variable.
*
* @param outputName
* name of the output variable
* @return {@code this} Script object to allow chaining of methods
*/
public Script out(String outputName) {
outputVariables.add(outputName);
return this;
}
/**
* Register output variables.
*
* @param outputNames
* names of the output variables
* @return {@code this} Script object to allow chaining of methods
*/
public Script out(String... outputNames) {
outputVariables.addAll(Arrays.asList(outputNames));
return this;
}
/**
* Clear the inputs, outputs, and symbol table.
*/
public void clearIOS() {
clearInputs();
clearOutputs();
clearSymbolTable();
}
/**
* Clear the inputs and outputs, but not the symbol table.
*/
public void clearIO() {
clearInputs();
clearOutputs();
}
/**
* Clear the script string, inputs, outputs, and symbol table.
*/
public void clearAll() {
scriptString = null;
clearIOS();
}
/**
* Clear the inputs.
*/
public void clearInputs() {
inputs.clear();
inputParameters.clear();
inputVariables.clear();
inputMetadata.clear();
}
/**
* Clear the outputs.
*/
public void clearOutputs() {
outputVariables.clear();
}
/**
* Clear the symbol table.
*/
public void clearSymbolTable() {
symbolTable.removeAll();
}
/**
* Obtain the results of the script execution.
*
* @return the results of the script execution.
*/
public MLResults results() {
return results;
}
/**
* Obtain the results of the script execution.
*
* @return the results of the script execution.
*/
public MLResults getResults() {
return results;
}
/**
* Set the results of the script execution.
*
* @param results
* the results of the script execution.
*/
public void setResults(MLResults results) {
this.results = results;
}
/**
* Obtain the script executor used by this Script.
*
* @return the ScriptExecutor used by this Script.
*/
public ScriptExecutor getScriptExecutor() {
return scriptExecutor;
}
/**
* Set the ScriptExecutor used by this Script.
*
* @param scriptExecutor
* the script executor
*/
public void setScriptExecutor(ScriptExecutor scriptExecutor) {
this.scriptExecutor = scriptExecutor;
}
/**
* Is the script type DML?
*
* @return {@code true} if the script type is DML, {@code false} otherwise
*/
public boolean isDML() {
return scriptType.isDML();
}
/**
* Is the script type PYDML?
*
* @return {@code true} if the script type is PYDML, {@code false} otherwise
*/
public boolean isPYDML() {
return scriptType.isPYDML();
}
/**
* Generate the script execution string, which adds read/load/write/save
* statements to the beginning and end of the script to execute.
*
* @return the script execution string
*/
public String getScriptExecutionString() {
StringBuilder sb = new StringBuilder();
Set<String> ins = getInputVariables();
for (String in : ins) {
Object inValue = getInputs().get(in);
sb.append(in);
if (isDML()) {
if (inValue instanceof String) {
String quotedString = MLContextUtil.quotedString((String) inValue);
sb.append(" = " + quotedString + ";\n");
} else if (MLContextUtil.isBasicType(inValue)) {
sb.append(" = read('', data_type='scalar', value_type='" + MLContextUtil.getBasicTypeString(inValue) + "');\n");
} else if (MLContextUtil.doesSymbolTableContainFrameObject(symbolTable, in)) {
sb.append(" = read('', data_type='frame');\n");
} else {
sb.append(" = read('');\n");
}
} else if (isPYDML()) {
if (inValue instanceof String) {
String quotedString = MLContextUtil.quotedString((String) inValue);
sb.append(" = " + quotedString + "\n");
} else if (MLContextUtil.isBasicType(inValue)) {
sb.append(" = load('', data_type='scalar', value_type='" + MLContextUtil.getBasicTypeString(inValue) + "')\n");
} else if (MLContextUtil.doesSymbolTableContainFrameObject(symbolTable, in)) {
sb.append(" = load('', data_type='frame')\n");
} else {
sb.append(" = load('')\n");
}
}
}
sb.append(getScriptString());
if (!getScriptString().endsWith("\n")) {
sb.append("\n");
}
Set<String> outs = getOutputVariables();
for (String out : outs) {
if (isDML()) {
sb.append("write(");
sb.append(out);
sb.append(", '');\n");
} else if (isPYDML()) {
sb.append("save(");
sb.append(out);
sb.append(", '')\n");
}
}
return sb.toString();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(MLContextUtil.displayInputs("Inputs", inputs, symbolTable));
sb.append("\n");
sb.append(MLContextUtil.displayOutputs("Outputs", outputVariables, symbolTable));
return sb.toString();
}
/**
* Display information about the script as a String. This consists of the
* script type, inputs, outputs, input parameters, input variables, output
* variables, the symbol table, the script string, and the script execution
* string.
*
* @return information about this script as a String
*/
public String info() {
StringBuilder sb = new StringBuilder();
sb.append("Script Type: ");
sb.append(scriptType);
sb.append("\n\n");
sb.append(MLContextUtil.displayInputs("Inputs", inputs, symbolTable));
sb.append("\n");
sb.append(MLContextUtil.displayOutputs("Outputs", outputVariables, symbolTable));
sb.append("\n");
sb.append(MLContextUtil.displayMap("Input Parameters", inputParameters));
sb.append("\n");
sb.append(MLContextUtil.displaySet("Input Variables", inputVariables));
sb.append("\n");
sb.append(MLContextUtil.displaySet("Output Variables", outputVariables));
sb.append("\n");
sb.append(MLContextUtil.displaySymbolTable("Symbol Table", symbolTable));
sb.append("\nScript String:\n");
sb.append(scriptString);
sb.append("\nScript Execution String:\n");
sb.append(getScriptExecutionString());
sb.append("\n");
return sb.toString();
}
/**
* Display the script inputs.
*
* @return the script inputs
*/
public String displayInputs() {
return MLContextUtil.displayInputs("Inputs", inputs, symbolTable);
}
/**
* Display the script outputs.
*
* @return the script outputs as a String
*/
public String displayOutputs() {
return MLContextUtil.displayOutputs("Outputs", outputVariables, symbolTable);
}
/**
* Display the script input parameters.
*
* @return the script input parameters as a String
*/
public String displayInputParameters() {
return MLContextUtil.displayMap("Input Parameters", inputParameters);
}
/**
* Display the script input variables.
*
* @return the script input variables as a String
*/
public String displayInputVariables() {
return MLContextUtil.displaySet("Input Variables", inputVariables);
}
/**
* Display the script output variables.
*
* @return the script output variables as a String
*/
public String displayOutputVariables() {
return MLContextUtil.displaySet("Output Variables", outputVariables);
}
/**
* Display the script symbol table.
*
* @return the script symbol table as a String
*/
public String displaySymbolTable() {
return MLContextUtil.displaySymbolTable("Symbol Table", symbolTable);
}
/**
* Obtain the script name.
*
* @return the script name
*/
public String getName() {
return name;
}
/**
* Set the script name.
*
* @param name
* the script name
* @return {@code this} Script object to allow chaining of methods
*/
public Script setName(String name) {
this.name = name;
return this;
}
}
|
fschueler/incubator-systemml
|
src/main/java/org/apache/sysml/api/mlcontext/Script.java
|
Java
|
apache-2.0
| 17,736
|
<!DOCTYPE html>
<meta charset=utf-8>
<title>Redirecting...</title>
<link rel=canonical href="../宙/index.html">
<meta http-equiv=refresh content="0; url='../宙/index.html'">
<h1>Redirecting...</h1>
<a href="../宙/index.html">Click here if you are not redirected.</a>
<script>location='../宙/index.html'</script>
|
hochanh/hochanh.github.io
|
rtk/v4/1109.html
|
HTML
|
apache-2.0
| 316
|
# [20170123 码农日报](http://hao.caibaojian.com/date/2017/01/23)
[前端日报](http://caibaojian.com/c/news)栏目数据来自[码农头条](http://hao.caibaojian.com/)（我开发的爬虫），每日分享前端、移动开发、设计、资源和资讯等，为开发者提供动力，点击Star按钮来关注这个项目，点击Watch来收听每日的更新[Github主页](https://github.com/kujian/frontendDaily)
* [聊聊 SVG 基本形状转换那些事](http://hao.caibaojian.com/23230.html) （前端大全）
* [基于 vue+vuex+localStorage 开发的本地记事本](http://hao.caibaojian.com/23264.html) （SegmentFault）
* [你的产品适合用微信小程序来开发吗](http://hao.caibaojian.com/23248.html) （开发者头条）
* [Webpack 2 快速入门](http://hao.caibaojian.com/23246.html) （开发者头条）
* [JavaScript跨域方法汇总2](http://hao.caibaojian.com/23282.html) （前端开发博客）
***
* [如何开发一个功能强大的图片选择器（Android）](http://hao.caibaojian.com/23294.html) （开发者头条）
* [HTML5 Canvas处理头像上传](http://hao.caibaojian.com/23241.html) （程序员俱乐部）
* [超酷的网页源文件免费下载](http://hao.caibaojian.com/23286.html) （优秀网页设计）
* [Webpack 2最终版本发布，聚焦文档内容提升](http://hao.caibaojian.com/23196.html) （InfoQ）
* [基于netty http协议栈的轻量级流程控制组件的实现](http://hao.caibaojian.com/23200.html) （ImportNew）
***
* [支持WebVR，使Flash可以即点即运行](http://hao.caibaojian.com/23195.html) （InfoQ）
* [什么是Spark，如何使用Spark进行数据分析](http://hao.caibaojian.com/23275.html) （实验楼官方微博）
* [关于渐进式 Web 应用，你应该知道的一切](http://hao.caibaojian.com/23295.html) （开发者头条）
* [Chaos工程](http://hao.caibaojian.com/23197.html) （InfoQ）
* [Linux以外的7种开源操作系统](http://hao.caibaojian.com/23266.html) （程序师视野）
***
* [开发软件到底有多贵](http://hao.caibaojian.com/23240.html) （程序员俱乐部）
* [在程序员的眼里，用户是这样使用他们开发的软件的](http://hao.caibaojian.com/23253.html) （IT程序猿）
* [Google的算法出过哪些囧事](http://hao.caibaojian.com/23268.html) （程序师视野）
* [Why Most Startups Suck At PR](http://hao.caibaojian.com/23206.html) （湾区日报BayArea）
* [如何理解微信小程序的各种“没有”](http://hao.caibaojian.com/23269.html) （程序师视野）
***
* [和 Thrift 的一场美丽邂逅](http://hao.caibaojian.com/23201.html) （ImportNew）
* [Netflix 在它创造的世界里能生存下去吗](http://hao.caibaojian.com/23204.html) （湾区日报BayArea）
* [Hexo+OSChina](http://hao.caibaojian.com/23284.html) （开源中国）
* [九大工具助你玩转Java性能优化](http://hao.caibaojian.com/23256.html) （IT程序猿）
* [强力优化Rancher k8s中国区的使用体验](http://hao.caibaojian.com/23259.html) （SegmentFault）
***
* [改良程序的11技巧](http://hao.caibaojian.com/23270.html) （程序师视野）
* [Logback 源码赏析-日志按时间滚动（切割）](http://hao.caibaojian.com/23260.html) （SegmentFault）
* [微服务框架和工具大全](http://hao.caibaojian.com/23231.html) （阿里云云栖社区）
* [runtime 入门与简介](http://hao.caibaojian.com/23261.html) （SegmentFault）
* [free 命令](http://hao.caibaojian.com/23290.html) （伯乐在线官方微博）
日报维护作者：[前端开发博客](http://caibaojian.com/)
|
kujian/frontendDaily
|
2017/01/23.md
|
Markdown
|
apache-2.0
| 3,641
|
package org.miabis.converter.util;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.node.Node;
import static org.elasticsearch.node.NodeBuilder.*;
public class EmbeddedElasticsearchServer {
private static final String DEFAULT_DATA_DIRECTORY = "elasticsearch-data";
private final Node node;
private final String dataDirectory;
public EmbeddedElasticsearchServer() {
this(DEFAULT_DATA_DIRECTORY);
}
public EmbeddedElasticsearchServer(String dataDirectory) {
this.dataDirectory = dataDirectory;
Settings settings = Settings.settingsBuilder()
.put("http.enabled", "false")
.put("cluster", "test")
.put("path.home", dataDirectory)
.put("transport.tcp.port", 9300).build();
node = nodeBuilder()
.settings(settings)
.node().start();
}
public Client getClient() {
return node.client();
}
public void shutdown() {
node.close();
deleteDataDirectory();
}
private void deleteDataDirectory() {
try {
FileUtils.deleteDirectory(new File(dataDirectory));
} catch (IOException e) {
throw new RuntimeException("Could not delete data directory of embedded elasticsearch server", e);
}
}
}
|
MIABIS/miabis-converter
|
src/test/java/org/miabis/converter/util/EmbeddedElasticsearchServer.java
|
Java
|
apache-2.0
| 1,489
|
/*
Copyright 2016 The Rook Authors. 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.
*/
package model
type HealthStatus int
const (
HealthOK HealthStatus = iota
HealthWarning
HealthError
HealthUnknown
)
type StatusDetails struct {
OverallStatus HealthStatus `json:"overall"`
SummaryMessages []StatusSummary `json:"summary"`
Monitors []MonitorSummary `json:"monitors"`
OSDs OSDSummary `json:"osd"`
PGs PGSummary `json:"pg"`
Usage UsageSummary `json:"usage"`
}
type StatusSummary struct {
Status HealthStatus `json:"status"`
Message string `json:"message"`
}
type MonitorSummary struct {
Name string `json:"name"`
Address string `json:"address"`
InQuorum bool `json:"inQuorum"`
Status HealthStatus `json:"status"`
}
type OSDSummary struct {
Total int `json:"total"`
NumberIn int `json:"numIn"`
NumberUp int `json:"numUp"`
Full bool `json:"full"`
NearFull bool `json:"nearFull"`
}
type PGSummary struct {
Total int `json:"total"`
StateCounts map[string]int `json:"stateCount"`
}
type UsageSummary struct {
DataBytes uint64 `json:"data"`
UsedBytes uint64 `json:"used"`
AvailableBytes uint64 `json:"available"`
TotalBytes uint64 `json:"total"`
}
func HealthStatusToString(hs HealthStatus) string {
switch hs {
case HealthOK:
return "OK"
case HealthWarning:
return "WARNING"
case HealthError:
return "ERROR"
default:
return "UNKNOWN"
}
}
|
aramisjohnson/rook
|
pkg/model/status.go
|
GO
|
apache-2.0
| 2,015
|
<?php
/**
* ECSHOP SQL查詢語言項
* ============================================================================
* 版權所有 2005-2011 上海商派網絡科技有限公司，並保留所有權利。
* 網站地址: http://www.ecshop.com；
* ----------------------------------------------------------------------------
* 這不是一個自由軟件！您只能在不用於商業目的的前提下對程序代碼進行修改和
* 使用；不允許對程序代碼以任何形式任何目的的再發佈。
* ============================================================================
* $Author: liubo $
* $Id: sql.php 17217 2011-01-19 06:29:08Z liubo $
*/
$_LANG['title'] = '運行 SQL 查詢';
$_LANG['error'] = '出錯了';
$_LANG['succeed'] = 'SQL 語句已成功運行';
$_LANG['no_data'] = '返回結果為空';
$_LANG['note'] = '執行SQL將直接操作數據庫，請謹慎使用';
$_LANG['query'] = '提交查詢';
$_LANG['no_data'] = '返回結果為空';
/*JS 語言項*/
$_LANG['js_languages']['sql_not_null'] = 'SQL語句為空';
?>
|
lvguocai/ec
|
languages/zh_tw/admin/sql.php
|
PHP
|
apache-2.0
| 1,091
|
// Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
// Copyright (c) 2011, 2012 Open Networking Foundation
// Copyright (c) 2012, 2013 Big Switch Networks, Inc.
// This library was generated by the LoxiGen Compiler.
// See the file LICENSE.txt which should have been included in the source distribution
// Automatically generated by LOXI from template of_class.java
// Do not modify
package org.projectfloodlight.openflow.protocol.ver15;
import org.projectfloodlight.openflow.protocol.*;
import org.projectfloodlight.openflow.protocol.action.*;
import org.projectfloodlight.openflow.protocol.actionid.*;
import org.projectfloodlight.openflow.protocol.bsntlv.*;
import org.projectfloodlight.openflow.protocol.errormsg.*;
import org.projectfloodlight.openflow.protocol.meterband.*;
import org.projectfloodlight.openflow.protocol.instruction.*;
import org.projectfloodlight.openflow.protocol.instructionid.*;
import org.projectfloodlight.openflow.protocol.match.*;
import org.projectfloodlight.openflow.protocol.stat.*;
import org.projectfloodlight.openflow.protocol.oxm.*;
import org.projectfloodlight.openflow.protocol.oxs.*;
import org.projectfloodlight.openflow.protocol.queueprop.*;
import org.projectfloodlight.openflow.types.*;
import org.projectfloodlight.openflow.util.*;
import org.projectfloodlight.openflow.exceptions.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import com.google.common.collect.ImmutableSet;
import java.util.List;
import com.google.common.collect.ImmutableList;
import io.netty.buffer.ByteBuf;
import com.google.common.hash.PrimitiveSink;
import com.google.common.hash.Funnel;
class OFBsnGentableDescStatsReplyVer15 implements OFBsnGentableDescStatsReply {
private static final Logger logger = LoggerFactory.getLogger(OFBsnGentableDescStatsReplyVer15.class);
// version: 1.5
final static byte WIRE_VERSION = 6;
final static int MINIMUM_LENGTH = 24;
// maximum OF message length: 16 bit, unsigned
final static int MAXIMUM_LENGTH = 0xFFFF;
private final static long DEFAULT_XID = 0x0L;
private final static Set<OFStatsReplyFlags> DEFAULT_FLAGS = ImmutableSet.<OFStatsReplyFlags>of();
private final static List<OFBsnGentableDescStatsEntry> DEFAULT_ENTRIES = ImmutableList.<OFBsnGentableDescStatsEntry>of();
// OF message fields
private final long xid;
private final Set<OFStatsReplyFlags> flags;
private final List<OFBsnGentableDescStatsEntry> entries;
//
// Immutable default instance
final static OFBsnGentableDescStatsReplyVer15 DEFAULT = new OFBsnGentableDescStatsReplyVer15(
DEFAULT_XID, DEFAULT_FLAGS, DEFAULT_ENTRIES
);
// package private constructor - used by readers, builders, and factory
OFBsnGentableDescStatsReplyVer15(long xid, Set<OFStatsReplyFlags> flags, List<OFBsnGentableDescStatsEntry> entries) {
if(flags == null) {
throw new NullPointerException("OFBsnGentableDescStatsReplyVer15: property flags cannot be null");
}
if(entries == null) {
throw new NullPointerException("OFBsnGentableDescStatsReplyVer15: property entries cannot be null");
}
this.xid = U32.normalize(xid);
this.flags = flags;
this.entries = entries;
}
// Accessors for OF message fields
@Override
public OFVersion getVersion() {
return OFVersion.OF_15;
}
@Override
public OFType getType() {
return OFType.STATS_REPLY;
}
@Override
public long getXid() {
return xid;
}
@Override
public OFStatsType getStatsType() {
return OFStatsType.EXPERIMENTER;
}
@Override
public Set<OFStatsReplyFlags> getFlags() {
return flags;
}
@Override
public long getExperimenter() {
return 0x5c16c7L;
}
@Override
public long getSubtype() {
return 0x4L;
}
@Override
public List<OFBsnGentableDescStatsEntry> getEntries() {
return entries;
}
public OFBsnGentableDescStatsReply.Builder createBuilder() {
return new BuilderWithParent(this);
}
static class BuilderWithParent implements OFBsnGentableDescStatsReply.Builder {
final OFBsnGentableDescStatsReplyVer15 parentMessage;
// OF message fields
private boolean xidSet;
private long xid;
private boolean flagsSet;
private Set<OFStatsReplyFlags> flags;
private boolean entriesSet;
private List<OFBsnGentableDescStatsEntry> entries;
BuilderWithParent(OFBsnGentableDescStatsReplyVer15 parentMessage) {
this.parentMessage = parentMessage;
}
@Override
public OFVersion getVersion() {
return OFVersion.OF_15;
}
@Override
public OFType getType() {
return OFType.STATS_REPLY;
}
@Override
public long getXid() {
return xid;
}
@Override
public OFBsnGentableDescStatsReply.Builder setXid(long xid) {
this.xid = xid;
this.xidSet = true;
return this;
}
@Override
public OFStatsType getStatsType() {
return OFStatsType.EXPERIMENTER;
}
@Override
public Set<OFStatsReplyFlags> getFlags() {
return flags;
}
@Override
public OFBsnGentableDescStatsReply.Builder setFlags(Set<OFStatsReplyFlags> flags) {
this.flags = flags;
this.flagsSet = true;
return this;
}
@Override
public long getExperimenter() {
return 0x5c16c7L;
}
@Override
public long getSubtype() {
return 0x4L;
}
@Override
public List<OFBsnGentableDescStatsEntry> getEntries() {
return entries;
}
@Override
public OFBsnGentableDescStatsReply.Builder setEntries(List<OFBsnGentableDescStatsEntry> entries) {
this.entries = entries;
this.entriesSet = true;
return this;
}
@Override
public OFBsnGentableDescStatsReply build() {
long xid = this.xidSet ? this.xid : parentMessage.xid;
Set<OFStatsReplyFlags> flags = this.flagsSet ? this.flags : parentMessage.flags;
if(flags == null)
throw new NullPointerException("Property flags must not be null");
List<OFBsnGentableDescStatsEntry> entries = this.entriesSet ? this.entries : parentMessage.entries;
if(entries == null)
throw new NullPointerException("Property entries must not be null");
//
return new OFBsnGentableDescStatsReplyVer15(
xid,
flags,
entries
);
}
}
static class Builder implements OFBsnGentableDescStatsReply.Builder {
// OF message fields
private boolean xidSet;
private long xid;
private boolean flagsSet;
private Set<OFStatsReplyFlags> flags;
private boolean entriesSet;
private List<OFBsnGentableDescStatsEntry> entries;
@Override
public OFVersion getVersion() {
return OFVersion.OF_15;
}
@Override
public OFType getType() {
return OFType.STATS_REPLY;
}
@Override
public long getXid() {
return xid;
}
@Override
public OFBsnGentableDescStatsReply.Builder setXid(long xid) {
this.xid = xid;
this.xidSet = true;
return this;
}
@Override
public OFStatsType getStatsType() {
return OFStatsType.EXPERIMENTER;
}
@Override
public Set<OFStatsReplyFlags> getFlags() {
return flags;
}
@Override
public OFBsnGentableDescStatsReply.Builder setFlags(Set<OFStatsReplyFlags> flags) {
this.flags = flags;
this.flagsSet = true;
return this;
}
@Override
public long getExperimenter() {
return 0x5c16c7L;
}
@Override
public long getSubtype() {
return 0x4L;
}
@Override
public List<OFBsnGentableDescStatsEntry> getEntries() {
return entries;
}
@Override
public OFBsnGentableDescStatsReply.Builder setEntries(List<OFBsnGentableDescStatsEntry> entries) {
this.entries = entries;
this.entriesSet = true;
return this;
}
//
@Override
public OFBsnGentableDescStatsReply build() {
long xid = this.xidSet ? this.xid : DEFAULT_XID;
Set<OFStatsReplyFlags> flags = this.flagsSet ? this.flags : DEFAULT_FLAGS;
if(flags == null)
throw new NullPointerException("Property flags must not be null");
List<OFBsnGentableDescStatsEntry> entries = this.entriesSet ? this.entries : DEFAULT_ENTRIES;
if(entries == null)
throw new NullPointerException("Property entries must not be null");
return new OFBsnGentableDescStatsReplyVer15(
xid,
flags,
entries
);
}
}
final static Reader READER = new Reader();
static class Reader implements OFMessageReader<OFBsnGentableDescStatsReply> {
@Override
public OFBsnGentableDescStatsReply readFrom(ByteBuf bb) throws OFParseError {
int start = bb.readerIndex();
// fixed value property version == 6
byte version = bb.readByte();
if(version != (byte) 0x6)
throw new OFParseError("Wrong version: Expected=OFVersion.OF_15(6), got="+version);
// fixed value property type == 19
byte type = bb.readByte();
if(type != (byte) 0x13)
throw new OFParseError("Wrong type: Expected=OFType.STATS_REPLY(19), got="+type);
int length = U16.f(bb.readShort());
if(length < MINIMUM_LENGTH)
throw new OFParseError("Wrong length: Expected to be >= " + MINIMUM_LENGTH + ", was: " + length);
if(bb.readableBytes() + (bb.readerIndex() - start) < length) {
// Buffer does not have all data yet
bb.readerIndex(start);
return null;
}
if(logger.isTraceEnabled())
logger.trace("readFrom - length={}", length);
long xid = U32.f(bb.readInt());
// fixed value property statsType == 65535
short statsType = bb.readShort();
if(statsType != (short) 0xffff)
throw new OFParseError("Wrong statsType: Expected=OFStatsType.EXPERIMENTER(65535), got="+statsType);
Set<OFStatsReplyFlags> flags = OFStatsReplyFlagsSerializerVer15.readFrom(bb);
// pad: 4 bytes
bb.skipBytes(4);
// fixed value property experimenter == 0x5c16c7L
int experimenter = bb.readInt();
if(experimenter != 0x5c16c7)
throw new OFParseError("Wrong experimenter: Expected=0x5c16c7L(0x5c16c7L), got="+experimenter);
// fixed value property subtype == 0x4L
int subtype = bb.readInt();
if(subtype != 0x4)
throw new OFParseError("Wrong subtype: Expected=0x4L(0x4L), got="+subtype);
List<OFBsnGentableDescStatsEntry> entries = ChannelUtils.readList(bb, length - (bb.readerIndex() - start), OFBsnGentableDescStatsEntryVer15.READER);
OFBsnGentableDescStatsReplyVer15 bsnGentableDescStatsReplyVer15 = new OFBsnGentableDescStatsReplyVer15(
xid,
flags,
entries
);
if(logger.isTraceEnabled())
logger.trace("readFrom - read={}", bsnGentableDescStatsReplyVer15);
return bsnGentableDescStatsReplyVer15;
}
}
public void putTo(PrimitiveSink sink) {
FUNNEL.funnel(this, sink);
}
final static OFBsnGentableDescStatsReplyVer15Funnel FUNNEL = new OFBsnGentableDescStatsReplyVer15Funnel();
static class OFBsnGentableDescStatsReplyVer15Funnel implements Funnel<OFBsnGentableDescStatsReplyVer15> {
private static final long serialVersionUID = 1L;
@Override
public void funnel(OFBsnGentableDescStatsReplyVer15 message, PrimitiveSink sink) {
// fixed value property version = 6
sink.putByte((byte) 0x6);
// fixed value property type = 19
sink.putByte((byte) 0x13);
// FIXME: skip funnel of length
sink.putLong(message.xid);
// fixed value property statsType = 65535
sink.putShort((short) 0xffff);
OFStatsReplyFlagsSerializerVer15.putTo(message.flags, sink);
// skip pad (4 bytes)
// fixed value property experimenter = 0x5c16c7L
sink.putInt(0x5c16c7);
// fixed value property subtype = 0x4L
sink.putInt(0x4);
FunnelUtils.putList(message.entries, sink);
}
}
public void writeTo(ByteBuf bb) {
WRITER.write(bb, this);
}
final static Writer WRITER = new Writer();
static class Writer implements OFMessageWriter<OFBsnGentableDescStatsReplyVer15> {
@Override
public void write(ByteBuf bb, OFBsnGentableDescStatsReplyVer15 message) {
int startIndex = bb.writerIndex();
// fixed value property version = 6
bb.writeByte((byte) 0x6);
// fixed value property type = 19
bb.writeByte((byte) 0x13);
// length is length of variable message, will be updated at the end
int lengthIndex = bb.writerIndex();
bb.writeShort(U16.t(0));
bb.writeInt(U32.t(message.xid));
// fixed value property statsType = 65535
bb.writeShort((short) 0xffff);
OFStatsReplyFlagsSerializerVer15.writeTo(bb, message.flags);
// pad: 4 bytes
bb.writeZero(4);
// fixed value property experimenter = 0x5c16c7L
bb.writeInt(0x5c16c7);
// fixed value property subtype = 0x4L
bb.writeInt(0x4);
ChannelUtils.writeList(bb, message.entries);
// update length field
int length = bb.writerIndex() - startIndex;
if (length > MAXIMUM_LENGTH) {
throw new IllegalArgumentException("OFBsnGentableDescStatsReplyVer15: message length (" + length + ") exceeds maximum (0xFFFF)");
}
bb.setShort(lengthIndex, length);
}
}
@Override
public String toString() {
StringBuilder b = new StringBuilder("OFBsnGentableDescStatsReplyVer15(");
b.append("xid=").append(xid);
b.append(", ");
b.append("flags=").append(flags);
b.append(", ");
b.append("entries=").append(entries);
b.append(")");
return b.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
OFBsnGentableDescStatsReplyVer15 other = (OFBsnGentableDescStatsReplyVer15) obj;
if( xid != other.xid)
return false;
if (flags == null) {
if (other.flags != null)
return false;
} else if (!flags.equals(other.flags))
return false;
if (entries == null) {
if (other.entries != null)
return false;
} else if (!entries.equals(other.entries))
return false;
return true;
}
@Override
public boolean equalsIgnoreXid(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
OFBsnGentableDescStatsReplyVer15 other = (OFBsnGentableDescStatsReplyVer15) obj;
// ignore XID
if (flags == null) {
if (other.flags != null)
return false;
} else if (!flags.equals(other.flags))
return false;
if (entries == null) {
if (other.entries != null)
return false;
} else if (!entries.equals(other.entries))
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * (int) (xid ^ (xid >>> 32));
result = prime * result + ((flags == null) ? 0 : flags.hashCode());
result = prime * result + ((entries == null) ? 0 : entries.hashCode());
return result;
}
@Override
public int hashCodeIgnoreXid() {
final int prime = 31;
int result = 1;
// ignore XID
result = prime * result + ((flags == null) ? 0 : flags.hashCode());
result = prime * result + ((entries == null) ? 0 : entries.hashCode());
return result;
}
}
|
floodlight/loxigen-artifacts
|
openflowj/gen-src/main/java/org/projectfloodlight/openflow/protocol/ver15/OFBsnGentableDescStatsReplyVer15.java
|
Java
|
apache-2.0
| 17,049
|
/*
* Copyright 2020 Red Hat, Inc. and/or its affiliates.
*
* 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.
*/
package org.optaplanner.core.impl.heuristic.selector;
import java.util.Spliterator;
import java.util.Spliterators;
import org.optaplanner.core.impl.heuristic.selector.common.decorator.SelectionProbabilityWeightFactory;
public interface IterableSelector<Solution_, T> extends Selector<Solution_>, Iterable<T> {
/**
* A random JIT {@link Selector} with {@link #isNeverEnding()} true should return a size
* as if it would be able to return each distinct element only once,
* because the size can be used in {@link SelectionProbabilityWeightFactory}.
*
* @return the approximate number of elements generated by this {@link Selector}, always {@code >= 0}
* @throws IllegalStateException if {@link #isCountable} returns false,
* but not if only {@link #isNeverEnding()} returns true
*/
long getSize();
@Override
default Spliterator<T> spliterator() {
if (isCountable()) {
return Spliterators.spliterator(iterator(), getSize(), Spliterator.ORDERED);
} else {
return Iterable.super.spliterator();
}
}
}
|
tkobayas/optaplanner
|
optaplanner-core/src/main/java/org/optaplanner/core/impl/heuristic/selector/IterableSelector.java
|
Java
|
apache-2.0
| 1,738
|
#!/usr/bin/env ruby
$LOAD_PATH.push(File.expand_path(File.dirname(__FILE__)))
require 'init'
require 'base64'
require 'json'
require __DIR__('helper/db_helper')
require __DIR__('../start')
describe UserController do
behaves_like :rack_test, :db_helper
before do
reset_db
end
def encode_credentials(username, password)
"Basic " + Base64.encode64("#{username}:#{password}")
end
it 'should return a list of users on GET /user' do
got = get('/user')
got.status.should == 200
got.body.should == '["nobody"]'
email = "someone@somewhere.com"
password = "somepassword"
got = post('/user/somebody', {:email => email, :password => password})
got.status.should == 201
got = get('/user')
got.status.should == 200
got.body.should == '["nobody","somebody"]'
end
it 'should return 404 for a user that does not exist' do
got = get('/user/nothere')
got.status.should == 404
got = delete('/user/nothere')
got.status.should == 404
end
it 'should get the details of an specified user on GET /user/name' do
got = get('/user/nobody')
got.status.should == 200
data = JSON.parse(got.body)
data["name"].should == "nobody"
data["email"].should == "nobody@nowhere.com"
end
it 'should create a new user on POST /user/name' do
email = "someone@somewhere.com"
password = "somepassword"
got = post('/user/somebody', {:email => email, :password => password})
got.status.should == 201
got = get('/user/somebody')
got.status.should == 200
data = JSON.parse(got.body)
data["name"].should == "somebody"
data["email"].should == email
end
it 'should bleat if email and/or password not specified' do
got = post('/user/somebody', {:email => "email"})
got.status.should == 403
got.body.should.include? "password"
got = post('/user/somebody', {:password => "password"})
got.status.should == 403
got.body.should.include? "email"
end
it 'should treat duplicate users as data updates' do
got = post('/user/somebody', {:email => "email", :password => "password"})
got.status.should == 201
got = post('/user/somebody', {:email => "email", :password => "password"})
got.status.should == 401
end
it 'should not be able to change user details unless authenticated as that user' do
got = post('/user/somebody', {:email => "email", :password => "password"})
got.status.should == 201
got = post('/user/me', {:email => "me", :password => "me"})
got.status.should == 201
got = post('/user/somebody', {:password => "newpassword"})
got.status.should == 401
authorize("me", "me")
got = post('/user/somebody?password=newpassword')
got.status.should == 401
authorize("somebody", "password")
got = post('/user/somebody?password=newpassword')
got.status.should == 200
Owner[:name => "somebody"].password.should == MD5.hexdigest("newpassword")
authorize("somebody", "newpassword")
got = post('/user/somebody?email=newemail')
got.status.should == 200
Owner[:name => "somebody"].email.should == "newemail"
end
it 'should be able to delete a user when authenticated as that user' do
got = post('/user/somebody', {:email => "email", :password => "password"})
got.status.should == 201
got = post('/user/me', {:email => "me", :password => "me"})
got.status.should == 201
got = delete('/user/somebody')
got.status.should == 401
authorize("me", "me")
got = delete('/user/somebody')
got.status.should == 401
authorize("somebody", "password")
got = delete('/user/somebody')
got.status.should == 200
got = get('/user/somebody')
got.status.should == 404
end
end
|
yannbelief/escservesconfig
|
spec/user.rb
|
Ruby
|
apache-2.0
| 4,080
|
# AUTOGENERATED FILE
FROM balenalib/n510-tx2-debian:jessie-run
ENV GO_VERSION 1.14.14
# gcc for cgo
RUN apt-get update && apt-get install -y --no-install-recommends \
g++ \
gcc \
libc6-dev \
make \
pkg-config \
git \
&& rm -rf /var/lib/apt/lists/*
RUN set -x \
&& fetchDeps=' \
curl \
' \
&& apt-get update && apt-get install -y $fetchDeps --no-install-recommends && rm -rf /var/lib/apt/lists/* \
&& mkdir -p /usr/local/go \
&& curl -SLO "https://storage.googleapis.com/golang/go$GO_VERSION.linux-arm64.tar.gz" \
&& echo "511d764197121f212d130724afb9c296f0cb4a22424e5ae956a5cc043b0f4a29 go$GO_VERSION.linux-arm64.tar.gz" | sha256sum -c - \
&& tar -xzf "go$GO_VERSION.linux-arm64.tar.gz" -C /usr/local/go --strip-components=1 \
&& rm -f go$GO_VERSION.linux-arm64.tar.gz
ENV GOROOT /usr/local/go
ENV GOPATH /go
ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" && chmod -R 777 "$GOPATH"
WORKDIR $GOPATH
CMD ["echo","'No CMD command was set in Dockerfile! Details about CMD command could be found in Dockerfile Guide section in our Docs. Here's the link: https://balena.io/docs"]
RUN curl -SLO "https://raw.githubusercontent.com/balena-io-library/base-images/8accad6af708fca7271c5c65f18a86782e19f877/scripts/assets/tests/test-stack@golang.sh" \
&& echo "Running test-stack@golang" \
&& chmod +x test-stack@golang.sh \
&& bash test-stack@golang.sh \
&& rm -rf test-stack@golang.sh
RUN [ ! -d /.balena/messages ] && mkdir -p /.balena/messages; echo 'Here are a few details about this Docker image (For more information please visit https://www.balena.io/docs/reference/base-images/base-images/): \nArchitecture: ARM v8 \nOS: Debian Jessie \nVariant: run variant \nDefault variable(s): UDEV=off \nThe following software stack is preinstalled: \nGo v1.14.14 \nExtra features: \n- Easy way to install packages with `install_packages <package-name>` command \n- Run anywhere with cross-build feature (for ARM only) \n- Keep the container idling with `balena-idle` command \n- Show base image details with `balena-info` command' > /.balena/messages/image-info
RUN echo '#!/bin/sh.real\nbalena-info\nrm -f /bin/sh\ncp /bin/sh.real /bin/sh\n/bin/sh "$@"' > /bin/sh-shim \
&& chmod +x /bin/sh-shim \
&& cp /bin/sh /bin/sh.real \
&& mv /bin/sh-shim /bin/sh
|
nghiant2710/base-images
|
balena-base-images/golang/n510-tx2/debian/jessie/1.14.14/run/Dockerfile
|
Dockerfile
|
apache-2.0
| 2,325
|
{% load admin_list suit_list %}
{% load i18n %}
{% if cl.formset and cl.result_count %}
<input type="submit" name="_save" class="default btn btn-primary changelist-save pull-right" value="{% trans 'Save' %}"/>
{% endif %}
<div class="paginator clearfix">
{% if pagination_required %}
<div class="row">
<div class="col-xs-12 text-center">
<ul class="pagination">
{% for i in page_range %}
{% paginator_number cl i %}
{% endfor %}
</ul>
</div>
</div>
{% endif %}
<div class="pagination-info row">
<div class="col-xs-8">
{% trans 'Displaying:' %}
{% paginator_info cl %}
of
{{ cl.result_count }}
{% ifequal cl.result_count 1 %}
{{ cl.opts.verbose_name }}
{% else %}
{{ cl.opts.verbose_name_plural }}
{% endifequal %}
{% if show_all_url %}
</div>
<div class="col-xs-4 text-right">
<a href="{{ show_all_url }}" class="showall">{% trans 'Show all' %}</a>{% endif %}
</div>
</div>
</div>
|
zdw/xos
|
xos/templates/admin/pagination.html
|
HTML
|
apache-2.0
| 1,075
|
/***************************************************************
*
* Copyright (C) 1990-2007, Condor Team, Computer Sciences Department,
* University of Wisconsin-Madison, WI.
*
* 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 "condor_common.h"
#include "condor_config.h"
#include "read_multiple_logs.h"
#include "basename.h"
#include "tmp_dir.h"
#include "dagman_multi_dag.h"
#include "condor_getcwd.h"
// Just so we can link in the ReadMultipleUserLogs class.
MULTI_LOG_HASH_INSTANCE;
//-------------------------------------------------------------------------
static void
AppendError(MyString &errMsg, const MyString &newError)
{
if ( errMsg != "" ) errMsg += "; ";
errMsg += newError;
}
//-------------------------------------------------------------------------
bool
GetConfigFile(/* const */ StringList &dagFiles, bool useDagDir,
MyString &configFile, MyString &errMsg)
{
bool result = true;
TmpDir dagDir;
dagFiles.rewind();
char *dagFile;
while ( (dagFile = dagFiles.next()) != NULL ) {
//
// Change to the DAG file's directory if necessary, and
// get the filename we need to use for it from that directory.
//
const char * newDagFile;
if ( useDagDir ) {
MyString tmpErrMsg;
if ( !dagDir.Cd2TmpDirFile( dagFile, tmpErrMsg ) ) {
AppendError( errMsg,
MyString("Unable to change to DAG directory ") +
tmpErrMsg );
return false;
}
newDagFile = condor_basename( dagFile );
} else {
newDagFile = dagFile;
}
//
// Get the list of config files from the current DAG file.
//
StringList configFiles;
MyString msg = MultiLogFiles::getValuesFromFile( newDagFile, "config",
configFiles);
if ( msg != "" ) {
AppendError( errMsg,
MyString("Failed to locate Condor job log files: ") +
msg );
result = false;
}
//
// Check the specified config file(s) against whatever we
// currently have, setting the config file if it hasn't
// been set yet, flagging an error if config files conflict.
//
configFiles.rewind();
char * cfgFile;
while ( (cfgFile = configFiles.next()) ) {
MyString cfgFileMS = cfgFile;
MyString tmpErrMsg;
if ( MakePathAbsolute( cfgFileMS, tmpErrMsg ) ) {
if ( configFile == "" ) {
configFile = cfgFileMS;
} else if ( configFile != cfgFileMS ) {
AppendError( errMsg, MyString("Conflicting DAGMan ") +
"config files specified: " + configFile +
" and " + cfgFileMS );
result = false;
}
} else {
AppendError( errMsg, tmpErrMsg );
result = false;
}
}
//
// Go back to our original directory.
//
MyString tmpErrMsg;
if ( !dagDir.Cd2MainDir( tmpErrMsg ) ) {
AppendError( errMsg,
MyString("Unable to change to original directory ") +
tmpErrMsg );
result = false;
}
}
return result;
}
//-------------------------------------------------------------------------
bool
MakePathAbsolute(MyString &filePath, MyString &errMsg)
{
bool result = true;
if ( !fullpath( filePath.Value() ) ) {
MyString currentDir;
if ( ! condor_getcwd( currentDir ) ) {
errMsg = MyString( "condor_getcwd() failed with errno " ) +
errno + " (" + strerror(errno) + ") at " + __FILE__
+ ":" + __LINE__;
result = false;
}
filePath = currentDir + DIR_DELIM_STRING + filePath;
}
return result;
}
//-------------------------------------------------------------------------
int
FindLastRescueDagNum( const char *primaryDagFile, bool multiDags,
int maxRescueDagNum )
{
int lastRescue = 0;
for ( int test = 1; test <= maxRescueDagNum; test++ ) {
MyString testName = RescueDagName( primaryDagFile, multiDags,
test );
if ( access( testName.Value(), F_OK ) == 0 ) {
if ( test > lastRescue + 1 ) {
// This should probably be a fatal error if
// DAGMAN_USE_STRICT is set, but I'm avoiding
// that for now because the fact that this code
// is used in both condor_dagman and condor_submit_dag
// makes that harder to implement. wenger 2011-01-28
dprintf( D_ALWAYS, "Warning: found rescue DAG "
"number %d, but not rescue DAG number %d\n",
test, test - 1);
}
lastRescue = test;
}
}
if ( lastRescue >= maxRescueDagNum ) {
dprintf( D_ALWAYS,
"Warning: FindLastRescueDagNum() hit maximum "
"rescue DAG number: %d\n", maxRescueDagNum );
}
return lastRescue;
}
//-------------------------------------------------------------------------
MyString
RescueDagName(const char *primaryDagFile, bool multiDags,
int rescueDagNum)
{
ASSERT( rescueDagNum >= 1 );
MyString fileName(primaryDagFile);
if ( multiDags ) {
fileName += "_multi";
}
fileName += ".rescue";
fileName.formatstr_cat( "%.3d", rescueDagNum );
return fileName;
}
//-------------------------------------------------------------------------
void
RenameRescueDagsAfter(const char *primaryDagFile, bool multiDags,
int rescueDagNum, int maxRescueDagNum)
{
// Need to allow 0 here so condor_submit_dag -f can rename all
// rescue DAGs.
ASSERT( rescueDagNum >= 0 );
dprintf( D_ALWAYS, "Renaming rescue DAGs newer than number %d\n",
rescueDagNum );
int firstToDelete = rescueDagNum + 1;
int lastToDelete = FindLastRescueDagNum( primaryDagFile, multiDags,
maxRescueDagNum );
for ( int rescueNum = firstToDelete; rescueNum <= lastToDelete;
rescueNum++ ) {
MyString rescueDagName = RescueDagName( primaryDagFile, multiDags,
rescueNum );
dprintf( D_ALWAYS, "Renaming %s\n", rescueDagName.Value() );
MyString newName = rescueDagName + ".old";
if ( rename( rescueDagName.Value(), newName.Value() ) != 0 ) {
EXCEPT( "Fatal error: unable to rename old rescue file "
"%s: error %d (%s)\n", rescueDagName.Value(),
errno, strerror( errno ) );
}
}
}
//-------------------------------------------------------------------------
MyString
HaltFileName( const MyString &primaryDagFile )
{
MyString haltFile = primaryDagFile + ".halt";
return haltFile;
}
|
djw8605/condor
|
src/condor_dagman/dagman_multi_dag.cpp
|
C++
|
apache-2.0
| 6,576
|
/*
* Copyright 2009 The Closure Compiler Authors.
*
* 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.
*/
package com.google.javascript.jscomp;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/**
* Tests OptimizeReturns
*
* @author johnlenz@google.com (John Lenz)
*/
@RunWith(JUnit4.class)
public final class OptimizeReturnsTest extends CompilerTestCase {
@Override
protected CompilerPass getProcessor(Compiler compiler) {
return new OptimizeReturns(compiler);
}
private static final String EXTERNAL_SYMBOLS = lines("var extern;", "extern.externalMethod");
public OptimizeReturnsTest() {
super(lines(DEFAULT_EXTERNS, EXTERNAL_SYMBOLS));
}
@Override
@Before
public void setUp() throws Exception {
super.setUp();
enableNormalize(); // Required for `OptimizeCalls`.
enableGatherExternProperties();
}
@Override
protected int getNumRepetitions() {
// run pass once.
return 1;
}
@Test
public void testNoRewriteUsedResult1() {
String source = lines(
"function a(){return 1}",
"var x = a()");
testSame(source);
}
@Test
public void testNoRewriteUsedResult2() {
String source = lines(
"var a = function(){return 1}",
"a(); var b = a()");
testSame(source);
}
@Test
public void testNoRewriteUsedClassMethodResult1() {
String source = lines(
"class C { method() {return 1} }",
"var x = new C().method()");
testSame(source);
}
@Test
public void testNoRewriteUnsedObjectMethodResult1() {
String source = lines(
"var o = { method() {return 1} }",
"o.method()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredArray1() {
String source = lines(
"var x = function() { return 1; };",
"[x] = []",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredArray2() {
String source = lines(
"var x = function() { return 1; };",
"[x = function() {}] = []",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredArray3() {
String source = lines(
"class C { method() { return 1 }}",
"[x.method] = []",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredArray4() {
String source = lines(
"class C { method() { return 1 }}",
"[x.method] = []",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredObject1() {
String source = lines(
"var x = function() { return 1; };",
"({a:x} = {})",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredObject2() {
String source = lines(
"var x = function() { return 1; };",
"({a:x = function() {}} = {})",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredObject3() {
String source = lines(
"class C { method() { return 1 }}",
"({a:x.method} = {})",
"x()");
testSame(source);
}
@Test
public void testNoRewriteDestructuredObject4() {
String source = lines(
"class C { method() { return 1 }}",
"({a:x.method = function() {}} = {})",
"x()");
testSame(source);
}
@Test
public void testNoRewriteTagged1() {
// TODO(johnlenz): support this. Unused return can be removed.
String source = lines(
"var f = function() { return 1; };",
"f`tagged`");
testSame(source);
}
@Test
public void testNoRewriteTagged2() {
// Tagged use prevents optimizations
String source = lines(
"var f = function() { return 1; };",
"var x = f`tagged`");
testSame(source);
}
@Test
public void testNoRewriteTagged3() {
// Tagged use is not ignored.
String source = lines(
"var f = function() { return 1; };",
"var x = f`tagged`",
"f()");
testSame(source);
}
@Test
public void testNoRewriteConstructorProp() {
String source = lines(
"class C { constructor() { return 1 } }",
"x.constructor()");
testSame(source);
}
@Test
public void testRewriteUnusedResult1() {
String source = lines(
"function a(){return 1}",
"a()");
String expected = lines(
"function a(){return}",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResult2() {
String source = lines(
"var a; a = function(){return 1}",
"a()");
String expected = lines(
"var a; a = function(){return}",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResult3() {
String source = lines(
"var a = function(){return 1}",
"a()");
String expected = lines(
"var a = function(){return}",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResult4a() {
String source = lines(
"var a = function(){return a()}",
"a()");
testSame(source);
}
@Test
public void testRewriteUnusedResult4b() {
String source = lines(
"var a = function b(){return b()}",
"a()");
testSame(source);
}
@Test
public void testRewriteUnusedResult4c() {
String source = lines(
"function a(){return a()}",
"a()");
testSame(source);
}
@Test
public void testRewriteUnusedResult5() {
String source = lines(
"function a(){}",
"a.prototype.foo = function(args) {return args};",
"var o = new a;",
"o.foo()");
String expected = lines(
"function a(){}",
"a.prototype.foo = function(args) {args;return};",
"var o = new a;",
"o.foo()");
test(source, expected);
}
@Test
public void testRewriteUnusedResult6() {
String source = lines(
"function a(){return (g = 1)}",
"a()");
String expected = lines(
"function a(){g = 1;return}",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResult7a() {
String source = lines(
"function a() { return 1 }",
"function b() { return a() }",
"function c() { return b() }",
"c();");
String expected = lines(
"function a() { return 1 }",
"function b() { return a() }",
"function c() { b(); return }",
"c();");
test(source, expected);
}
@Test
public void testRewriteUnusedResult7b() {
String source = lines(
"c();",
"function c() { return b() }",
"function b() { return a() }",
"function a() { return 1 }");
// Iteration 1.
String expected = lines(
"c();",
"function c() { b(); return }",
"function b() { return a() }",
"function a() { return 1 }");
test(source, expected);
// Iteration 2.
source = expected;
expected = lines(
"c();",
"function c() { b(); return }",
"function b() { a(); return }",
"function a() { return 1 }");
test(source, expected);
// Iteration 3.
source = expected;
expected = lines(
"c();",
"function c() { b(); return }",
"function b() { a(); return }",
"function a() { return }");
test(source, expected);
}
@Test
public void testRewriteUnusedResult8() {
String source = lines(
"function a() { return c() }",
"function b() { return a() }",
"function c() { return b() }",
"c();");
testSame(source);
}
@Test
public void testRewriteUnusedResult9() {
// Proves that the deleted function scope is reported.
String source = lines(
"function a(){return function() {};}",
"a()");
String expected = lines(
"function a(){(function() {}); return}",
"a()");
test(source, expected);
}
@Test
public void testRewriteUsedResult10() {
String source = lines(
"class C { method() {return 1} }",
"new C().method()");
String expected = lines(
"class C { method() {return} }",
"new C().method()");
test(source, expected);
}
@Test
public void testRewriteUnusedTemplateLitResult() {
// Proves that the deleted function scope is reported.
String source = lines("function a(){ return `template`; }", "a()");
String expected = lines("function a(){ return; }", "a()");
test(source, expected);
}
@Test
public void testRewriteUnusedAsyncResult1() {
// Async function returns can be dropped if no-one waits on the returned
// promise.
String source = lines(
"async function a(){return promise}",
"a()");
String expected = lines(
"async function a(){promise; return}",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedGeneratorResult1() {
// Generator function returns can be dropped if no-one uses the returned
// iterator.
String source = lines(
"function *a(){return value}",
"a()");
String expected = lines(
"function *a(){value; return}",
"a()");
test(source, expected);
}
@Test
public void testNoRewriteObjLit1() {
String source = lines(
"var a = {b:function(){return 1;}}",
"for(c in a) (a[c])();",
"a.b()");
testSame(source);
}
@Test
public void testNoRewriteObjLit2() {
String source = lines(
"var a = {b:function fn(){return 1;}}",
"for(c in a) (a[c])();",
"a.b()");
testSame(source);
}
@Test
public void testNoRewriteArrLit() {
String source = lines(
"var a = [function(){return 1;}]",
"(a[0])();");
testSame(source);
}
@Test
public void testPrototypeMethod1() {
String source = lines(
"function c(){}",
"c.prototype.a = function(){return 1}",
"var x = new c;",
"x.a()");
String result = lines(
"function c(){}",
"c.prototype.a = function(){return}",
"var x = new c;",
"x.a()");
test(source, result);
}
@Test
public void testPrototypeMethod2() {
String source = lines(
"function c(){}",
"c.prototype.a = function(){return 1}",
"goog.reflect.object({a: 'v'})",
"var x = new c;",
"x.a()");
testSame(source);
}
@Test
public void testPrototypeMethod3() {
String source = lines(
"function c(){}",
"c.prototype.a = function(){return 1}",
"var x = new c;",
"for(var key in goog.reflect.object({a: 'v'})){ x[key](); }",
"x.a()");
testSame(source);
}
@Test
public void testPrototypeMethod4() {
String source = lines(
"function c(){}",
"c.prototype.a = function(){return 1}",
"var x = new c;",
"for(var key in goog.reflect.object({a: 'v'})){ x[key](); }");
testSame(source);
}
@Test
public void testCallOrApply() {
// TODO(johnlenz): Add support for .apply
test(
"function a() {return 1}; a.call(new foo);",
"function a() {return }; a.call(new foo);");
testSame("function a() {return 1}; a.apply(new foo);");
}
@Test
public void testRewriteUseSiteRemoval() {
String source = lines(
"function a() { return {\"_id\" : 1} }",
"a();");
String expected = lines(
"function a() { ({\"_id\" : 1}); return }",
"a();");
test(source, expected);
}
@Test
public void testUnknownDefinitionAllowRemoval() {
// TODO(johnlenz): allow this to be optimized.
testSame(
lines(
"let x = functionFactory();",
"x(1, 2);",
"x = function(a,b) { return b; }"));
}
@Test
public void testRewriteUnusedResultWithSafeReference1() {
String source = lines(
"function a(){return 1}",
"typeof a",
"a()");
String expected = lines(
"function a(){return}",
"typeof a",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResultWithSafeReference2() {
String source = lines(
"function a(){return 1}",
"x instanceof a",
"a instanceof x",
"a()");
String expected = lines(
"function a(){return}",
"x instanceof a",
"a instanceof x",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResultWithSafeReference3() {
String source = lines(
"function a(){return 1}",
"x in a",
"a in x",
"a()");
String expected = lines(
"function a(){return}",
"x in a",
"a in x",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResultWithSafeReference4() {
String source = lines(
"function a(){return 1}",
"a.x",
"a['x']",
"a()");
String expected = lines(
"function a(){return}",
"a.x",
"a['x']",
"a()");
test(source, expected);
}
@Test
public void testRewriteUnusedResultWithSafeReference5() {
String source = lines(
"function a(){return 1}",
"for (x in a) {}",
"for (x of a) {}",
"a()");
String expected = lines(
"function a(){return}",
"for (x in a) {}",
"for (x of a) {}",
"a()");
test(source, expected);
}
@Test
public void testNoRewriteUnusedResultWithUnsafeReference1() {
// call to 'a.x' escapes 'a' as 'this'
String source = lines(
"function a(){return 1}",
"a.x()",
"a()");
testSame(source);
}
@Test
public void testNoRewriteUnusedResultWithUnsafeReference2() {
// call to 'a.x' escapes 'a' as 'this'
String source = lines(
"function a(){return 1}",
"a['x']()",
"a()");
testSame(source);
}
@Test
public void testNoRewriteUnusedResultWithUnsafeReference3() {
// call to 'a' is assigned an unknown value
String source = lines(
"function a(){return 1}",
"for (a in x) {}",
"a()");
testSame(source);
}
@Test
public void testNoRewriteUnusedResultWithUnsafeReference4() {
// call to 'a' is assigned an unknown value
// TODO(johnlenz): optimize this.
String source = lines(
"function a(){return 1}",
"for (a of x) {}",
"a()");
testSame(source);
}
}
|
Yannic/closure-compiler
|
test/com/google/javascript/jscomp/OptimizeReturnsTest.java
|
Java
|
apache-2.0
| 14,990
|
package dsmoq.controllers.json
/**
* サジェスト系検索APIのリクエストに使用するJSON型のケースクラス
*
* 具体的には、以下のAPIで使用する。
* GET /api/suggests/users
* GET /api/suggests/groups
* GET /api/suggests/attributes
*
* @param query 検索文字列
* @param limit 検索件数上限
* @param offset 検索位置
*/
case class SuggestApiParams(
query: Option[String] = None,
limit: Option[Int] = None,
offset: Option[Int] = None
)
/**
* GET /api/suggests/users_and_groupsのリクエストに使用するJSON型のケースクラス
*
* @param query 検索文字列
* @param limit 検索件数上限
* @param offset 検索位置
* @param excludeIds 検索から除外するユーザー・グループID
*/
case class UserAndGroupSuggestApiParams(
query: Option[String] = None,
limit: Option[Int] = None,
offset: Option[Int] = None,
excludeIds: Seq[String] = Seq.empty
)
|
nkawa/dsmoq
|
server/apiServer/src/main/scala/dsmoq/controllers/json/SuggestApiParams.scala
|
Scala
|
apache-2.0
| 950
|
/*
* Copyright 2017-2022 Amazon.com, Inc. or its affiliates. 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. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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.
*/
package com.amazonaws.services.elasticinference.model.transform;
import java.util.List;
import javax.annotation.Generated;
import com.amazonaws.SdkClientException;
import com.amazonaws.services.elasticinference.model.*;
import com.amazonaws.protocol.*;
import com.amazonaws.annotation.SdkInternalApi;
/**
* AcceleratorTypeMarshaller
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
@SdkInternalApi
public class AcceleratorTypeMarshaller {
private static final MarshallingInfo<String> ACCELERATORTYPENAME_BINDING = MarshallingInfo.builder(MarshallingType.STRING)
.marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("acceleratorTypeName").build();
private static final MarshallingInfo<StructuredPojo> MEMORYINFO_BINDING = MarshallingInfo.builder(MarshallingType.STRUCTURED)
.marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("memoryInfo").build();
private static final MarshallingInfo<List> THROUGHPUTINFO_BINDING = MarshallingInfo.builder(MarshallingType.LIST)
.marshallLocation(MarshallLocation.PAYLOAD).marshallLocationName("throughputInfo").build();
private static final AcceleratorTypeMarshaller instance = new AcceleratorTypeMarshaller();
public static AcceleratorTypeMarshaller getInstance() {
return instance;
}
/**
* Marshall the given parameter object.
*/
public void marshall(AcceleratorType acceleratorType, ProtocolMarshaller protocolMarshaller) {
if (acceleratorType == null) {
throw new SdkClientException("Invalid argument passed to marshall(...)");
}
try {
protocolMarshaller.marshall(acceleratorType.getAcceleratorTypeName(), ACCELERATORTYPENAME_BINDING);
protocolMarshaller.marshall(acceleratorType.getMemoryInfo(), MEMORYINFO_BINDING);
protocolMarshaller.marshall(acceleratorType.getThroughputInfo(), THROUGHPUTINFO_BINDING);
} catch (Exception e) {
throw new SdkClientException("Unable to marshall request to JSON: " + e.getMessage(), e);
}
}
}
|
aws/aws-sdk-java
|
aws-java-sdk-elasticinference/src/main/java/com/amazonaws/services/elasticinference/model/transform/AcceleratorTypeMarshaller.java
|
Java
|
apache-2.0
| 2,685
|
/*
Copyright (c) 2011, Siemens Corporate Research a Division of Siemens Corporation
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.
*/
// Disable the warning raised because of the std::map<>
#pragma warning ( disable : 4786 )
#include <xip/system/standard.h>
#include "geomutils.h"
#include <xip/inventor/core/SoXipActiveViewportElement.h>
#include <xip/inventor/core/SoXipCursor.h>
// Inventor actions
#include <Inventor/actions/SoGLRenderAction.h>
#include <Inventor/actions/SoHandleEventAction.h>
// Inventor events
#include <Inventor/events/SoMouseButtonEvent.h>
#include <Inventor/events/SoLocation2Event.h>
#include <Inventor/events/SoKeyboardEvent.h>
// Inventor nodes
#include <Inventor/nodes/SoCoordinate3.h>
#include <Inventor/nodes/SoMatrixTransform.h>
#include <Inventor/nodes/SoSwitch.h>
#include <Inventor/nodes/SoMaterial.h>
#include <Inventor/nodes/SoIndexedLineSet.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoTranslation.h>
#include <Inventor/nodes/SoDrawStyle.h>
// Inventor misc
#include <Inventor/SoPickedPoint.h>
#include <Inventor/projectors/SbPlaneProjector.h>
#include <Inventor/SbTime.h>
#include "SoXipOverlayFilterElement.h"
#include "SoXipOverlayColorElement.h"
#include "SoXipOverlayDrawStyleElement.h"
#include <xip/inventor/overlay/SoXipOverlayManipulatedElement.h>
#include "SoXipDropShadowElement.h"
#include <xip/inventor/overlay/SoXipManipulableShape.h>
SO_NODE_ABSTRACT_SOURCE( SoXipManipulableShape );
// Maximal distance between two consecutive mouse down positions
// allowed to generate a double-click.
int SoXipManipulableShape::mDoubleClickMaxJump = 2;
// Maximal time between two mouse clicks to be considered as a
// double-click.
SbTime SoXipManipulableShape::mDoubleClickTime = SbTime(0.5);
// Time corresponding to a click
SbTime SoXipManipulableShape::mClickTime = SbTime(0.1);
SoXipManipulableShape::SoXipManipulableShape()
{
SO_NODE_CONSTRUCTOR( SoXipManipulableShape );
// Color
SO_XIP_KIT_ADD_TYPE_ENTRY( mColor, SoMaterial, this );
SO_XIP_KIT_ADD_TYPE_ENTRY( mDrawStyle, SoDrawStyle, this );
// Enumeration
SO_XIP_KIT_ADD_ENTRY( mEnumerationSwitch, SoSwitch, this );
SO_XIP_KIT_ADD_ENTRY( mEnumerationSeparator, SoSeparator, mEnumerationSwitch );
SO_XIP_KIT_ADD_ENTRY( mEnumerationPickStyle, SoPickStyle, mEnumerationSeparator );
SO_XIP_KIT_ADD_ENTRY( mEnumerationOffset, SoTranslation, mEnumerationSeparator );
SO_XIP_KIT_ADD_TYPE_ENTRY( mEnumerationText, SoXipText2, mEnumerationSeparator );
// Text annotation
SO_XIP_KIT_ADD_ENTRY( mAnnotationSwitch, SoSwitch, this );
SO_XIP_KIT_ADD_ENTRY( mAnnotationSeparator, SoSeparator, mAnnotationSwitch );
SO_XIP_KIT_ADD_TYPE_ENTRY( mAnnotationTransform, SoMatrixTransform, mAnnotationSeparator );
SO_XIP_KIT_ADD_ENTRY( mAnnotationOffset, SoTranslation, mAnnotationSeparator );
SO_XIP_KIT_ADD_TYPE_ENTRY( mAnnotation, SoXipEditText2, mAnnotationSeparator );
// Shadows
SO_XIP_KIT_ADD_ENTRY( mShadowSwitch, SoSwitch, this );
SO_XIP_KIT_ADD_ENTRY( mShadowSeparator, SoSeparator, mShadowSwitch );
SO_XIP_KIT_ADD_ENTRY( mShadowMaterial, SoMaterial, mShadowSeparator );
SO_XIP_KIT_ADD_ENTRY( mShadowOffset, SoTranslation, mShadowSeparator );
// Top Separator
SO_XIP_KIT_ADD_ENTRY( mTopSeparator, SoSeparator, this );
SO_XIP_KIT_ADD_TYPE_ENTRY( mTransform, SoMatrixTransform, mTopSeparator );
// Geometries
SO_XIP_KIT_ADD_ENTRY( mLinesSeparator, SoSeparator, mTopSeparator );
SO_XIP_KIT_ADD_TYPE_ENTRY( mLinesCoords, SoCoordinate3, mLinesSeparator );
SO_XIP_KIT_ADD_TYPE_ENTRY( mLinesIndices, SoIndexedLineSet, mLinesSeparator );
// Also attach the geometries to the shadow separator
((SoSeparator *) mShadowSeparator)->addChild( mTopSeparator );
SO_NODE_ADD_FIELD( textAnchored, (TRUE) );
SO_NODE_ADD_FIELD( textPosition, (0, 0, 0) );
mEnumerationText->string.connectFrom( &rank );
mEnumerationPickStyle->set( "style UNPICKABLE" );
mAnnotation->string.connectFrom( &caption );
((SoTranslation *) mAnnotationOffset)->translation.connectFrom( &textPosition );
mLinesCoords->point.setNum(0);
mLinesIndices->coordIndex.setNum(0);
mShowAnnotation = status.getValue() == NONE;
mShowEnumeration = status.getValue() == NONE;
mIsButtonPressed = FALSE;
mIsViewInitialized = FALSE;
mIsTextPicked = FALSE;
mIsEnumPicked = FALSE;
mIsManipulated = FALSE;
mIsSpacePressed = FALSE;
mMouseDownTime = SbTime::zero();
mMouseDownPos = SbVec2s(-1, -1);
mHandleEventAction = 0;
invalidateGeometries();
}
SoXipManipulableShape::~SoXipManipulableShape()
{
}
void
SoXipManipulableShape::initClass()
{
SO_NODE_INIT_ABSTRACT_CLASS( SoXipManipulableShape, SoXipShape, "SoXipShape" );
SO_ENABLE( SoGLRenderAction, SoXipOverlayElement);
SO_ENABLE( SoHandleEventAction, SoXipOverlayElement);
SO_ENABLE( SoGLRenderAction, SoXipOverlayManipulatedElement);
SO_ENABLE( SoHandleEventAction, SoXipOverlayManipulatedElement);
}
SbBool
SoXipManipulableShape::isButtonPressed() const
{
return mIsButtonPressed;
}
SbBool
SoXipManipulableShape::isClosed() const
{
return FALSE;
}
SbBool
SoXipManipulableShape::readInstance( SoInput* in, unsigned short flags )
{
SbBool readOK = SoNode::readInstance( in , flags );
invalidateGeometries();
if( status.getValue() == NONE )
{
toggleEnumerationOnOff( TRUE );
toggleAnnotationOnOff( TRUE );
}
return readOK;
}
SbBool
SoXipManipulableShape::isTextPicked() const
{
return mIsTextPicked;
}
SbBool
SoXipManipulableShape::isTextAnchored() const
{
return textAnchored.getValue();
}
void
SoXipManipulableShape::GLRender( SoGLRenderAction* action )
{
SbBool isOn = SoXipOverlayFilterElement::isOn( action->getState(), label );
if( !isOn || !on.getValue() )
return ;
SoState* state = action->getState();
if( !state )
return ;
saveViewInformation( action );
if( mIsViewInitialized == FALSE )
{
if( SoXipActiveViewportElement::get(state) )
{
mIsViewInitialized = TRUE;
updateViewDependentGeometries();
}
}
if( mUpdateGeometries )
{
this->enableNotify( FALSE );
mUpdateGeometries = FALSE;
updateGeometries();
this->enableNotify( TRUE );
}
if( mShadowSwitch )
{
SoSwitch* shadowSwitch = (SoSwitch *) mShadowSwitch;
if( !mIsManipulated && SoXipDropShadowElement::isOn( state ) )
{
const SbVec2s& shadowPixelOffset = SoXipDropShadowElement::getPixelOffset( state );
SbVec3f p0, p1;
if( getPoint( action->getNodeAppliedTo(), SbVec2s( 0, 0 ), p0 ) &&
getPoint( action->getNodeAppliedTo(), shadowPixelOffset, p1 ) )
{
((SoTranslation *) mShadowOffset)->translation.setValue(
p1[0] - p0[0], p1[1] - p0[1], 0 );
((SoMaterial *) mShadowMaterial)->diffuseColor.setValue(
SoXipDropShadowElement::getColor( state ) );
((SoMaterial *) mShadowMaterial)->transparency.setValue(
SoXipDropShadowElement::getTransparency( state ) );
if( shadowSwitch->whichChild.getValue() != 0 )
shadowSwitch->whichChild.setValue (0);
}
}
else
{
if( shadowSwitch->whichChild.getValue() != -1 )
shadowSwitch->whichChild.setValue (-1);
}
}
// Set the color
{
SbColor shapeColor;
float shapeAlpha;
SoXipOverlayColorElement::get( action->getState(), label,
shapeColor, shapeAlpha );
mColor->enableNotify( FALSE );
mColor->diffuseColor.setValue( shapeColor );
mColor->transparency.setValue( shapeAlpha );
mColor->enableNotify( TRUE );
}
// Set the draw style
{
float pointSize, lineWidth;
unsigned short linePattern;
SoXipOverlayDrawStyleElement::get( action->getState(), label,
pointSize, lineWidth, linePattern );
mDrawStyle->enableNotify( FALSE );
mDrawStyle->pointSize.setValue( pointSize );
mDrawStyle->lineWidth.setValue( lineWidth );
mDrawStyle->linePattern.setValue( linePattern );
mDrawStyle->enableNotify( TRUE );
}
SbXipOverlaySettings settings = SoXipOverlayElement::get( action->getState() );
// Disable notification to avoid invalidating the cache and call GLRender again
mAnnotationSwitch->enableNotify( FALSE );
mEnumerationSwitch->enableNotify( FALSE );
// By default hide annotation and enumeration
((SoSwitch *) mAnnotationSwitch)->whichChild.setValue(-1);
((SoSwitch *) mEnumerationSwitch)->whichChild.setValue(-1);
// Show/hide annotation and enumeration
if( mShowAnnotation && settings.shouldDisplayAnnotation() )
((SoSwitch *) mAnnotationSwitch)->whichChild.setValue(0);
if( mShowEnumeration && settings.shouldDisplayEnumeration() && rank.getValue() != -1 )
((SoSwitch *) mEnumerationSwitch)->whichChild.setValue(0);
// Restore notification
mAnnotationSwitch->enableNotify( TRUE );
mEnumerationSwitch->enableNotify( TRUE );
GLboolean depthTest = glIsEnabled( GL_DEPTH_TEST );
if( depthTest )
glDisable( GL_DEPTH_TEST );
if( mLinesCoords->point.getNum() > 1 )
{
SoXipKit::GLRender( action );
}
if( depthTest )
glEnable( GL_DEPTH_TEST );
}
void
SoXipManipulableShape::handleEvent( SoHandleEventAction* action )
{
if( !on.getValue() )
return ;
SoXipShape::handleEvent( action );
if( action->isHandled() )
return ;
SbVec3f pos;
const SbVec2s& mousePosition = action->getEvent()->getPosition();
if( action->getGrabber() == this )
{
mHandleEventAction = action;
}
if( action->getEvent()->isOfType( SoKeyboardEvent::getClassTypeId() ) )
{
const SoKeyboardEvent* keyEvent = (const SoKeyboardEvent *) action->getEvent();
if( keyEvent->getKey() == SoKeyboardEvent::SPACE )
{
if( SO_KEY_PRESS_EVENT( action->getEvent(), ANY ) && !mIsSpacePressed )
{
getPoint( action, mSpacePosition );
mIsSpacePressed = TRUE;
}
else if( SO_KEY_RELEASE_EVENT( action->getEvent(), ANY ) )
{
mIsSpacePressed = FALSE;
}
}
}
else if( SO_MOUSE_RELEASE_EVENT( action->getEvent(), BUTTON1 ) && action->getGrabber() == this )
{
if( getPoint( action, pos ) )
{
mMouseUpTime = action->getEvent()->getTime();
mouseUp( pos );
}
if( status.getValue() == NONE )
{
select( TRUE );
updateGeometries();
action->releaseGrabber();
}
action->setHandled();
mIsButtonPressed = FALSE;
}
else if( action->getEvent()->isOfType( SoLocation2Event::getClassTypeId() ) && action->getGrabber() == this )
{
if( mousePosition != mMouseDownPos )
{
if( status.getValue() == CREATE && getPoint( action, pos ) )
{
if( mIsSpacePressed )
{
translate( pos - mSpacePosition );
mSpacePosition = pos;
}
else mouseMove( pos );
}
}
action->setHandled();
}
else if( SO_MOUSE_PRESS_EVENT( action->getEvent(), BUTTON1 ) )
{
if( isCreating() )
{
action->setHandled();
SbTime time = action->getEvent()->getTime();
// Compute the distance between the last mouse press event and this one
SbVec2s v = (mMouseDownPos - mousePosition);
float mouseJump = sqrtf( v.dot(v) );
// Do not perform a double-click if the time between two mouse press
// events is higher than the default time set for double-clicks, or if
// the mouse jumped further than the tolerance set (without tolerance
// it is more difficult to get a double-click.
if( (time - mMouseDownTime) < mDoubleClickTime && mouseJump < mDoubleClickMaxJump )
{
if( getPoint( action->getNodeAppliedTo(), mMouseDownPos, pos ) )
mouseDouble( pos );
mMouseDownTime = SbTime::zero();
mMouseDownPos = SbVec2s(-1, -1);
}
else
{
action->setGrabber( this );
if( getPoint( action, pos ) )
mouseDown( pos );
mIsButtonPressed = TRUE;
mMouseDownTime = time;
mMouseDownPos = mousePosition;
}
}
}
if( action->getGrabber() == this )
{
updateGeometries();
if( status.getValue() == NONE )
{
// We just finish to create the shape. Make it selected
select( TRUE );
}
}
}
const SbMatrix&
SoXipManipulableShape::getTransform() const
{
return mTransform->matrix.getValue();
}
void
SoXipManipulableShape::setViewTransform( const SbMatrix& viewMatrix )
{
// Hide the enumeration
toggleEnumerationOnOff( FALSE );
mIsManipulated = TRUE;
if( isTextPicked() )
{
mAnnotationTransform->matrix.setValue( viewMatrix );
// If the user starts dragging the text annotation, then
// the text is not anchored to the shape anymore.
textAnchored.setValue( FALSE );
}
else
{
mTransform->matrix.setValue( viewMatrix );
// If the text is anchored, then its position needs to be
// recomputed everytime the shape is changing. To avoid this,
// the text annotation is hidden until the transformation is
// applied.
if( isTextAnchored() )
toggleAnnotationOnOff( FALSE );
}
}
void
SoXipManipulableShape::applyViewTransform( const SbMatrix& viewMatrix )
{
if( !isTextPicked() )
{
transform( viewMatrix );
mTransform->matrix.setValue( SbMatrix::identity() );
updateGeometries();
// Show the text
if( isTextAnchored() )
toggleAnnotationOnOff( TRUE );
}
else
{
mAnnotationTransform->matrix.setValue( SbMatrix::identity() );
SbVec3f newTextOffset;
viewMatrix.multVecMatrix( textPosition.getValue(), newTextOffset );
textPosition.setValue( newTextOffset );
textAnchored.setValue( FALSE );
}
mIsManipulated = FALSE;
toggleEnumerationOnOff( TRUE );
}
void
SoXipManipulableShape::updateGeometries()
{
if( mLinesCoords && mLinesIndices )
{
SbBool dummyClosed;
extractGeometries( mLinesCoords->point, mLinesIndices->coordIndex, dummyClosed );
}
updateViewDependentGeometries();
}
void
SoXipManipulableShape::updateViewDependentGeometries()
{
if( isTextAnchored() )
updateAnnotationPosition( textPosition );
updateEnumerationPosition( ((SoTranslation *) mEnumerationOffset)->translation );
}
void
SoXipManipulableShape::updateEnumerationPosition( SoSFVec3f& position )
{
if( mIsViewInitialized )
{
mEnumerationText->justification.setValue( SoXipText2::LEFT );
mEnumerationText->vAlignment.setValue( SoXipText2::BOTTOM );
SbXfBox3f bbox;
computeXBoundingBox( bbox );
SbVec3f bboxMin, bboxMax, refPt;
bbox.getBounds( bboxMin, bboxMax );
bbox.getTransform().multVecMatrix( bboxMax, refPt );
int pointIndex = closestPoint( mLinesCoords->point, refPt );
if( pointIndex != -1 )
{
SbVec3f offset = projectScreenOffsetToWorld( SbVec2s( 5, 0 ) );
// By default (if method not overwritten), enumeration will be
// positionned in the top right corner, as close as possible from
// from the shape
position.setValue( mLinesCoords->point[ pointIndex ] + offset );
}
}
}
void
SoXipManipulableShape::updateAnnotationPosition( SoSFVec3f& position )
{
if( mIsViewInitialized )
{
mAnnotation->justification.setValue( SoXipText2::RIGHT );
mAnnotation->vAlignment.setValue( SoXipText2::TOP );
SbXfBox3f bbox;
computeXBoundingBox( bbox );
SbVec3f bboxMin, bboxMax, refPt;
bbox.getBounds( bboxMin, bboxMax );
bbox.getTransform().multVecMatrix( bboxMin, refPt );
int pointIndex = closestPoint( mLinesCoords->point, refPt );
if( pointIndex != -1 )
{
SbVec3f offset = projectScreenOffsetToWorld( SbVec2s( 5, 0 ) );
// By default (if method not overwritten), text will be
// positionned in the bottom left corner, as close as possible from
// from the shape
position.setValue( mLinesCoords->point[ pointIndex ] - offset );
}
}
}
void
SoXipManipulableShape::rayPick( SoRayPickAction* action )
{
if( !on.getValue() )
return ;
SoXipShape::pick( action );
if( action->isPickAll() )
{
mIsTextPicked = FALSE;
SoPickedPointList pickedPoints = action->getPickedPointList();
for( int i = 0; i < pickedPoints.getLength(); ++ i )
{
if( pickedPoints[i]->getPath()->containsNode( this ) )
{
mIsTextPicked = pickedPoints[i]->getPath()->containsNode( mAnnotation );
break ;
}
}
}
else
{
SoPickedPoint* pickedPoint = action->getPickedPoint();
if( pickedPoint )
mIsTextPicked = pickedPoint->getPath()->containsNode( mAnnotation );
}
}
void
SoXipManipulableShape::beforeCreation()
{
mLinesCoords->point.setNum(0);
mLinesIndices->coordIndex.setNum(0);
// Hide the annotation
toggleAnnotationOnOff( FALSE );
toggleEnumerationOnOff( FALSE );
}
void
SoXipManipulableShape::afterCreation()
{
// Show the annotation
toggleAnnotationOnOff( TRUE );
toggleEnumerationOnOff( TRUE );
}
void
SoXipManipulableShape::computeXBoundingBox( SbXfBox3f& bbox )
{
if( !mLinesCoords || mLinesCoords->point.getNum() <= 0 )
return ;
SbMatrix affine, proj;
mViewVolume.getMatrices( affine, proj );
bbox.makeEmpty();
bbox.setTransform( affine.inverse() );
const SoMFVec3f& point = mLinesCoords->point;
for( int i = 0; i < point.getNum(); ++ i )
{
bbox.extendBy( point[i] );
}
}
void
SoXipManipulableShape::editText()
{
mAnnotation->isEditing.setValue( TRUE );
mAnnotation->startNotify();
}
void
SoXipManipulableShape::editText( SoHandleEventAction* action )
{
mAnnotation->isEditing.setValue( TRUE );
mAnnotation->startNotify();
action->setGrabber( mAnnotation );
}
void
SoXipManipulableShape::toggleEnumerationOnOff( SbBool flag )
{
mShowEnumeration = flag;
}
void
SoXipManipulableShape::toggleAnnotationOnOff( SbBool flag )
{
mShowAnnotation = flag;
}
void
SoXipManipulableShape::invalidateGeometries()
{
mUpdateGeometries = TRUE;
startNotify();
}
void
SoXipManipulableShape::invalidateGeometriesCB( void* userData, SoSensor* )
{
((SoXipManipulableShape *) userData)->invalidateGeometries();
}
|
OpenXIP/xip-libraries
|
src/database/overlay/SoXipManipulableShape.cpp
|
C++
|
apache-2.0
| 17,885
|
// Copyright 2017 Google Inc.
//
// 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.
/**
* @fileoverview This option controls spacing before a inline comment.
* @author Joe Schafer
*/
goog.module('eslintClosure.rules.inlineCommentSpacing');
const utils = goog.require('eslintClosure.utils');
/** @const {number} */
const DEFAULT_PRECEDING_SPACES = 1;
/** @const {!ESLint.RuleDefinition} */
const INLINE_COMMENT_SPACING_RULE = {
meta: {
docs: {
description: 'enforce consistent spacing before the `//` at line end',
category: 'Stylistic Issues',
recommended: false,
},
fixable: 'whitespace',
schema: [
{
type: 'integer',
minimum: 0,
maximum: 5,
},
],
},
/**
* @param {!ESLint.RuleContext} context
* @return {!ESLint.VisitorMapping}
*/
create(context) {
// Check for null explicitily because 0 is a falsey value.
/** @const {number} */
const minPrecedingSpaces = context.options[0] == null ?
DEFAULT_PRECEDING_SPACES :
/** @type {number} */ (context.options[0]);
/**
* Reports a given comment if it's invalid..
* @param {!AST.LineComment} commentNode A comment node to check.
* @return {undefined}
*/
function checkLineCommentForPrecedingSpace(commentNode) {
const sourceCode = context.getSourceCode();
// Need to call getComments to attach comments to the AST.
sourceCode.getComments(commentNode);
// TODO: I'm not sure why I can't just call getTokenBefore. The tests
// fail if either of the two calls is missing.
const previousToken = sourceCode.getTokenBefore(commentNode, 1) ||
sourceCode.getTokenOrCommentBefore(commentNode);
// Return early if there's no tokens before commentNode or there's only
// whitespace.
if (previousToken == null ||
!utils.nodesShareOneLine(commentNode, previousToken)) {
return;
}
const whiteSpaceGap = commentNode.start - previousToken.end;
if (whiteSpaceGap < minPrecedingSpaces) {
const spacesNoun = minPrecedingSpaces === 1 ? 'space' : 'spaces';
context.report({
node: commentNode,
message: `Expected at least ${minPrecedingSpaces} ${spacesNoun} ` +
`before inline comment.`,
/**
* @param {!ESLint.Fixer} fixer
* @return {!ESLint.FixCommand}
*/
fix(fixer) {
const numNeededSpaces = minPrecedingSpaces - whiteSpaceGap;
const spaces = new Array(numNeededSpaces + 1).join(' ');
return fixer.insertTextBefore(commentNode, spaces);
},
});
}
}
return {
LineComment: checkLineCommentForPrecedingSpace,
};
},
};
exports = INLINE_COMMENT_SPACING_RULE;
|
google/eslint-closure
|
packages/eslint-plugin-closure/lib/rules/inline-comment-spacing.js
|
JavaScript
|
apache-2.0
| 3,337
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
package org.apache.camel.component.aws2.eventbridge;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.Collection;
import org.apache.camel.Endpoint;
import org.apache.camel.Exchange;
import org.apache.camel.InvalidPayloadException;
import org.apache.camel.Message;
import org.apache.camel.support.DefaultProducer;
import org.apache.camel.support.ResourceHelper;
import org.apache.camel.util.ObjectHelper;
import org.apache.camel.util.URISupport;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.services.eventbridge.EventBridgeClient;
import software.amazon.awssdk.services.eventbridge.model.PutRuleRequest;
import software.amazon.awssdk.services.eventbridge.model.PutRuleResponse;
import software.amazon.awssdk.services.eventbridge.model.PutTargetsRequest;
import software.amazon.awssdk.services.eventbridge.model.PutTargetsResponse;
import software.amazon.awssdk.services.eventbridge.model.RemoveTargetsRequest;
import software.amazon.awssdk.services.eventbridge.model.RemoveTargetsResponse;
import software.amazon.awssdk.services.eventbridge.model.Target;
/**
* A Producer which sends messages to the Amazon Eventbridge Service SDK v2
* <a href="http://aws.amazon.com/eventbridge/">AWS Eventbridge</a>
*/
public class EventbridgeProducer extends DefaultProducer {
private static final Logger LOG = LoggerFactory.getLogger(EventbridgeProducer.class);
private transient String eventbridgeProducerToString;
public EventbridgeProducer(Endpoint endpoint) {
super(endpoint);
}
@Override
public void process(Exchange exchange) throws Exception {
switch (determineOperation(exchange)) {
case putRule:
putRule(getEndpoint().getEventbridgeClient(), exchange);
break;
case putTargets:
putTargets(getEndpoint().getEventbridgeClient(), exchange);
break;
case removeTargets:
removeTargets(getEndpoint().getEventbridgeClient(), exchange);
break;
default:
throw new IllegalArgumentException("Unsupported operation");
}
}
private EventbridgeOperations determineOperation(Exchange exchange) {
EventbridgeOperations operation
= exchange.getIn().getHeader(EventbridgeConstants.OPERATION, EventbridgeOperations.class);
if (operation == null) {
operation = getConfiguration().getOperation();
}
return operation;
}
protected EventbridgeConfiguration getConfiguration() {
return getEndpoint().getConfiguration();
}
@Override
public String toString() {
if (eventbridgeProducerToString == null) {
eventbridgeProducerToString = "EventbridgeProducer[" + URISupport.sanitizeUri(getEndpoint().getEndpointUri()) + "]";
}
return eventbridgeProducerToString;
}
private void putRule(EventBridgeClient eventbridgeClient, Exchange exchange) throws InvalidPayloadException, IOException {
if (getConfiguration().isPojoRequest()) {
Object payload = exchange.getIn().getMandatoryBody();
if (payload instanceof PutRuleRequest) {
PutRuleResponse result;
try {
result = eventbridgeClient.putRule((PutRuleRequest) payload);
} catch (AwsServiceException ase) {
LOG.trace("PutRule command returned the error code {}", ase.awsErrorDetails().errorCode());
throw ase;
}
Message message = getMessageForResponse(exchange);
message.setBody(result);
}
} else {
PutRuleRequest.Builder builder = PutRuleRequest.builder();
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(EventbridgeConstants.RULE_NAME))) {
String ruleName = exchange.getIn().getHeader(EventbridgeConstants.RULE_NAME, String.class);
builder.name(ruleName);
}
if (ObjectHelper.isEmpty(exchange.getIn().getHeader(EventbridgeConstants.EVENT_PATTERN))) {
InputStream s = ResourceHelper.resolveMandatoryResourceAsInputStream(this.getEndpoint().getCamelContext(),
getConfiguration().getEventPatternFile());
String eventPattern = IOUtils.toString(s, Charset.defaultCharset());
builder.eventPattern(eventPattern);
} else {
String eventPattern = exchange.getIn().getHeader(EventbridgeConstants.EVENT_PATTERN, String.class);
builder.eventPattern(eventPattern);
}
builder.eventBusName(getConfiguration().getEventbusName());
PutRuleResponse result;
try {
result = eventbridgeClient.putRule(builder.build());
} catch (AwsServiceException ase) {
LOG.trace("Put Rule command returned the error code {}", ase.awsErrorDetails().errorCode());
throw ase;
}
Message message = getMessageForResponse(exchange);
message.setBody(result);
}
}
private void putTargets(EventBridgeClient eventbridgeClient, Exchange exchange) throws InvalidPayloadException {
if (getConfiguration().isPojoRequest()) {
Object payload = exchange.getIn().getMandatoryBody();
if (payload instanceof PutTargetsRequest) {
PutTargetsResponse result;
try {
result = eventbridgeClient.putTargets((PutTargetsRequest) payload);
} catch (AwsServiceException ase) {
LOG.trace("PutTargets command returned the error code {}", ase.awsErrorDetails().errorCode());
throw ase;
}
Message message = getMessageForResponse(exchange);
message.setBody(result);
}
} else {
PutTargetsRequest.Builder builder = PutTargetsRequest.builder();
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(EventbridgeConstants.RULE_NAME))) {
String ruleName = exchange.getIn().getHeader(EventbridgeConstants.RULE_NAME, String.class);
builder.rule(ruleName);
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(EventbridgeConstants.TARGETS))) {
Collection<Target> targets = exchange.getIn().getHeader(EventbridgeConstants.TARGETS, Collection.class);
builder.targets(targets);
} else {
throw new IllegalArgumentException("At least one targets must be specified");
}
builder.eventBusName(getConfiguration().getEventbusName());
PutTargetsResponse result;
try {
result = eventbridgeClient.putTargets(builder.build());
} catch (AwsServiceException ase) {
LOG.trace("Put Targets command returned the error code {}", ase.awsErrorDetails().errorCode());
throw ase;
}
Message message = getMessageForResponse(exchange);
message.setBody(result);
}
}
private void removeTargets(EventBridgeClient eventbridgeClient, Exchange exchange) throws InvalidPayloadException {
if (getConfiguration().isPojoRequest()) {
Object payload = exchange.getIn().getMandatoryBody();
if (payload instanceof RemoveTargetsRequest) {
RemoveTargetsResponse result;
try {
result = eventbridgeClient.removeTargets((RemoveTargetsRequest) payload);
} catch (AwsServiceException ase) {
LOG.trace("RemoveTargets command returned the error code {}", ase.awsErrorDetails().errorCode());
throw ase;
}
Message message = getMessageForResponse(exchange);
message.setBody(result);
}
} else {
RemoveTargetsRequest.Builder builder = RemoveTargetsRequest.builder();
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(EventbridgeConstants.RULE_NAME))) {
String ruleName = exchange.getIn().getHeader(EventbridgeConstants.RULE_NAME, String.class);
builder.rule(ruleName);
}
if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(EventbridgeConstants.TARGETS_IDS))) {
Collection<String> ids = exchange.getIn().getHeader(EventbridgeConstants.TARGETS_IDS, Collection.class);
builder.ids(ids);
} else {
throw new IllegalArgumentException("At least one targets must be specified");
}
builder.eventBusName(getConfiguration().getEventbusName());
RemoveTargetsResponse result;
try {
result = eventbridgeClient.removeTargets(builder.build());
} catch (AwsServiceException ase) {
LOG.trace("Remove Targets command returned the error code {}", ase.awsErrorDetails().errorCode());
throw ase;
}
Message message = getMessageForResponse(exchange);
message.setBody(result);
}
}
@Override
public EventbridgeEndpoint getEndpoint() {
return (EventbridgeEndpoint) super.getEndpoint();
}
public static Message getMessageForResponse(final Exchange exchange) {
return exchange.getMessage();
}
}
|
adessaigne/camel
|
components/camel-aws2-eventbridge/src/main/java/org/apache/camel/component/aws2/eventbridge/EventbridgeProducer.java
|
Java
|
apache-2.0
| 10,543
|
package com.example.innf.criminalintent;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Environment;
import com.example.innf.criminalintent.database.CrimeBaseHelper;
import com.example.innf.criminalintent.database.CrimeCursorWrapper;
import com.example.innf.criminalintent.database.CrimeDbSchema.CrimeTable;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* Author: Inno Fang
* Time: 2016/7/4 10:29
* Description:
*/
public class CrimeLab {
private static CrimeLab sCrimeLab;
// private List<Crime> mCrimes;
private Context mContext;
private SQLiteDatabase mDatabase;
private CrimeLab(Context context) {
mContext = context.getApplicationContext();
mDatabase = new CrimeBaseHelper(mContext).getWritableDatabase();
// mCrimes = new ArrayList<>();
}
public List<Crime> getCrimes(){
// return mCrimes;
List<Crime> crimes = new ArrayList<>();
CrimeCursorWrapper cursor = queryCrimes(null, null);
try{
cursor.moveToFirst();
while(!cursor.isAfterLast()){
crimes.add(cursor.getCrime());
cursor.moveToNext();
}
} finally {
cursor.close();
}
return crimes;
}
public Crime getCrime(UUID id) {
// for (Crime crime: mCrimes) {
// if (crime.getId().equals(id)){
// return crime;
// }
// }
CrimeCursorWrapper cursor = queryCrimes(CrimeTable.Cols.UUID + " = ?",
new String[] {id.toString()});
try{
if (cursor.getCount() == 0){
return null;
}
cursor.moveToFirst();
return cursor.getCrime();
} finally {
cursor.close();
}
}
public static CrimeLab get(Context context) {
if(null == sCrimeLab){
sCrimeLab = new CrimeLab(context);
}
return sCrimeLab;
}
public void updateCrime (Crime crime) {
String uuidString = crime.getId().toString();
ContentValues values = getContentValues(crime);
mDatabase.update(CrimeTable.NAME, values,
CrimeTable.Cols.UUID + " = ?",
new String[] {uuidString});
}
public void addCrime(Crime c){
// mCrimes.add(c);
ContentValues values = getContentValues(c);
mDatabase.insert(CrimeTable.NAME, null, values);
}
public void delCrime(Crime c){
// mCrimes.remove(c);
String uuidString = c.getId().toString();
mDatabase.delete(CrimeTable.NAME, CrimeTable.Cols.UUID + " = ?", new String[] {uuidString});
}
private static ContentValues getContentValues(Crime crime) {
ContentValues values = new ContentValues();
values.put(CrimeTable.Cols.UUID, crime.getId().toString());
values.put(CrimeTable.Cols.TITLE, crime.getTitle());
values.put(CrimeTable.Cols.DATE, crime.getDate().getTime());
values.put(CrimeTable.Cols.SOLVED, crime.isSolved() ? 1 : 0);
values.put(CrimeTable.Cols.SUSPECT, crime.getSuspect());
return values;
}
private CrimeCursorWrapper queryCrimes(String whereClause, String[] whereArgs) {
Cursor cursor = mDatabase.query(
CrimeTable.NAME,
null, // Columns - null selects all columns
whereClause,
whereArgs,
null, // groupBy
null, // having
null // orderBy
);
return new CrimeCursorWrapper(cursor);
}
public File getPhotoFile(Crime crime) {
File externalFilesDir = mContext.getExternalFilesDir(Environment.DIRECTORY_PICTURES);
if (externalFilesDir == null) {
return null;
}
return new File(externalFilesDir, crime.getPhotoFilename());
}
}
|
InnoFang/Android-Code-Demos
|
AndroidProgrammingDemo/CriminalIntent/app/src/main/java/com/example/innf/criminalintent/CrimeLab.java
|
Java
|
apache-2.0
| 4,061
|
Import-Module AU
Import-Module "$PSScriptRoot\..\..\scripts\au_extensions.psm1"
$domain = 'https://sourceforge.net'
$releases = "$domain/projects/pspp4windows/files/"
$softwareName = 'pspp*'
function global:au_BeforeUpdate { Get-RemoteFiles -Purge -NoSuffix -FileNameSkip 1 }
function global:au_AfterUpdate { Set-DescriptionFromReadme -SkipFirst 1 }
function global:au_SearchReplace {
@{
".\legal\VERIFICATION.txt" = @{
"(?i)(^\s*location on\:?\s*)\<.*\>" = "`${1}<$releases>"
"(?i)(\s*32\-Bit Software.*)\<.*\>" = "`${1}<$($Latest.URL32)>"
"(?i)(\s*64\-Bit Software.*)\<.*\>" = "`${1}<$($Latest.URL64)>"
"(?i)(^\s*checksum\s*type\:).*" = "`${1} $($Latest.ChecksumType32)"
"(?i)(^\s*checksum(32)?\:).*" = "`${1} $($Latest.Checksum32)"
"(?i)(^\s*checksum64\:).*" = "`${1} $($Latest.Checksum64)"
}
".\tools\chocolateyInstall.ps1" = @{
"(?i)^(\s*softwareName\s*=\s*)'.*'" = "`${1}'$softwareName'"
"(?i)(^\s*file\s*=\s*`"[$]toolsPath\\).*" = "`${1}$($Latest.FileName32)`""
"(?i)(^\s*file64\s*=\s*`"[$]toolsPath\\).*" = "`${1}$($Latest.FileName64)`""
}
".\tools\chocolateyUninstall.ps1" = @{
"(?i)^(\s*softwareName\s*=\s*)'.*'" = "`${1}'$softwareName'"
}
}
}
function global:au_GetLatest {
$download_page = Invoke-WebRequest -Uri $releases -UseBasicParsing
$re = '[\d]{4}\-([\d]{2}\-?){2}\/$'
$releasesUrl = $download_page.Links | ? href -match $re | select -first 1 -expand href | % { $domain + $_ }
$download_page = Invoke-WebRequest -Uri $releasesUrl -UseBasicParsing
$re = '32bits.*\.exe\/download$'
$url32 = $download_page.Links | ? href -match $re | select -first 1 -expand href
$re = '64bits.*\.exe\/download$'
$url64 = $download_page.links | ? href -match $re | select -first 1 -expand href
$verRe = "PSPPVersion\:\s*pspp-(\d+\.[\d\.]+)\-g"
$download_page.Content -match $verRe | Out-Null
$version = $Matches[1]
@{
URL32 = $url32
URL64 = $url64
Version = $version
FileType = 'exe'
}
}
update -ChecksumFor none
|
octomike/chocolatey-coreteampackages
|
automatic/pspp/update.ps1
|
PowerShell
|
apache-2.0
| 2,058
|
/*
* Copyright to the original author or authors.
*
* 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.
*/
package org.rioproject.test;
import java.lang.annotation.*;
/**
* <p>
* Defines the property to invoke to set the {@link TestManager}. The
* {@link TestManager} will be injected by the {@link RioTestRunner} prior to
* test case method invocation.
* </p>
*
* <p>
* Note: {@link SetTestManager @SetTestManager} can be applied at either the
* class or method level.
* </p>
*/
@Documented
@Retention (RetentionPolicy.RUNTIME)
@Target (value={ElementType.METHOD, ElementType.FIELD})
@Inherited
public @interface SetTestManager {
}
|
dreedyman/Rio
|
rio-test/src/main/java/org/rioproject/test/SetTestManager.java
|
Java
|
apache-2.0
| 1,160
|
__all__ = [
'fixed_value',
'coalesce',
]
try:
from itertools import ifilter as filter
except ImportError:
pass
class _FixedValue(object):
def __init__(self, value):
self._value = value
def __call__(self, *args, **kwargs):
return self._value
def fixed_value(value):
return _FixedValue(value)
class _Coalesce(object):
def _filter(self, x):
return x is not None
def __init__(self, callbacks, else_=None):
self._callbacks = callbacks
self._else = else_
def __call__(self, invoice):
results = (
callback(invoice)
for callback in self._callbacks
)
try:
return next(filter(
self._filter, results
))
except StopIteration:
return self._else
def coalesce(callbacks, else_=None):
return _Coalesce(callbacks, else_=else_)
|
calidae/python-aeat_sii
|
src/pyAEATsii/callback_utils.py
|
Python
|
apache-2.0
| 918
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_131) on Mon Nov 06 19:55:11 GMT 2017 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Assets</title>
<meta name="date" content="2017-11-06">
<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Assets";
}
}
catch(err) {
}
//-->
var methods = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":9,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Assets.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../index-files/index-1.html">Index</a></li>
<li><a href="../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev Class</li>
<li><a href="../../qmaze/View/TrainingConfig.html" title="class in qmaze.View"><span class="typeNameLink">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../index.html?qmaze/View/Assets.html" target="_top">Frames</a></li>
<li><a href="Assets.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary: </li>
<li>Nested | </li>
<li>Field | </li>
<li>Constr | </li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail: </li>
<li>Field | </li>
<li>Constr | </li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">qmaze.View</div>
<h2 title="Class Assets" class="title">Class Assets</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li>java.lang.Object</li>
<li>
<ul class="inheritance">
<li>qmaze.View.Assets</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <span class="typeNameLabel">Assets</span>
extends java.lang.Object</pre>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!-- -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd"> </span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></span><span class="tabEnd"> </span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd"> </span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd"> </span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>javafx.scene.paint.ImagePattern</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getAgentAtGoalImage--">getAgentAtGoalImage</a></span>()</code> </td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>javafx.scene.paint.ImagePattern</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getAgentDeathImage--">getAgentDeathImage</a></span>()</code> </td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>javafx.scene.paint.ImagePattern</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getAgentImage--">getAgentImage</a></span>()</code> </td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>javafx.collections.ObservableList<java.lang.String></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getAgentOptions--">getAgentOptions</a></span>()</code> </td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>javafx.scene.paint.ImagePattern</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getGoalImage--">getGoalImage</a></span>()</code> </td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getGoalRoomBackground--">getGoalRoomBackground</a></span>()</code> </td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>static <a href="../../qmaze/View/Assets.html" title="class in qmaze.View">Assets</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getInstance--">getInstance</a></span>()</code> </td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getLightGreenBackground--">getLightGreenBackground</a></span>()</code> </td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getRichGreenBackground--">getRichGreenBackground</a></span>()</code> </td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getUnvisitedRoomBackground--">getUnvisitedRoomBackground</a></span>()</code> </td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>java.lang.String</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#getWhiteBackground--">getWhiteBackground</a></span>()</code> </td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../qmaze/View/Assets.html#setTheme-java.lang.String-">setTheme</a></span>(java.lang.String theme)</code> </td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!-- -->
</a>
<h3>Methods inherited from class java.lang.Object</h3>
<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!-- -->
</a>
<h3>Method Detail</h3>
<a name="getInstance--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getInstance</h4>
<pre>public static <a href="../../qmaze/View/Assets.html" title="class in qmaze.View">Assets</a> getInstance()</pre>
</li>
</ul>
<a name="setTheme-java.lang.String-">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTheme</h4>
<pre>public void setTheme(java.lang.String theme)</pre>
</li>
</ul>
<a name="getAgentImage--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAgentImage</h4>
<pre>public javafx.scene.paint.ImagePattern getAgentImage()</pre>
</li>
</ul>
<a name="getAgentAtGoalImage--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAgentAtGoalImage</h4>
<pre>public javafx.scene.paint.ImagePattern getAgentAtGoalImage()</pre>
</li>
</ul>
<a name="getAgentDeathImage--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAgentDeathImage</h4>
<pre>public javafx.scene.paint.ImagePattern getAgentDeathImage()</pre>
</li>
</ul>
<a name="getGoalImage--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getGoalImage</h4>
<pre>public javafx.scene.paint.ImagePattern getGoalImage()</pre>
</li>
</ul>
<a name="getLightGreenBackground--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLightGreenBackground</h4>
<pre>public java.lang.String getLightGreenBackground()</pre>
</li>
</ul>
<a name="getUnvisitedRoomBackground--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getUnvisitedRoomBackground</h4>
<pre>public java.lang.String getUnvisitedRoomBackground()</pre>
</li>
</ul>
<a name="getGoalRoomBackground--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getGoalRoomBackground</h4>
<pre>public java.lang.String getGoalRoomBackground()</pre>
</li>
</ul>
<a name="getWhiteBackground--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getWhiteBackground</h4>
<pre>public java.lang.String getWhiteBackground()</pre>
</li>
</ul>
<a name="getRichGreenBackground--">
<!-- -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRichGreenBackground</h4>
<pre>public java.lang.String getRichGreenBackground()</pre>
</li>
</ul>
<a name="getAgentOptions--">
<!-- -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>getAgentOptions</h4>
<pre>public javafx.collections.ObservableList<java.lang.String> getAgentOptions()</pre>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Assets.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../index-files/index-1.html">Index</a></li>
<li><a href="../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev Class</li>
<li><a href="../../qmaze/View/TrainingConfig.html" title="class in qmaze.View"><span class="typeNameLink">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../index.html?qmaze/View/Assets.html" target="_top">Frames</a></li>
<li><a href="Assets.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary: </li>
<li>Nested | </li>
<li>Field | </li>
<li>Constr | </li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail: </li>
<li>Field | </li>
<li>Constr | </li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</body>
</html>
|
katharinebeaumont/QMaze
|
example/javadoc/qmaze/View/Assets.html
|
HTML
|
apache-2.0
| 13,103
|
package com.iticket.service.impl;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;
import com.iticket.constant.ModuleCon;
import com.iticket.model.api.ApiMethod;
import com.iticket.model.api.ClientMember;
import com.iticket.model.auth.Group;
import com.iticket.model.auth.Member2Group;
import com.iticket.service.AuthService;
import com.iticket.service.IException;
import com.iticket.util.BeanUtil;
import com.iticket.util.ValidateUtil;
@Service("authService")
public class AuthServiceImpl extends BaseServiceImpl implements AuthService, InitializingBean{
private Map<String, ApiMethod> methodMap = new HashMap<String, ApiMethod>();
@Override
public void addClientMember(ClientMember manager, String memberName,
String password, String groupIds) throws IException {
if(StringUtils.isBlank(memberName)){
throw new IException("用户名不能为空！");
}
if(!ValidateUtil.isMemberName(memberName)){
throw new IException( "用户名不符合规则(长度6-14位，由数字和字母组成)");
}
String hql = "from ClientMember where memberName=? and stadiumId=?";
List<ClientMember> list = baseDao.findByHql(hql, memberName, manager.getStadiumId());
if(list.isEmpty()){
if(StringUtils.isBlank(password)){
throw new IException("密码不能为空！");
}
if(!ValidateUtil.isPassword(password)){
throw new IException( "密码不符合规则(长度6-14位，由数字和字母组成)");
}
}
List<Long> groupIdList = BeanUtil.getIdList(groupIds, ",");
for(Long groupId : groupIdList){
Group group = baseDao.getObject(Group.class, groupId);
if(group==null){
throw new IException( groupId + "找不到记录！");
}
}
ClientMember member = null;
if(list.isEmpty()){
member = new ClientMember(manager.getStadiumId(), memberName, password);
}else {
member = list.get(0);
List<Member2Group> m2gList = baseDao.getObjectListByField(Member2Group.class, "memberId", member.getId());
baseDao.removeObjectList(m2gList);
}
if(StringUtils.isNotBlank(password)){
member.setPassword(password);
}
baseDao.saveObject(member);
for(Long groupId : groupIdList){
Member2Group m2g = new Member2Group(member, groupId);
baseDao.saveObject(m2g);
}
}
@Override
public Set<String> getMemberModule(ClientMember member){
Set<String> moduleList = new HashSet<String>();
if(member.hasManage()){
moduleList.addAll(ModuleCon.getAllModuleList());
}else {
List<Member2Group> m2gList = baseDao.getObjectListByField(Member2Group.class, "memberId", member.getId());
if(m2gList.size()>0){
List<Long> groupIdList = BeanUtil.getBeanPropertyList(m2gList, Long.class, "groupId", true);
List<Group> groupList = baseDao.getObjectList(Group.class, groupIdList);
for(Group group : groupList){
List<String> mdList = Arrays.asList(group.getModule().split(","));
moduleList.addAll(mdList);
}
}
}
return moduleList;
}
@Override
public Map<String, ApiMethod> getApiMethodMap() {
return methodMap;
}
@Override
public void initApiMethod() {
List<ApiMethod> mdList = baseDao.findByHql("from ApiMethod");
methodMap = new HashMap<String, ApiMethod>();
methodMap.putAll(BeanUtil.beanListToMap(mdList, "method"));
}
@Override
public void afterPropertiesSet() throws Exception {
initApiMethod();
}
}
|
liqilun/iticket
|
src/main/java/com/iticket/service/impl/AuthServiceImpl.java
|
Java
|
apache-2.0
| 3,669
|
#include "stack.h"
#include <iostream>
using namespace std;
struct StackElement {
char value;
StackElement *next;
};
struct Stack {
StackElement *head;
};
Stack *createStack()
{
Stack *newElement = new Stack;
newElement->head = nullptr;
return newElement;
}
void push(Stack *stack, char value)
{
StackElement* newElement = new StackElement;
newElement->value = value;
newElement->next = stack->head;
stack->head = newElement;
}
char pop(Stack *stack)
{
StackElement* newHead = stack->head->next;
char val = stack->head->value;
delete stack->head;
stack->head = newHead;
return val;
}
bool isEmpty(Stack *stack)
{
return !stack->head;
}
void deleteStack(Stack *stack)
{
while (!isEmpty(stack))
{
StackElement *temp = stack->head;
stack->head = stack->head->next;
delete temp;
}
delete stack;
}
|
Riteyl/SPbU-Homeworks
|
1 semester/6 homework/2 task/stack.cpp
|
C++
|
apache-2.0
| 826
|
# Pasania elephantum (Hance) Hickel & A.Camus SPECIES
#### Status
SYNONYM
#### According to
The Catalogue of Life, 3rd January 2011
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Magnoliopsida/Fagales/Fagaceae/Lithocarpus/Lithocarpus elephantum/ Syn. Pasania elephantum/README.md
|
Markdown
|
apache-2.0
| 200
|
package com.eworkplus.dal.core.build.io;
import java.io.InputStream;
import java.net.URL;
/**
* A class to wrap access to multiple class loaders making them work as one
*
* @author Clinton Begin
*/
public class ClassLoaderWrapper {
ClassLoader defaultClassLoader;
ClassLoader systemClassLoader;
ClassLoaderWrapper() {
try {
systemClassLoader = ClassLoader.getSystemClassLoader();
} catch (SecurityException ignored) {
// AccessControlException on Google App Engine
}
}
/*
* Get a resource as a URL using the current class path
*
* @param resource - the resource to locate
* @return the resource or null
*/
public URL getResourceAsURL(String resource) {
return getResourceAsURL(resource, getClassLoaders(null));
}
/*
* Get a resource from the classpath, starting with a specific class loader
*
* @param resource - the resource to find
* @param classLoader - the first classloader to try
* @return the stream or null
*/
public URL getResourceAsURL(String resource, ClassLoader classLoader) {
return getResourceAsURL(resource, getClassLoaders(classLoader));
}
/*
* Get a resource from the classpath
*
* @param resource - the resource to find
* @return the stream or null
*/
public InputStream getResourceAsStream(String resource) {
return getResourceAsStream(resource, getClassLoaders(null));
}
/*
* Get a resource from the classpath, starting with a specific class loader
*
* @param resource - the resource to find
* @param classLoader - the first class loader to try
* @return the stream or null
*/
public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
return getResourceAsStream(resource, getClassLoaders(classLoader));
}
/*
* Find a class on the classpath (or die trying)
*
* @param name - the class to look for
* @return - the class
* @throws ClassNotFoundException Duh.
*/
public Class<?> classForName(String name) throws ClassNotFoundException {
return classForName(name, getClassLoaders(null));
}
/*
* Find a class on the classpath, starting with a specific classloader (or die trying)
*
* @param name - the class to look for
* @param classLoader - the first classloader to try
* @return - the class
* @throws ClassNotFoundException Duh.
*/
public Class<?> classForName(String name, ClassLoader classLoader) throws ClassNotFoundException {
return classForName(name, getClassLoaders(classLoader));
}
/*
* Try to get a resource from a group of classloaders
*
* @param resource - the resource to get
* @param classLoader - the classloaders to examine
* @return the resource or null
*/
InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
for (ClassLoader cl : classLoader) {
if (null != cl) {
// try to find the resource as passed
InputStream returnValue = cl.getResourceAsStream(resource);
// now, some class loaders want this leading "/", so we'll add it and try again if we didn't find the resource
if (null == returnValue) {
returnValue = cl.getResourceAsStream("/" + resource);
}
if (null != returnValue) {
return returnValue;
}
}
}
return null;
}
/*
* Get a resource as a URL using the current class path
*
* @param resource - the resource to locate
* @param classLoader - the class loaders to examine
* @return the resource or null
*/
URL getResourceAsURL(String resource, ClassLoader[] classLoader) {
URL url;
for (ClassLoader cl : classLoader) {
if (null != cl) {
// look for the resource as passed in...
url = cl.getResource(resource);
// ...but some class loaders want this leading "/", so we'll add it
// and try again if we didn't find the resource
if (null == url) {
url = cl.getResource("/" + resource);
}
// "It's always in the last place I look for it!"
// ... because only an idiot would keep looking for it after finding it, so stop looking already.
if (null != url) {
return url;
}
}
}
// didn't find it anywhere.
return null;
}
/*
* Attempt to load a class from a group of classloaders
*
* @param name - the class to load
* @param classLoader - the group of classloaders to examine
* @return the class
* @throws ClassNotFoundException - Remember the wisdom of Judge Smails: Well, the world needs ditch diggers, too.
*/
Class<?> classForName(String name, ClassLoader[] classLoader) throws ClassNotFoundException {
for (ClassLoader cl : classLoader) {
if (null != cl) {
try {
Class<?> c = Class.forName(name, true, cl);
if (null != c) {
return c;
}
} catch (ClassNotFoundException e) {
// we'll ignore this until all classloaders fail to locate the class
}
}
}
throw new ClassNotFoundException("Cannot find class: " + name);
}
ClassLoader[] getClassLoaders(ClassLoader classLoader) {
return new ClassLoader[]{
classLoader,
defaultClassLoader,
Thread.currentThread().getContextClassLoader(),
getClass().getClassLoader(),
systemClassLoader};
}
}
|
wuditp520/Commons-Jdbc
|
smart-dal-core/src/main/java/com/eworkplus/dal/core/build/io/ClassLoaderWrapper.java
|
Java
|
apache-2.0
| 6,037
|
<?php
/**
* Copyright 2015 Arrogance
*
* 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.
*
*/
namespace FunXMPP\Core;
use FunXMPP\Core\Config\ConfigMethods;
use FunXMPP\Core\Exception\CustomException;
use FunXMPP\Util\Helpers;
class Config extends ConfigMethods
{
/**
* Read and save into static variables the settings stored in serverinfo.json
* file. But first call checkConfigFile() method to verify if files are ok.
*/
public static function generateConfig()
{
Config::checkConfigFile();
$config = file_get_contents(Helpers::fileBuildPath(__DIR__, '..', 'Resources', 'serverinfo.json'));
$configArray = json_decode($config, true);
foreach($configArray as $key => $value) {
static::$key($value);
}
}
/**
* Save this class static variables into the serverinfo.json file.
*/
public static function updateConfig()
{
$class = new \ReflectionClass('FunXMPP\\Core\\Config');
$staticProperties = $class->getStaticProperties();
if (!$configFile = @fopen(Helpers::fileBuildPath(__DIR__, '..', 'Resources', 'serverinfo.json'), 'w')) {
throw new CustomException('Unable to open serverinfo.json file.');
}
$data = json_encode($staticProperties, JSON_PRETTY_PRINT);
$text = $data;
fwrite($configFile, $text);
fclose($configFile);
}
/**
* Check of the serverinfo.json file exists. If not, then copy all settings
* from the serverinfo.json.dist
*/
public static function checkConfigFile()
{
if (@file_exists((Helpers::fileBuildPath(__DIR__, '..', 'Resources', 'serverinfo.json')))) {
return;
}
else if (!@file_exists((Helpers::fileBuildPath(__DIR__, '..', 'Resources', 'serverinfo.json.dist')))) {
throw new CustomException('Unable to open serverinfo.json.dist file.');
}
$config = file_get_contents(Helpers::fileBuildPath(__DIR__, '..', 'Resources', 'serverinfo.json.dist'));
file_put_contents(Helpers::fileBuildPath(__DIR__, '..', 'Resources', 'serverinfo.json'), $config);
}
}
|
Arrogance/FunXMPP-API
|
src/Core/Config.php
|
PHP
|
apache-2.0
| 2,677
|
<?php
class Awd_Model extends CI_Model{
//this model made by @Ahmed Awd
public function AddToDBKey($Tname,$data)
{
$this->db->insert($Tname,$data);
$insert_id = $this->db->insert_id();
return $insert_id;
}
public function AddToDB($Tname,$data)
{
$this->db->insert($Tname,$data);
}
public function CheckDub($Tname,$var,$col)
{
$this->db->where($col,$var);
$query=$this->db->get($Tname);
if($query->num_rows()==0){return false;}
else{return true;}
}
//return data arranged
public function ReturnDataArranged($Tname,$ArBy,$ArMod)
{
$this->db->select('*');
$this->db->from($Tname);
$this->db->order_by($ArBy,$ArMod);
$query=$this->db->get();
$res=$query->result();
return $res;
}
//get all data from table
public function GetData($Tname)
{
$query=$this->db->get($Tname);
$res=$query->result();
return $res;
}
public function GetOneRow($Tname)
{
$query=$this->db->get($Tname);
$res=$query->result();
return $res[0];
}
//get one row from table
public function ChData($Tname,$var,$col)
{
$this->db->where($col,$var);
$query=$this->db->get($Tname);
if($query->num_rows()==0){return false;}
$res=$query->result();
return $res[0];
}
//get one value from table
public function GetOneValue($Tname,$var,$col,$attr)
{
$this->db->where($col,$var);
$result=$this->db->get($Tname);
if($result->num_rows()==0)
{return false;}
else{
$x=$result->row(0)->$attr;
return $x;}
}
//get one coulmn from table where ....
public function GetCoulmnWhere($Tname,$col,$Bcol,$Val)
{
$this->db->select($col);
$this->db->where($Bcol,$Val);
$query=$this->db->get($Tname);
$res=$query->result();
for ($i=0; $i <sizeof($res) ; $i++) {
$Fres[$i]=$res[$i]->$col;
}
return $Fres;
}
//get all data from table where ....
public function DataWhere($Tname,$cond,$var,$ArBy,$ArMod)
{
$this->db->where($cond,$var);
$this->db->order_by($ArBy,$ArMod);
$query=$this->db->get($Tname);
$res=$query->result();
return $res;
}
public function OneDataWhere($Tname,$cond,$var,$ArBy,$ArMod)
{
$this->db->where($cond,$var);
$this->db->order_by($ArBy,$ArMod);
$query=$this->db->get($Tname);
$res=$query->result();
return $res[0];
}
public function Login($username, $password)
{
$this->db->where('username',$username);
$this->db->where('password',$password);
$result=$this->db->get('admins');
if($result->num_rows()==1){
$Res = $result->row(0);
return $Res;
}
else{
return False;
}
}
public function DelData($Tname,$var,$col)
{
$this->db->where($col,$var);
$this->db->delete($Tname);
}
public function update($Tname,$data,$var,$col)
{
$this->db->where($col,$var);
$this->db->update($Tname,$data);
}
public function PrinterTagsData()
{
$query = $this->db->query("SELECT * FROM tags");
$res = $query->result();
return $res;
}
public function PartsTagsData()
{
$query = $this->db->query("SELECT * FROM tags");
$res = $query->result();
return $res;
}
public function CheckOldPW($username, $password)
{
$this->db->where('username',$username);
$this->db->where('password',$password);
$result=$this->db->get('admins');
if($result->num_rows()==1){
$Res = $result->row(0);
return true;
}
else{
return False;
}
}
public function Counter($table,$col,$val)
{
$query = $this->db->query("SELECT COUNT($col) AS count FROM $table WHERE $col = '$val' ");
$res = $query->result();
return $res[0];
}
}
//this model made by @Ahmed Awd #TheImaginaryKing
?>
|
hackerghost93/ProTech
|
application/models_old/Awd_Model.php
|
PHP
|
apache-2.0
| 4,195
|
// =================================================================================================
// ADOBE SYSTEMS INCORPORATED
// Copyright 2006 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms
// of the Adobe license agreement accompanying it.
// =================================================================================================
#include "XMP_Environment.h" // ! This must be the first include.
#include "XMP_Const.h"
#include "XMP_IO.hpp"
#include "XMPFiles_Impl.hpp"
#include "XIO.hpp"
#include "TIFF_Handler.hpp"
#include "TIFF_Support.hpp"
#include "PSIR_Support.hpp"
#include "IPTC_Support.hpp"
#include "ReconcileLegacy.hpp"
#include "Reconcile_Impl.hpp"
#include "MD5.h"
using namespace std;
// =================================================================================================
/// \file TIFF_Handler.cpp
/// \brief File format handler for TIFF.
///
/// This handler ...
///
// =================================================================================================
// =================================================================================================
// TIFF_CheckFormat
// ================
// For TIFF we just check for the II/42 or MM/42 in the first 4 bytes and that there are at least
// 26 bytes of data (4+4+2+12+4).
//
// ! The CheckXyzFormat routines don't track the filePos, that is left to ScanXyzFile.
bool TIFF_CheckFormat ( XMP_FileFormat format,
XMP_StringPtr filePath,
XMP_IO* fileRef,
XMPFiles * parent )
{
IgnoreParam(format); IgnoreParam(filePath); IgnoreParam(parent);
XMP_Assert ( format == kXMP_TIFFFile );
enum { kMinimalTIFFSize = 4+4+2+12+4 }; // Header plus IFD with 1 entry.
fileRef->Rewind ( );
if ( ! XIO::CheckFileSpace ( fileRef, kMinimalTIFFSize ) ) return false;
XMP_Uns8 buffer [4];
fileRef->Read ( buffer, 4 );
bool leTIFF = CheckBytes ( buffer, "\x49\x49\x2A\x00", 4 );
bool beTIFF = CheckBytes ( buffer, "\x4D\x4D\x00\x2A", 4 );
return (leTIFF | beTIFF);
} // TIFF_CheckFormat
// =================================================================================================
// TIFF_MetaHandlerCTor
// ====================
XMPFileHandler * TIFF_MetaHandlerCTor ( XMPFiles * parent )
{
return new TIFF_MetaHandler ( parent );
} // TIFF_MetaHandlerCTor
// =================================================================================================
// TIFF_MetaHandler::TIFF_MetaHandler
// ==================================
TIFF_MetaHandler::TIFF_MetaHandler ( XMPFiles * _parent ) : psirMgr(0), iptcMgr(0)
{
this->parent = _parent;
this->handlerFlags = kTIFF_HandlerFlags;
this->stdCharForm = kXMP_Char8Bit;
} // TIFF_MetaHandler::TIFF_MetaHandler
// =================================================================================================
// TIFF_MetaHandler::~TIFF_MetaHandler
// ===================================
TIFF_MetaHandler::~TIFF_MetaHandler()
{
if ( this->psirMgr != 0 ) delete ( this->psirMgr );
if ( this->iptcMgr != 0 ) delete ( this->iptcMgr );
} // TIFF_MetaHandler::~TIFF_MetaHandler
// =================================================================================================
// TIFF_MetaHandler::CacheFileData
// ===============================
//
// The data caching for TIFF is easy to explain and implement, but does more processing than one
// might at first expect. This seems unavoidable given the need to close the disk file after calling
// CacheFileData. We parse the TIFF stream and cache the values for all tags of interest, and note
// whether XMP is present. We do not parse the XMP, Photoshop image resources, or IPTC datasets.
// *** This implementation simply returns when invalid TIFF is encountered. Should we throw instead?
void TIFF_MetaHandler::CacheFileData()
{
XMP_IO* fileRef = this->parent->ioRef;
XMP_PacketInfo & packetInfo = this->packetInfo;
XMP_AbortProc abortProc = this->parent->abortProc;
void * abortArg = this->parent->abortArg;
const bool checkAbort = (abortProc != 0);
XMP_Assert ( ! this->containsXMP );
// Set containsXMP to true here only if the XMP tag is found.
if ( checkAbort && abortProc(abortArg) ) {
XMP_Throw ( "TIFF_MetaHandler::CacheFileData - User abort", kXMPErr_UserAbort );
}
this->tiffMgr.ParseFileStream ( fileRef );
TIFF_Manager::TagInfo dngInfo;
if ( this->tiffMgr.GetTag ( kTIFF_PrimaryIFD, kTIFF_DNGVersion, &dngInfo ) ) {
// Reject DNG files that are version 2.0 or beyond, this is being written at the time of
// DNG version 1.2. The DNG team says it is OK to use 2.0, not strictly 1.2. Use the
// DNGBackwardVersion if it is present, else the DNGVersion. Note that the version value is
// supposed to be type BYTE, so the file order is always essentially big endian.
XMP_Uns8 majorVersion = *((XMP_Uns8*)dngInfo.dataPtr); // Start with DNGVersion.
if ( this->tiffMgr.GetTag ( kTIFF_PrimaryIFD, kTIFF_DNGBackwardVersion, &dngInfo ) ) {
majorVersion = *((XMP_Uns8*)dngInfo.dataPtr); // Use DNGBackwardVersion if possible.
}
if ( majorVersion > 1 ) XMP_Throw ( "DNG version beyond 1.x", kXMPErr_BadTIFF );
}
TIFF_Manager::TagInfo xmpInfo;
bool found = this->tiffMgr.GetTag ( kTIFF_PrimaryIFD, kTIFF_XMP, &xmpInfo );
if ( found ) {
this->packetInfo.offset = this->tiffMgr.GetValueOffset ( kTIFF_PrimaryIFD, kTIFF_XMP );
this->packetInfo.length = xmpInfo.dataLen;
this->packetInfo.padSize = 0; // Assume for now, set these properly in ProcessXMP.
this->packetInfo.charForm = kXMP_CharUnknown;
this->packetInfo.writeable = true;
this->xmpPacket.assign ( (XMP_StringPtr)xmpInfo.dataPtr, xmpInfo.dataLen );
this->containsXMP = true;
}
} // TIFF_MetaHandler::CacheFileData
// =================================================================================================
// TIFF_MetaHandler::ProcessXMP
// ============================
//
// Process the raw XMP and legacy metadata that was previously cached. The legacy metadata in TIFF
// is messy because there are 2 copies of the IPTC and because of a Photoshop 6 bug/quirk in the way
// Exif metadata is saved.
void TIFF_MetaHandler::ProcessXMP()
{
this->processedXMP = true; // Make sure we only come through here once.
// Set up everything for the legacy import, but don't do it yet. This lets us do a forced legacy
// import if the XMP packet gets parsing errors.
// ! Photoshop 6 wrote annoyingly wacky TIFF files. It buried a lot of the Exif metadata inside
// ! image resource 1058, itself inside of tag 34377 in the 0th IFD. Take care of this before
// ! doing any of the legacy metadata presence or priority analysis. Delete image resource 1058
// ! to get rid of the buried Exif, but don't mark the XMPFiles object as changed. This change
// ! should not trigger an update, but should be included as part of a normal update.
bool found;
bool readOnly = ((this->parent->openFlags & kXMPFiles_OpenForUpdate) == 0);
if ( readOnly ) {
this->psirMgr = new PSIR_MemoryReader();
this->iptcMgr = new IPTC_Reader();
} else {
this->psirMgr = new PSIR_FileWriter();
this->iptcMgr = new IPTC_Writer(); // ! Parse it later.
}
TIFF_Manager & tiff = this->tiffMgr; // Give the compiler help in recognizing non-aliases.
PSIR_Manager & psir = *this->psirMgr;
IPTC_Manager & iptc = *this->iptcMgr;
TIFF_Manager::TagInfo psirInfo;
bool havePSIR = tiff.GetTag ( kTIFF_PrimaryIFD, kTIFF_PSIR, &psirInfo );
if ( havePSIR ) { // ! Do the Photoshop 6 integration before other legacy analysis.
psir.ParseMemoryResources ( psirInfo.dataPtr, psirInfo.dataLen );
PSIR_Manager::ImgRsrcInfo buriedExif;
found = psir.GetImgRsrc ( kPSIR_Exif, &buriedExif );
if ( found ) {
tiff.IntegrateFromPShop6 ( buriedExif.dataPtr, buriedExif.dataLen );
if ( ! readOnly ) psir.DeleteImgRsrc ( kPSIR_Exif );
}
}
TIFF_Manager::TagInfo iptcInfo;
bool haveIPTC = tiff.GetTag ( kTIFF_PrimaryIFD, kTIFF_IPTC, &iptcInfo ); // The TIFF IPTC tag.
int iptcDigestState = kDigestMatches;
if ( haveIPTC ) {
bool haveDigest = false;
PSIR_Manager::ImgRsrcInfo digestInfo;
if ( havePSIR ) haveDigest = psir.GetImgRsrc ( kPSIR_IPTCDigest, &digestInfo );
if ( digestInfo.dataLen != 16 ) haveDigest = false;
if ( ! haveDigest ) {
iptcDigestState = kDigestMissing;
} else {
// Older versions of Photoshop wrote tag 33723 with type LONG, but ignored the trailing
// zero padding for the IPTC digest. If the full digest differs, recheck without the padding.
iptcDigestState = PhotoDataUtils::CheckIPTCDigest ( iptcInfo.dataPtr, iptcInfo.dataLen, digestInfo.dataPtr );
if ( (iptcDigestState == kDigestDiffers) && (kTIFF_TypeSizes[iptcInfo.type] > 1) ) {
XMP_Uns8 * endPtr = (XMP_Uns8*)iptcInfo.dataPtr + iptcInfo.dataLen - 1;
XMP_Uns8 * minPtr = endPtr - kTIFF_TypeSizes[iptcInfo.type] + 1;
while ( (endPtr >= minPtr) && (*endPtr == 0) ) --endPtr;
XMP_Uns32 unpaddedLen = (XMP_Uns32) (endPtr - (XMP_Uns8*)iptcInfo.dataPtr + 1);
iptcDigestState = PhotoDataUtils::CheckIPTCDigest ( iptcInfo.dataPtr, unpaddedLen, digestInfo.dataPtr );
}
}
}
XMP_OptionBits options = k2XMP_FileHadExif; // TIFF files are presumed to have Exif legacy.
if ( haveIPTC ) options |= k2XMP_FileHadIPTC;
if ( this->containsXMP ) options |= k2XMP_FileHadXMP;
// Process the XMP packet. If it fails to parse, do a forced legacy import but still throw an
// exception. This tells the caller that an error happened, but gives them recovered legacy
// should they want to proceed with that.
bool haveXMP = false;
if ( ! this->xmpPacket.empty() ) {
XMP_Assert ( this->containsXMP );
// Common code takes care of packetInfo.charForm, .padSize, and .writeable.
XMP_StringPtr packetStr = this->xmpPacket.c_str();
XMP_StringLen packetLen = (XMP_StringLen)this->xmpPacket.size();
try {
this->xmpObj.ParseFromBuffer ( packetStr, packetLen );
} catch ( ... ) { /* Ignore parsing failures, someday we hope to get partial XMP back. */ }
haveXMP = true;
}
// Process the legacy metadata.
if ( haveIPTC && (! haveXMP) && (iptcDigestState == kDigestMatches) ) iptcDigestState = kDigestMissing;
bool parseIPTC = (iptcDigestState != kDigestMatches) || (! readOnly);
if ( parseIPTC ) iptc.ParseMemoryDataSets ( iptcInfo.dataPtr, iptcInfo.dataLen );
ImportPhotoData ( tiff, iptc, psir, iptcDigestState, &this->xmpObj, options );
this->containsXMP = true; // Assume we now have something in the XMP.
} // TIFF_MetaHandler::ProcessXMP
// =================================================================================================
// TIFF_MetaHandler::UpdateFile
// ============================
//
// There is very little to do directly in UpdateFile. ExportXMPtoJTP takes care of setting all of
// the necessary TIFF tags, including things like the 2nd copy of the IPTC in the Photoshop image
// resources in tag 34377. TIFF_FileWriter::UpdateFileStream does all of the update-by-append I/O.
// *** Need to pass the abort proc and arg to TIFF_FileWriter::UpdateFileStream.
void TIFF_MetaHandler::UpdateFile ( bool doSafeUpdate )
{
XMP_Assert ( ! doSafeUpdate ); // This should only be called for "unsafe" updates.
XMP_IO* destRef = this->parent->ioRef;
XMP_AbortProc abortProc = this->parent->abortProc;
void * abortArg = this->parent->abortArg;
XMP_Int64 oldPacketOffset = this->packetInfo.offset;
XMP_Int32 oldPacketLength = this->packetInfo.length;
if ( oldPacketOffset == kXMPFiles_UnknownOffset ) oldPacketOffset = 0; // ! Simplify checks.
if ( oldPacketLength == kXMPFiles_UnknownLength ) oldPacketLength = 0;
bool fileHadXMP = ((oldPacketOffset != 0) && (oldPacketLength != 0));
// Update the IPTC-IIM and native TIFF/Exif metadata. ExportPhotoData also trips the tiff: and
// exif: copies from the XMP, so reserialize the now final XMP packet.
ExportPhotoData ( kXMP_TIFFFile, &this->xmpObj, &this->tiffMgr, this->iptcMgr, this->psirMgr );
try {
XMP_OptionBits options = kXMP_UseCompactFormat;
if ( fileHadXMP ) options |= kXMP_ExactPacketLength;
this->xmpObj.SerializeToBuffer ( &this->xmpPacket, options, oldPacketLength );
} catch ( ... ) {
this->xmpObj.SerializeToBuffer ( &this->xmpPacket, kXMP_UseCompactFormat );
}
// Decide whether to do an in-place update. This can only happen if all of the following are true:
// - There is an XMP packet in the file.
// - The are no changes to the legacy tags. (The IPTC and PSIR are in the TIFF tags.)
// - The new XMP can fit in the old space.
bool doInPlace = (fileHadXMP && (this->xmpPacket.size() <= (size_t)oldPacketLength));
if ( this->tiffMgr.IsLegacyChanged() ) doInPlace = false;
bool localProgressTracking = false;
XMP_ProgressTracker* progressTracker = this->parent->progressTracker;
if ( ! doInPlace ) {
#if GatherPerformanceData
sAPIPerf->back().extraInfo += ", TIFF append update";
#endif
if ( (progressTracker != 0) && (! progressTracker->WorkInProgress()) ) {
localProgressTracking = true;
progressTracker->BeginWork();
}
this->tiffMgr.SetTag ( kTIFF_PrimaryIFD, kTIFF_XMP, kTIFF_UndefinedType, (XMP_Uns32)this->xmpPacket.size(), this->xmpPacket.c_str() );
this->tiffMgr.UpdateFileStream ( destRef, progressTracker );
} else {
#if GatherPerformanceData
sAPIPerf->back().extraInfo += ", TIFF in-place update";
#endif
if ( this->xmpPacket.size() < (size_t)this->packetInfo.length ) {
// They ought to match, cheap to be sure.
size_t extraSpace = (size_t)this->packetInfo.length - this->xmpPacket.size();
this->xmpPacket.append ( extraSpace, ' ' );
}
XMP_IO* liveFile = this->parent->ioRef;
XMP_Assert ( this->xmpPacket.size() == (size_t)oldPacketLength ); // ! Done by common PutXMP logic.
if ( progressTracker != 0 ) {
if ( progressTracker->WorkInProgress() ) {
progressTracker->AddTotalWork ( this->xmpPacket.size() );
} else {
localProgressTracking = true;
progressTracker->BeginWork ( this->xmpPacket.size() );
}
}
liveFile->Seek ( oldPacketOffset, kXMP_SeekFromStart );
liveFile->Write ( this->xmpPacket.c_str(), (XMP_Int32)this->xmpPacket.size() );
}
if ( localProgressTracking ) progressTracker->WorkComplete();
this->needsUpdate = false;
} // TIFF_MetaHandler::UpdateFile
// =================================================================================================
// TIFF_MetaHandler::WriteTempFile
// ===============================
//
// The structure of TIFF makes it hard to do a sequential source-to-dest copy with interleaved
// updates. So, copy the existing source to the destination and call UpdateFile.
void TIFF_MetaHandler::WriteTempFile ( XMP_IO* tempRef )
{
XMP_IO* origRef = this->parent->ioRef;
XMP_AbortProc abortProc = this->parent->abortProc;
void * abortArg = this->parent->abortArg;
XMP_Int64 fileLen = origRef->Length();
if ( fileLen > 0xFFFFFFFFLL ) { // Check before making a copy of the file.
XMP_Throw ( "TIFF fles can't exceed 4GB", kXMPErr_BadTIFF );
}
XMP_ProgressTracker* progressTracker = this->parent->progressTracker;
if ( progressTracker != 0 ) progressTracker->BeginWork ( (float)fileLen );
origRef->Rewind ( );
tempRef->Truncate ( 0 );
XIO::Copy ( origRef, tempRef, fileLen, abortProc, abortArg );
try {
this->parent->ioRef = tempRef; // ! Make UpdateFile update the temp.
this->UpdateFile ( false );
this->parent->ioRef = origRef;
} catch ( ... ) {
this->parent->ioRef = origRef;
throw;
}
if ( progressTracker != 0 ) progressTracker->WorkComplete();
} // TIFF_MetaHandler::WriteTempFile
// =================================================================================================
|
vb0067/XMPToolkitSDK
|
XMPFilesStatic/source/FileHandlers/TIFF_Handler.cpp
|
C++
|
apache-2.0
| 15,862
|
/*
* Licensed to ElasticSearch and Shay Banon under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. ElasticSearch licenses this
* file to you 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.
*/
package org.elasticsearch.search.facet.query;
import org.apache.lucene.index.AtomicReaderContext;
import org.apache.lucene.search.*;
import org.apache.lucene.util.Bits;
import org.elasticsearch.common.lucene.docset.DocIdSets;
import org.elasticsearch.common.lucene.search.Queries;
import org.elasticsearch.common.lucene.search.XConstantScoreQuery;
import org.elasticsearch.common.lucene.search.XFilteredQuery;
import org.elasticsearch.index.cache.filter.FilterCache;
import org.elasticsearch.search.facet.AbstractFacetCollector;
import org.elasticsearch.search.facet.Facet;
import org.elasticsearch.search.facet.OptimizeGlobalFacetCollector;
import org.elasticsearch.search.internal.SearchContext;
import java.io.IOException;
/**
*
*/
public class QueryFacetCollector extends AbstractFacetCollector implements OptimizeGlobalFacetCollector {
private final Query query;
private final Filter filter;
private Bits bits;
private int count = 0;
public QueryFacetCollector(String facetName, Query query, FilterCache filterCache) {
super(facetName);
this.query = query;
Filter possibleFilter = extractFilterIfApplicable(query);
if (possibleFilter != null) {
this.filter = possibleFilter;
} else {
this.filter = new QueryWrapperFilter(query);
}
}
@Override
protected void doSetNextReader(AtomicReaderContext context) throws IOException {
bits = DocIdSets.toSafeBits(context.reader(), filter.getDocIdSet(context, context.reader().getLiveDocs()));
}
@Override
protected void doCollect(int doc) throws IOException {
if (bits.get(doc)) {
count++;
}
}
@Override
public void optimizedGlobalExecution(SearchContext searchContext) throws IOException {
Query query = this.query;
if (super.filter != null) {
query = new XFilteredQuery(query, super.filter);
}
Filter searchFilter = searchContext.mapperService().searchFilter(searchContext.types());
if (searchFilter != null) {
query = new XFilteredQuery(query, searchContext.filterCache().cache(searchFilter));
}
TotalHitCountCollector collector = new TotalHitCountCollector();
searchContext.searcher().search(query, collector);
count = collector.getTotalHits();
}
@Override
public Facet facet() {
return new InternalQueryFacet(facetName, count);
}
/**
* If its a filtered query with a match all, then we just need the inner filter.
*/
private Filter extractFilterIfApplicable(Query query) {
if (query instanceof XFilteredQuery) {
XFilteredQuery fQuery = (XFilteredQuery) query;
if (Queries.isConstantMatchAllQuery(fQuery.getQuery())) {
return fQuery.getFilter();
}
} else if (query instanceof XConstantScoreQuery) {
return ((XConstantScoreQuery) query).getFilter();
} else if (query instanceof ConstantScoreQuery) {
ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery) query;
if (constantScoreQuery.getFilter() != null) {
return constantScoreQuery.getFilter();
}
}
return null;
}
}
|
synhershko/elasticsearch
|
src/main/java/org/elasticsearch/search/facet/query/QueryFacetCollector.java
|
Java
|
apache-2.0
| 4,105
|
# Copyright (c) Facebook, Inc. and its affiliates.
#
# 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.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import textwrap
import unittest
# The sorted one.
from SortKeys.ttypes import SortedStruct, NegativeId
from SortSets.ttypes import SortedSetStruct
from thrift.protocol import TSimpleJSONProtocol
from thrift.transport.TTransport import TMemoryBuffer
def writeToJSON(obj):
trans = TMemoryBuffer()
proto = TSimpleJSONProtocol.TSimpleJSONProtocol(trans)
obj.write(proto)
return trans.getvalue()
def readStructFromJSON(jstr, struct_type):
stuff = struct_type()
trans = TMemoryBuffer(jstr)
proto = TSimpleJSONProtocol.TSimpleJSONProtocol(trans, struct_type.thrift_spec)
stuff.read(proto)
return stuff
class TestSortKeys(unittest.TestCase):
def testSorted(self):
static_struct = SortedStruct(aMap={"b": 1.0, "a": 1.0})
unsorted_blob = b'{\n "aMap": {\n "b": 1.0,\n "a": 1.0\n }\n}'
sorted_blob = b'{\n "aMap": {\n "a": 1.0,\n "b": 1.0\n }\n}'
sorted_struct = readStructFromJSON(unsorted_blob, SortedStruct)
blob = writeToJSON(sorted_struct)
self.assertNotEqual(blob, unsorted_blob)
self.assertEqual(blob, sorted_blob)
self.assertEqual(static_struct, sorted_struct)
def testSetSorted(self):
unsorted_set = set(["5", "4", "3", "2", "1", "0"])
static_struct = SortedSetStruct(aSet=unsorted_set)
unsorted_blob = (
textwrap.dedent(
"""\
{{
"aSet": [
"{}"
]
}}"""
)
.format('",\n "'.join(unsorted_set))
.encode()
)
sorted_blob = (
textwrap.dedent(
"""\
{{
"aSet": [
"{}"
]
}}"""
)
.format('",\n "'.join(sorted(unsorted_set)))
.encode()
)
sorted_struct = readStructFromJSON(unsorted_blob, SortedSetStruct)
blob = writeToJSON(sorted_struct)
self.assertNotEqual(blob, unsorted_blob)
self.assertEqual(blob, sorted_blob)
self.assertEqual(static_struct, sorted_struct)
def testNegativeId(self):
obj = NegativeId()
self.assertEqual(obj.field1, 1)
self.assertEqual(obj.field2, 2)
self.assertEqual(obj.field3, 3)
|
facebook/fbthrift
|
thrift/test/py/TestSerializationSorted.py
|
Python
|
apache-2.0
| 3,066
|
/*
Erudite v1.1.0 Copyright(c) 2013 Adam A Lara
This software is dedicated to the pursuit of knowledge, the generations before(Dad) and after (Harrison) me, and the love of my life- Jord'an <3
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.
*/
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import org.jdom2.Document;
public class JDOMToTreeModelAdapter implements TreeModel {
//JDOM Document to view as a tree
private Document document;
//listeners for changes, not used in this example
private ArrayList listenerList = new ArrayList();
//constructor used to set the document to view
public JDOMToTreeModelAdapter(Document doc) {
document = doc;
}
//override from TreeModel
public Object getRoot() {
if(document == null) return null;
return new JDOMAdapterNode(document.getRootElement());
}
//override from TreeModel
public Object getChild(Object parent, int index) {
JDOMAdapterNode node = (JDOMAdapterNode) parent;
return node.child(index);
}
//override from TreeModel
public int getIndexOfChild(Object parent, Object child) {
JDOMAdapterNode node = (JDOMAdapterNode) parent;
return node.index((JDOMAdapterNode) child);
}
//override from TreeModel
public int getChildCount(Object parent) {
JDOMAdapterNode jdomNode = (JDOMAdapterNode)parent;
return jdomNode.childCount();
}
//override from TreeModel
public boolean isLeaf(Object node) {
JDOMAdapterNode jdomNode = (JDOMAdapterNode)node;
return (jdomNode.node.getTextTrim().length() > 0);
}
//override from TreeModel
public void valueForPathChanged(TreePath path, Object newValue) {
// Null. We won't be making changes in the GUI
// If we did, we would ensure the new value was really new,
// adjust the model, and then fire a TreeNodesChanged event.
}
/*
* Use these methods to add and remove event listeners.
* (Needed to satisfy TreeModel interface, but not used.)
*/
// override from TreeModel
public void addTreeModelListener(TreeModelListener listener) {
if (listener != null && !listenerList.contains(listener)) {
listenerList.add(listener);
}
}
// override from TreeModel
public void removeTreeModelListener(TreeModelListener listener) {
if (listener != null) {
listenerList.remove(listener);
}
}
/*
* Invoke these methods to inform listeners of changes. (Not needed for this
* example.) Methods taken from TreeModelSupport class described at
* http://java.sun.com/products/jfc/tsc/articles/jtree/index.html That
* architecture (produced by Tom Santos and Steve Wilson) is more elegant. I
* just hacked 'em in here so they are immediately at hand.
*/
public void fireTreeNodesChanged(TreeModelEvent e) {
Iterator listeners = listenerList.iterator();
while (listeners.hasNext()) {
TreeModelListener listener = (TreeModelListener) listeners.next();
listener.treeNodesChanged(e);
}
}
public void fireTreeNodesInserted(TreeModelEvent e) {
Iterator listeners = listenerList.iterator();
while (listeners.hasNext()) {
TreeModelListener listener = (TreeModelListener) listeners.next();
listener.treeNodesInserted(e);
}
}
public void fireTreeNodesRemoved(TreeModelEvent e) {
Iterator listeners = listenerList.iterator();
while (listeners.hasNext()) {
TreeModelListener listener = (TreeModelListener) listeners.next();
listener.treeNodesRemoved(e);
}
}
public void fireTreeStructureChanged(TreeModelEvent e) {
Iterator listeners = listenerList.iterator();
while (listeners.hasNext()) {
TreeModelListener listener = (TreeModelListener) listeners.next();
listener.treeStructureChanged(e);
}
}
}
|
adam-nnl/Erudite
|
v1.1.0/src/JDOMToTreeModelAdapter.java
|
Java
|
apache-2.0
| 4,525
|
<!--
~ Copyright (c) 2020 pCloud AG
~
~ 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.
-->
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_231) on Wed Jul 29 08:52:24 EEST 2020 -->
<title>Generated Documentation (Untitled)</title>
<script type="text/javascript">
tmpTargetPage = "" + window.location.search;
if (tmpTargetPage != "" && tmpTargetPage != "undefined")
tmpTargetPage = tmpTargetPage.substring(1);
if (tmpTargetPage.indexOf(":") != -1 || (tmpTargetPage != "" && !validURL(tmpTargetPage)))
tmpTargetPage = "undefined";
targetPage = tmpTargetPage;
function validURL(url) {
try {
url = decodeURIComponent(url);
}
catch (error) {
return false;
}
var pos = url.indexOf(".html");
if (pos == -1 || pos != url.length - 5)
return false;
var allowNumber = false;
var allowSep = false;
var seenDot = false;
for (var i = 0; i < url.length - 5; i++) {
var ch = url.charAt(i);
if ('a' <= ch && ch <= 'z' ||
'A' <= ch && ch <= 'Z' ||
ch == '$' ||
ch == '_' ||
ch.charCodeAt(0) > 127) {
allowNumber = true;
allowSep = true;
} else if ('0' <= ch && ch <= '9'
|| ch == '-') {
if (!allowNumber)
return false;
} else if (ch == '/' || ch == '.') {
if (!allowSep)
return false;
allowNumber = false;
allowSep = false;
if (ch == '.')
seenDot = true;
if (ch == '/' && seenDot)
return false;
} else {
return false;
}
}
return true;
}
function loadFrames() {
if (targetPage != "" && targetPage != "undefined")
top.classFrame.location = top.targetPage;
}
</script>
</head>
<frameset cols="20%,80%" title="Documentation frame" onload="top.loadFrames()">
<frameset rows="30%,70%" title="Left frames" onload="top.loadFrames()">
<frame src="overview-frame.html" name="packageListFrame" title="All Packages">
<frame src="allclasses-frame.html" name="packageFrame" title="All classes and interfaces (except non-static nested types)">
</frameset>
<frame src="overview-summary.html" name="classFrame" title="Package, class and interface descriptions" scrolling="yes">
<noframes>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<h2>Frame Alert</h2>
<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="overview-summary.html">Non-frame version</a>.</p>
</noframes>
</frameset>
</html>
|
pCloud/pcloud-networking-java
|
docs/index.html
|
HTML
|
apache-2.0
| 3,540
|
# Introduction to dda-pallet-commons
TODO: write [great documentation](http://jacobian.org/writing/what-to-write/)
|
DomainDrivenArchitecture/dda-pallet-commons
|
doc/intro.md
|
Markdown
|
apache-2.0
| 116
|
package dao
import (
"bytes"
"context"
"fmt"
"net/http"
"strings"
"time"
"go-common/app/admin/main/cache/model"
"go-common/library/ecode"
"go-common/library/log"
)
var (
tokenURI = "http://easyst.bilibili.co/v1/token"
dataURI = "http://easyst.bilibili.co/v1/node/apptree"
authURI = "http://easyst.bilibili.co/v1/auth"
nodeURI = "http://easyst.bilibili.co/v1/node/bilibili%s"
appsURI = "http://easyst.bilibili.co/v1/node/role/app"
prefix = []byte("bilibili.")
)
// Token get Token.
func (d *Dao) Token(c context.Context, body string) (msg map[string]interface{}, err error) {
var (
req *http.Request
)
if req, err = http.NewRequest("POST", tokenURI, strings.NewReader(body)); err != nil {
log.Error("Token url(%s) error(%v)", tokenURI, err)
return
}
var res struct {
Code int `json:"code"`
Data map[string]interface{} `json:"data"`
Message string `json:"message"`
Status int `json:"status"`
}
if err = d.client.Do(c, req, &res); err != nil {
log.Error("d.Token url(%s) res(%+v) err(%v)", tokenURI, res, err)
return
}
if res.Code != 90000 {
err = fmt.Errorf("error code :%d", res.Code)
log.Error("Status url(%s) res(%v)", tokenURI, res)
return
}
msg = res.Data
return
}
// Auth get Token.
func (d *Dao) Auth(c context.Context, cookie string) (msg map[string]interface{}, err error) {
var (
req *http.Request
)
if req, err = http.NewRequest("GET", authURI, nil); err != nil {
log.Error("Token url(%s) error(%v)", tokenURI, err)
return
}
req.Header.Set("Cookie", cookie)
var res struct {
Code int `json:"code"`
Data map[string]interface{} `json:"data"`
Message string `json:"message"`
Status int `json:"status"`
}
if err = d.client.Do(c, req, &res); err != nil {
log.Error("d.Token url(%s) res(%s) err(%v)", tokenURI, res, err)
return
}
if res.Code != 90000 {
err = fmt.Errorf("error code :%d", res.Code)
log.Error("Status url(%s) res(%v)", tokenURI, res)
return
}
msg = res.Data
return
}
// Tree get service tree.
func (d *Dao) Tree(c context.Context, token string) (data interface{}, err error) {
var (
req *http.Request
tmp map[string]interface{}
ok bool
)
if req, err = http.NewRequest("GET", dataURI, nil); err != nil {
log.Error("Status url(%s) error(%v)", dataURI, err)
return
}
req.Header.Set("X-Authorization-Token", token)
req.Header.Set("Content-Type", "application/json")
var res struct {
Code int `json:"code"`
Data map[string]map[string]interface{} `json:"data"`
Message string `json:"message"`
Status int `json:"status"`
}
if err = d.client.Do(c, req, &res); err != nil {
log.Error("d.Status url(%s) res($s) err(%v)", dataURI, res, err)
return
}
if res.Code != 90000 {
err = fmt.Errorf("error code :%d", res.Code)
log.Error("Status url(%s) res(%v)", dataURI, res)
return
}
if tmp, ok = res.Data["bilibili"]; ok {
data, ok = tmp["children"]
}
if !ok {
err = ecode.NothingFound
}
return
}
// Role get service tree.
func (d *Dao) Role(c context.Context, token string) (nodes *model.CacheData, err error) {
var (
req *http.Request
)
if req, err = http.NewRequest("GET", appsURI, nil); err != nil {
log.Error("Status url(%s) error(%v)", dataURI, err)
return
}
req.Header.Set("X-Authorization-Token", token)
req.Header.Set("Content-Type", "application/json")
var res struct {
Code int `json:"code"`
Data []*model.RoleNode `json:"data"`
Message string `json:"message"`
Status int `json:"status"`
}
if err = d.client.Do(c, req, &res); err != nil {
log.Error("d.Status url(%s) res($s) err(%v)", dataURI, res, err)
return
}
if res.Code != 90000 {
err = fmt.Errorf("error code :%d", res.Code)
log.Error("Status url(%s) res(%v)", dataURI, res)
return
}
nodes = &model.CacheData{Data: make(map[int64]*model.RoleNode)}
nodes.CTime = time.Now()
for _, node := range res.Data {
if bytes.Equal(prefix, []byte(node.Path)[0:9]) {
node.Path = string([]byte(node.Path)[9:])
}
nodes.Data[node.ID] = node
}
return
}
// NodeTree get service tree.
func (d *Dao) NodeTree(c context.Context, token, bu, team string) (nodes []*model.Node, err error) {
var (
req *http.Request
node string
)
if len(bu) != 0 {
node = "." + bu
}
if len(team) != 0 {
node = "." + team
}
if len(node) == 0 {
nodes = append(nodes, &model.Node{Name: "main", Path: "main"})
nodes = append(nodes, &model.Node{Name: "ai", Path: "ai"})
return
}
if req, err = http.NewRequest("GET", fmt.Sprintf(nodeURI, node), nil); err != nil {
log.Error("Status url(%s) error(%v)", dataURI, err)
return
}
req.Header.Set("X-Authorization-Token", token)
req.Header.Set("Content-Type", "application/json")
var res struct {
Code int `json:"code"`
Data *model.Res `json:"data"`
Message string `json:"message"`
Status int `json:"status"`
}
if err = d.client.Do(c, req, &res); err != nil {
log.Error("d.Status url(%s) res($s) err(%v)", dataURI, res, err)
return
}
if res.Code != 90000 {
err = fmt.Errorf("error code :%d", res.Code)
log.Error("Status url(%s) error(%v)", dataURI, err)
return
}
for _, tnode := range res.Data.Data {
if bytes.Equal(prefix, []byte(tnode.Path)[0:9]) {
tnode.Path = string([]byte(tnode.Path)[9:])
}
nodes = append(nodes, &model.Node{Name: tnode.Name, Path: tnode.Path})
}
return
}
|
LQJJ/demo
|
126-go-common-master/app/admin/main/cache/dao/tree.go
|
GO
|
apache-2.0
| 5,598
|
package dao
import (
"context"
"database/sql"
"fmt"
"go-common/library/log"
)
const (
_queryBvcResource = "select id from %s where svid = %d"
_queryCoverResource = "select cover_url,cover_width,cover_height from video_repository where svid = ?"
)
//CheckSVResource ...
func (d *Dao) CheckSVResource(c context.Context, svid int64) (err error) {
var (
ID int64
cURL string
cH int64
cW int64
)
tN := fmt.Sprintf("video_bvc_%02d", svid%100)
if err = d.db.QueryRow(c, fmt.Sprintf(_queryBvcResource, tN, svid)).Scan(&ID); err == sql.ErrNoRows {
log.Error("CheckSVResource bvc err,svid:%d,err:%v", svid, err)
return
}
//cover,err := d.cmsdb.QueryRow(c, query, ...)
if err = d.db.QueryRow(c, _queryCoverResource, svid).Scan(&cURL, &cW, &cH); err == sql.ErrNoRows {
log.Error("CheckSVResource cover err,svid:%d,err:%v", svid, err)
return
}
return
}
|
LQJJ/demo
|
126-go-common-master/app/service/bbq/video/dao/check.go
|
GO
|
apache-2.0
| 883
|
## PP Comm view test bed
Setup:
Requires node, npm and bower installed globally
Also a good idea to have LiveReload chrome extension installed and running
`(sudo) npm install -g grunt-cli bower`
`npm install`
`bower install`
`grunt scaffold`
`grunt`
# Web Interface
Once you've run `nodemon server.js` you should be able to access the index page at http://localhost:3000.
# API
The API is pretty simple.
Get all animals: `http://localhost:3000/v1/animals`
Get a single animal: `http://localhost:3000/v1/animal/cow`
|
4fthawaiian/cowgoes
|
README.md
|
Markdown
|
apache-2.0
| 530
|
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.Net;
using System.IO;
using SHDocVw;
using System.Runtime.InteropServices;
using mshtml;
public struct OLECMDTEXT {
public uint cmdtextf;
public uint cwActual;
public uint cwBuf;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 100)]
public char rgwz;
}
[StructLayout(LayoutKind.Sequential)]
public struct OLECMD {
public uint cmdID;
public uint cmdf;
}
[ComImport,
Guid("b722bccb-4e68-101b-a2bc-00aa00404770"),
InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleCommandTarget {
void QueryStatus(ref Guid pguidCmdGroup, UInt32 cCmds,
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] OLECMD[] prgCmds, ref OLECMDTEXT CmdText);
void Exec(ref Guid pguidCmdGroup, uint nCmdId, uint nCmdExecOpt, ref object pvaIn, ref object pvaOut);
}
namespace V5.DataWebBrowser {
public partial class frmMainBrowser : Form {
private bool IsInvoke = false;
public delegate void ReturnCookie(string Cookie);
public ReturnCookie rCookie;
public delegate void ReturnExportCookie(string Cookie);
public ReturnExportCookie rExportCookie;
public delegate void ReturnPOST(string cookie, string pData);
public ReturnPOST rPData;
public delegate void ReturnExportPOST(string cookie, string pData);
public ReturnExportPOST rExportPData;
///Èç¹ûΪ
/// 0-·µ»Ø²É¼¯Êý¾ÝµÄcookie£¨ÔËÐÐʱ²É¼¯ºÍÈÎÎñÌîдcookieʱ²É¼¯£©£¬
///1-·µ»Ø²É¼¯Êý¾ÝpostÊý¾Ý£¬
///2-·µ»Øµ¼³öÊý¾ÝµÄcookie£¬
///3-·µ»Øµ¼³öÊý¾ÝµÄpostÊý¾Ý£¬
///4-Õý³£µÄä¯ÀÀÆ÷
private int m_GetFlag = 4;
private Guid cmdGuid = new Guid("ED016940-BD5B-11CF-BA4E-00C04FD70816");
private enum MiscCommandTarget { Find = 1, ViewSource, Options }
public int getFlag {
get { return m_GetFlag; }
set { m_GetFlag = value; }
}
public frmMainBrowser() {
InitializeComponent();
}
public frmMainBrowser(string Url) {
InitializeComponent();
this.txtUrl.Text = Url;
}
private void wb_NavigateComplete2(object pDisp, ref object URL) {
Cursor.Current = Cursors.Default;
toolStripProgressBar1.Value = 0;
this.txtUrl.Text = ((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).Url.ToString();
this.textBox1.Text = ((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).Document.Cookie.ToString();
}
private void frmWeblink_Resize(object sender, EventArgs e) {
this.txtUrl.Width = this.Width - this.txtUrl.Left - this.butUrl.Width - 50;
this.butUrl.Left = this.txtUrl.Left + this.txtUrl.Width;
}
private void frmWeblink_Load(object sender, EventArgs e) {
this.splitContainer2.SplitterDistance = this.splitContainer2.Height - 100;
switch (this.getFlag) {
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
this.toolCancleExit.Text = "¹Ø±Õ";
break;
default:
break;
}
if (this.txtUrl.Text.Trim() != "" || this.txtUrl.Text != null) {
GoUrl();
}
}
private void wb_NewWindow2(ref object ppDisp, ref bool Cancel) {
SHDocVw.WebBrowser _axWebBrowser = CreateNewWebBrowser();
ppDisp = _axWebBrowser.Application;
_axWebBrowser.RegisterAsBrowser = true;
}
private void wb_BeforeNavigate2(object pDisp, ref object URL, ref object Flags, ref object TargetFrameName, ref object PostData, ref object Headers, ref bool Cancel) {
this.textBox2.Text = System.Text.Encoding.ASCII.GetString(PostData as byte[]);
this.textBox1.Text = ((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).Document.Cookie.ToString();
}
private void toolSource_Click(object sender, EventArgs e) {
IOleCommandTarget cmdt;
Object o = new object();
try {
cmdt = (IOleCommandTarget)GetDocument();
cmdt.Exec(ref cmdGuid, (uint)MiscCommandTarget.ViewSource,
(uint)SHDocVw.OLECMDEXECOPT.OLECMDEXECOPT_DODEFAULT, ref o, ref o);
}
catch (Exception ex) {
MessageBox.Show(ex.Message, "´íÎóÐÅÏ¢", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private HTMLDocument GetDocument() {
try {
SHDocVw.WebBrowser wb = (SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance;
HTMLDocument htm = (HTMLDocument)wb.Document;
return htm;
}
catch (System.Exception ex) {
throw (ex);
}
}
private void GoUrl() {
string url = this.txtUrl.Text;
SHDocVw.WebBrowser wb = CreateNewWebBrowser();
if (url == "")
return;
try {
Cursor.Current = Cursors.WaitCursor;
Object o = null;
wb.Navigate(url, ref o, ref o, ref o, ref o);
}
finally {
int i = this.txtUrl.Items.IndexOf(url);
if (i == -1)
this.txtUrl.Items.Add(url);
Cursor.Current = Cursors.Default;
}
}
private void wb_DocumentComplete(object pDisp, ref object URL) {
SHDocVw.WebBrowser wb = (SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance;
if (wb.ReadyState == SHDocVw.tagREADYSTATE.READYSTATE_COMPLETE) {
this.txtUrl.Text = wb.LocationURL;
this.toolStripProgressBar1.Value = 0;
this.toolStripProgressBar1.Visible = false;
}
this.textBox1.Text = ((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).Document.Cookie.ToString();
}
private void wb_ProgressChange(int Progress, int ProgressMax) {
this.toolStripProgressBar1.Visible = true;
SHDocVw.WebBrowser wb = (SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance;
if ((Progress > 0) && (ProgressMax > 0)) {
this.toolStripProgressBar1.Maximum = ProgressMax;
this.toolStripProgressBar1.Step = Progress;
this.toolStripProgressBar1.PerformStep();
}
else if (wb.ReadyState == SHDocVw.tagREADYSTATE.READYSTATE_COMPLETE) {
this.toolStripProgressBar1.Value = 0;
this.toolStripProgressBar1.Visible = false;
}
}
private void wb_StatusTextChange(string Text) {
this.toolStripStatusLabel1.Text = Text;
}
private SHDocVw.WebBrowser CreateNewWebBrowser() {
this.toolSource.Enabled = true;
System.Windows.Forms.WebBrowser TmpWebBrowser = new System.Windows.Forms.WebBrowser();
if (this.WebBrowserTab.TabPages.Count == 1 && this.WebBrowserTab.TabPages[0].Controls.Count == 0) {
this.WebBrowserTab.TabPages[0].Controls.Add(TmpWebBrowser);
}
else {
this.WebBrowserTab.TabPages[0].Controls.Clear();
this.WebBrowserTab.TabPages[0].Controls.Add(TmpWebBrowser);
}
TmpWebBrowser.Dock = DockStyle.Fill;
SHDocVw.WebBrowser wb = (SHDocVw.WebBrowser)TmpWebBrowser.ActiveXInstance;
wb.CommandStateChange += new SHDocVw.DWebBrowserEvents2_CommandStateChangeEventHandler(this.wb_CommandStateChange);
wb.BeforeNavigate2 += new SHDocVw.DWebBrowserEvents2_BeforeNavigate2EventHandler(this.wb_BeforeNavigate2);
wb.ProgressChange += new SHDocVw.DWebBrowserEvents2_ProgressChangeEventHandler(this.wb_ProgressChange);
wb.StatusTextChange += new SHDocVw.DWebBrowserEvents2_StatusTextChangeEventHandler(this.wb_StatusTextChange);
wb.NavigateError += new SHDocVw.DWebBrowserEvents2_NavigateErrorEventHandler(this.wb_NavigateError);
wb.NavigateComplete2 += new SHDocVw.DWebBrowserEvents2_NavigateComplete2EventHandler(this.wb_NavigateComplete2);
wb.TitleChange += new SHDocVw.DWebBrowserEvents2_TitleChangeEventHandler(this.wb_TitleChange);
wb.DocumentComplete += new SHDocVw.DWebBrowserEvents2_DocumentCompleteEventHandler(this.wb_DocumentComplete);
wb.NewWindow2 += new SHDocVw.DWebBrowserEvents2_NewWindow2EventHandler(this.wb_NewWindow2);
return wb;
}
private void wb_CommandStateChange(int Command, bool Enable) {
switch (Command) {
case ((int)CommandStateChangeConstants.CSC_NAVIGATEFORWARD):
this.toolNext.Enabled = Enable;
this.menuNext.Enabled = Enable;
break;
case ((int)CommandStateChangeConstants.CSC_NAVIGATEBACK):
this.toolBack.Enabled = Enable;
this.menuBack.Enabled = Enable;
break;
default:
break;
}
}
private void wb_NavigateError(object pDisp, ref object URL, ref object Frame, ref object StatusCode, ref bool Cancel) {
}
private void butUrl_Click(object sender, EventArgs e) {
GoUrl();
}
private void wb_TitleChange(string Text) {
this.WebBrowserTab.TabPages[0].Text = Text;
}
private void txtUrl_KeyDown(object sender, KeyEventArgs e) {
if (e.KeyCode == Keys.Enter) {
GoUrl();
}
}
private void OkExit() {
switch (this.getFlag) {
case 0:
if (rCookie != null) {
rCookie(this.textBox1.Text);
}
break;
case 1:
if (rPData != null) {
rPData(this.textBox1.Text, this.textBox2.Text);
}
break;
case 2:
if (rExportCookie != null) {
rExportCookie(this.textBox1.Text);
}
break;
case 3:
if (rExportPData != null) {
rExportPData(this.textBox1.Text, this.textBox2.Text);
}
break;
case 4:
break;
default:
break;
}
this.DialogResult = DialogResult.OK;
}
private void menuAbout_Click(object sender, EventArgs e) {
}
private void menuExit_Click(object sender, EventArgs e) {
this.DialogResult = DialogResult.Cancel;
this.Close();
this.Dispose();
}
private void toolCancleExit_Click(object sender, EventArgs e) {
this.DialogResult = DialogResult.Cancel;
this.Close();
this.Dispose();
}
private void toolHome_Click(object sender, EventArgs e) {
this.txtUrl.Text = "http://www.v5soft.com";
GoUrl();
}
private void toolOkExit_Click(object sender, EventArgs e) {
Console.Write(this.textBox1.Text);
System.Environment.Exit(-1);
}
private void toolBack_Click(object sender, EventArgs e) {
((SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance).GoBack();
}
private void menuBack_Click(object sender, EventArgs e) {
((SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance).GoBack();
}
private void menuNext_Click(object sender, EventArgs e) {
((SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance).GoForward();
}
private void toolNext_Click(object sender, EventArgs e) {
((SHDocVw.WebBrowser)((System.Windows.Forms.WebBrowser)this.WebBrowserTab.TabPages[0].Controls[0]).ActiveXInstance).GoForward();
}
}
}
|
lsamu/V5_DataCollection
|
V5_DataWebBrowser/frmMainBrowser.cs
|
C#
|
apache-2.0
| 13,007
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_77) on Mon May 23 19:37:25 EDT 2016 -->
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Uses of Class org.apache.lucene.search.suggest.fst.FSTCompletion.Completion (Lucene 6.0.1 API)</title>
<meta name="date" content="2016-05-23">
<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Class org.apache.lucene.search.suggest.fst.FSTCompletion.Completion (Lucene 6.0.1 API)";
}
}
catch(err) {
}
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/lucene/search/suggest/fst/class-use/FSTCompletion.Completion.html" target="_top">Frames</a></li>
<li><a href="FSTCompletion.Completion.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="header">
<h2 title="Uses of Class org.apache.lucene.search.suggest.fst.FSTCompletion.Completion" class="title">Uses of Class<br>org.apache.lucene.search.suggest.fst.FSTCompletion.Completion</h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">FSTCompletion.Completion</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.apache.lucene.search.suggest.fst">org.apache.lucene.search.suggest.fst</a></td>
<td class="colLast">
<div class="block">Finite-state based autosuggest.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="org.apache.lucene.search.suggest.fst">
<!-- -->
</a>
<h3>Uses of <a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">FSTCompletion.Completion</a> in <a href="../../../../../../../org/apache/lucene/search/suggest/fst/package-summary.html">org.apache.lucene.search.suggest.fst</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/apache/lucene/search/suggest/fst/package-summary.html">org.apache.lucene.search.suggest.fst</a> that return types with arguments of type <a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">FSTCompletion.Completion</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code><a href="http://download.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a><<a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">FSTCompletion.Completion</a>></code></td>
<td class="colLast"><span class="typeNameLabel">FSTCompletion.</span><code><span class="memberNameLink"><a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.html#lookup-java.lang.CharSequence-int-">lookup</a></span>(<a href="http://download.oracle.com/javase/8/docs/api/java/lang/CharSequence.html?is-external=true" title="class or interface in java.lang">CharSequence</a> key,
int num)</code>
<div class="block">Lookup suggestions to <code>key</code>.</div>
</td>
</tr>
</tbody>
</table>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing methods, and an explanation">
<caption><span>Methods in <a href="../../../../../../../org/apache/lucene/search/suggest/fst/package-summary.html">org.apache.lucene.search.suggest.fst</a> with parameters of type <a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">FSTCompletion.Completion</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>int</code></td>
<td class="colLast"><span class="typeNameLabel">FSTCompletion.Completion.</span><code><span class="memberNameLink"><a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html#compareTo-org.apache.lucene.search.suggest.fst.FSTCompletion.Completion-">compareTo</a></span>(<a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">FSTCompletion.Completion</a> o)</code> </td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../../../../../org/apache/lucene/search/suggest/fst/FSTCompletion.Completion.html" title="class in org.apache.lucene.search.suggest.fst">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/lucene/search/suggest/fst/class-use/FSTCompletion.Completion.html" target="_top">Frames</a></li>
<li><a href="FSTCompletion.Completion.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>
<i>Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.</i>
<script src='../../../../../../../prettify.js' type='text/javascript'></script>
<script type='text/javascript'>
(function(){
var oldonload = window.onload;
if (typeof oldonload != 'function') {
window.onload = prettyPrint;
} else {
window.onload = function() {
oldonload();
prettyPrint();
}
}
})();
</script>
</small></p>
</body>
</html>
|
YorkUIRLab/irlab
|
lib/lucene-6.0.1/docs/suggest/org/apache/lucene/search/suggest/fst/class-use/FSTCompletion.Completion.html
|
HTML
|
apache-2.0
| 9,460
|
#include <endian.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
int
main(int argc, char *argv[])
{
union {
uint32_t u32;
uint8_t arr[4];
} x;
x.arr[0] = 0x11; /* Lowest-address byte */
x.arr[1] = 0x22;
x.arr[2] = 0x33;
x.arr[3] = 0x44; /* Highest-address byte */
printf("x.u32 = 0x%x\n", x.u32);
printf("htole32(x.u32) = 0x%x\n", htole32(x.u32));
printf("htobe32(x.u32) = 0x%x\n", htobe32(x.u32));
printf("0x%x\n", *(uint32_t*)&x);
exit(EXIT_SUCCESS);
}
// !!! man endian to see more functions
~
|
derek-zhang/linux
|
byteorder.c
|
C
|
apache-2.0
| 628
|
nuget.exe pack CA.Blocks.DataAccess.csproj -Prop Platform=AnyCPU
|
KevinBosch/CA.Blocks.DataAccess
|
CA.Blocks.DataAccess/PrepNugetPackage.bat
|
Batchfile
|
apache-2.0
| 64
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--NewPage-->
<HTML>
<HEAD>
<!-- Generated by javadoc (build 1.6.0_35) on Tue Dec 25 19:15:56 MSK 2012 -->
<TITLE>
Imgproc
</TITLE>
<META NAME="date" CONTENT="2012-12-25">
<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../stylesheet.css" TITLE="Style">
<SCRIPT type="text/javascript">
function windowTitle()
{
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Imgproc";
}
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>
</HEAD>
<BODY BGCOLOR="white" onload="windowTitle();">
<HR>
<!-- ========= START OF TOP NAVBAR ======= -->
<A NAME="navbar_top"><!-- --></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
<TR ALIGN="center" VALIGN="top">
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A> </TD>
<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> <FONT CLASS="NavBarFont1Rev"><B>Class</B></FONT> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A> </TD>
</TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
OpenCV 2.4.3.2</EM>
</TD>
</TR>
<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
PREV CLASS
<A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc"><B>NEXT CLASS</B></A></FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../index.html?org/opencv/imgproc/Imgproc.html" target="_top"><B>FRAMES</B></A>
<A HREF="Imgproc.html" target="_top"><B>NO FRAMES</B></A>
<SCRIPT type="text/javascript">
<!--
if(window==top) {
document.writeln('<A HREF="../../../allclasses-noframe.html"><B>All Classes</B></A>');
}
//-->
</SCRIPT>
<NOSCRIPT>
<A HREF="../../../allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>
</FONT></TD>
</TR>
<TR>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
SUMMARY: NESTED | <A HREF="#field_summary">FIELD</A> | <A HREF="#constructor_summary">CONSTR</A> | <A HREF="#method_summary">METHOD</A></FONT></TD>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
DETAIL: <A HREF="#field_detail">FIELD</A> | <A HREF="#constructor_detail">CONSTR</A> | <A HREF="#method_detail">METHOD</A></FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<!-- ========= END OF TOP NAVBAR ========= -->
<HR>
<!-- ======== START OF CLASS DATA ======== -->
<H2>
<FONT SIZE="-1">
org.opencv.imgproc</FONT>
<BR>
Class Imgproc</H2>
<PRE>
java.lang.Object
<IMG SRC="../../../resources/inherit.gif" ALT="extended by "><B>org.opencv.imgproc.Imgproc</B>
</PRE>
<HR>
<DL>
<DT><PRE>public class <B>Imgproc</B><DT>extends java.lang.Object</DL>
</PRE>
<P>
<HR>
<P>
<!-- =========== FIELD SUMMARY =========== -->
<A NAME="field_summary"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
<B>Field Summary</B></FONT></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#ADAPTIVE_THRESH_GAUSSIAN_C">ADAPTIVE_THRESH_GAUSSIAN_C</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#ADAPTIVE_THRESH_MEAN_C">ADAPTIVE_THRESH_MEAN_C</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_CONSTANT">BORDER_CONSTANT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_DEFAULT">BORDER_DEFAULT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_ISOLATED">BORDER_ISOLATED</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_REFLECT">BORDER_REFLECT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_REFLECT_101">BORDER_REFLECT_101</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_REFLECT101">BORDER_REFLECT101</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_REPLICATE">BORDER_REPLICATE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_TRANSPARENT">BORDER_TRANSPARENT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#BORDER_WRAP">BORDER_WRAP</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CHAIN_APPROX_NONE">CHAIN_APPROX_NONE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CHAIN_APPROX_SIMPLE">CHAIN_APPROX_SIMPLE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CHAIN_APPROX_TC89_KCOS">CHAIN_APPROX_TC89_KCOS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CHAIN_APPROX_TC89_L1">CHAIN_APPROX_TC89_L1</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerBG2BGR">COLOR_BayerBG2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerBG2BGR_VNG">COLOR_BayerBG2BGR_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerBG2GRAY">COLOR_BayerBG2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerBG2RGB">COLOR_BayerBG2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerBG2RGB_VNG">COLOR_BayerBG2RGB_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGB2BGR">COLOR_BayerGB2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGB2BGR_VNG">COLOR_BayerGB2BGR_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGB2GRAY">COLOR_BayerGB2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGB2RGB">COLOR_BayerGB2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGB2RGB_VNG">COLOR_BayerGB2RGB_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGR2BGR">COLOR_BayerGR2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGR2BGR_VNG">COLOR_BayerGR2BGR_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGR2GRAY">COLOR_BayerGR2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGR2RGB">COLOR_BayerGR2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerGR2RGB_VNG">COLOR_BayerGR2RGB_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerRG2BGR">COLOR_BayerRG2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerRG2BGR_VNG">COLOR_BayerRG2BGR_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerRG2GRAY">COLOR_BayerRG2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerRG2RGB">COLOR_BayerRG2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BayerRG2RGB_VNG">COLOR_BayerRG2RGB_VNG</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2BGR555">COLOR_BGR2BGR555</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2BGR565">COLOR_BGR2BGR565</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2BGRA">COLOR_BGR2BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2GRAY">COLOR_BGR2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2HLS">COLOR_BGR2HLS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2HLS_FULL">COLOR_BGR2HLS_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2HSV">COLOR_BGR2HSV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2HSV_FULL">COLOR_BGR2HSV_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2Lab">COLOR_BGR2Lab</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2Luv">COLOR_BGR2Luv</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2RGB">COLOR_BGR2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2RGBA">COLOR_BGR2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2XYZ">COLOR_BGR2XYZ</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2YCrCb">COLOR_BGR2YCrCb</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR2YUV">COLOR_BGR2YUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5552BGR">COLOR_BGR5552BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5552BGRA">COLOR_BGR5552BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5552GRAY">COLOR_BGR5552GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5552RGB">COLOR_BGR5552RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5552RGBA">COLOR_BGR5552RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5652BGR">COLOR_BGR5652BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5652BGRA">COLOR_BGR5652BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5652GRAY">COLOR_BGR5652GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5652RGB">COLOR_BGR5652RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGR5652RGBA">COLOR_BGR5652RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGRA2BGR">COLOR_BGRA2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGRA2BGR555">COLOR_BGRA2BGR555</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGRA2BGR565">COLOR_BGRA2BGR565</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGRA2GRAY">COLOR_BGRA2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGRA2RGB">COLOR_BGRA2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_BGRA2RGBA">COLOR_BGRA2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_COLORCVT_MAX">COLOR_COLORCVT_MAX</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_GRAY2BGR">COLOR_GRAY2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_GRAY2BGR555">COLOR_GRAY2BGR555</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_GRAY2BGR565">COLOR_GRAY2BGR565</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_GRAY2BGRA">COLOR_GRAY2BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_GRAY2RGB">COLOR_GRAY2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_GRAY2RGBA">COLOR_GRAY2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HLS2BGR">COLOR_HLS2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HLS2BGR_FULL">COLOR_HLS2BGR_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HLS2RGB">COLOR_HLS2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HLS2RGB_FULL">COLOR_HLS2RGB_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HSV2BGR">COLOR_HSV2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HSV2BGR_FULL">COLOR_HSV2BGR_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HSV2RGB">COLOR_HSV2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_HSV2RGB_FULL">COLOR_HSV2RGB_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Lab2BGR">COLOR_Lab2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Lab2LBGR">COLOR_Lab2LBGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Lab2LRGB">COLOR_Lab2LRGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Lab2RGB">COLOR_Lab2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_LBGR2Lab">COLOR_LBGR2Lab</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_LBGR2Luv">COLOR_LBGR2Luv</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_LRGB2Lab">COLOR_LRGB2Lab</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_LRGB2Luv">COLOR_LRGB2Luv</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Luv2BGR">COLOR_Luv2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Luv2LBGR">COLOR_Luv2LBGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Luv2LRGB">COLOR_Luv2LRGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_Luv2RGB">COLOR_Luv2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_mRGBA2RGBA">COLOR_mRGBA2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2BGR">COLOR_RGB2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2BGR555">COLOR_RGB2BGR555</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2BGR565">COLOR_RGB2BGR565</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2BGRA">COLOR_RGB2BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2GRAY">COLOR_RGB2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2HLS">COLOR_RGB2HLS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2HLS_FULL">COLOR_RGB2HLS_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2HSV">COLOR_RGB2HSV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2HSV_FULL">COLOR_RGB2HSV_FULL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2Lab">COLOR_RGB2Lab</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2Luv">COLOR_RGB2Luv</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2RGBA">COLOR_RGB2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2XYZ">COLOR_RGB2XYZ</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2YCrCb">COLOR_RGB2YCrCb</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGB2YUV">COLOR_RGB2YUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2BGR">COLOR_RGBA2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2BGR555">COLOR_RGBA2BGR555</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2BGR565">COLOR_RGBA2BGR565</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2BGRA">COLOR_RGBA2BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2GRAY">COLOR_RGBA2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2mRGBA">COLOR_RGBA2mRGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_RGBA2RGB">COLOR_RGBA2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_XYZ2BGR">COLOR_XYZ2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_XYZ2RGB">COLOR_XYZ2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YCrCb2BGR">COLOR_YCrCb2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YCrCb2RGB">COLOR_YCrCb2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR">COLOR_YUV2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_I420">COLOR_YUV2BGR_I420</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_IYUV">COLOR_YUV2BGR_IYUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_NV12">COLOR_YUV2BGR_NV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_NV21">COLOR_YUV2BGR_NV21</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_UYNV">COLOR_YUV2BGR_UYNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_UYVY">COLOR_YUV2BGR_UYVY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_Y422">COLOR_YUV2BGR_Y422</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_YUNV">COLOR_YUV2BGR_YUNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_YUY2">COLOR_YUV2BGR_YUY2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_YUYV">COLOR_YUV2BGR_YUYV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_YV12">COLOR_YUV2BGR_YV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGR_YVYU">COLOR_YUV2BGR_YVYU</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_I420">COLOR_YUV2BGRA_I420</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_IYUV">COLOR_YUV2BGRA_IYUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_NV12">COLOR_YUV2BGRA_NV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_NV21">COLOR_YUV2BGRA_NV21</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_UYNV">COLOR_YUV2BGRA_UYNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_UYVY">COLOR_YUV2BGRA_UYVY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_Y422">COLOR_YUV2BGRA_Y422</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_YUNV">COLOR_YUV2BGRA_YUNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_YUY2">COLOR_YUV2BGRA_YUY2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_YUYV">COLOR_YUV2BGRA_YUYV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_YV12">COLOR_YUV2BGRA_YV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2BGRA_YVYU">COLOR_YUV2BGRA_YVYU</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_420">COLOR_YUV2GRAY_420</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_I420">COLOR_YUV2GRAY_I420</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_IYUV">COLOR_YUV2GRAY_IYUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_NV12">COLOR_YUV2GRAY_NV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_NV21">COLOR_YUV2GRAY_NV21</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_UYNV">COLOR_YUV2GRAY_UYNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_UYVY">COLOR_YUV2GRAY_UYVY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_Y422">COLOR_YUV2GRAY_Y422</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_YUNV">COLOR_YUV2GRAY_YUNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_YUY2">COLOR_YUV2GRAY_YUY2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_YUYV">COLOR_YUV2GRAY_YUYV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_YV12">COLOR_YUV2GRAY_YV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2GRAY_YVYU">COLOR_YUV2GRAY_YVYU</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB">COLOR_YUV2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_I420">COLOR_YUV2RGB_I420</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_IYUV">COLOR_YUV2RGB_IYUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_NV12">COLOR_YUV2RGB_NV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_NV21">COLOR_YUV2RGB_NV21</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_UYNV">COLOR_YUV2RGB_UYNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_UYVY">COLOR_YUV2RGB_UYVY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_Y422">COLOR_YUV2RGB_Y422</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_YUNV">COLOR_YUV2RGB_YUNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_YUY2">COLOR_YUV2RGB_YUY2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_YUYV">COLOR_YUV2RGB_YUYV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_YV12">COLOR_YUV2RGB_YV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGB_YVYU">COLOR_YUV2RGB_YVYU</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_I420">COLOR_YUV2RGBA_I420</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_IYUV">COLOR_YUV2RGBA_IYUV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_NV12">COLOR_YUV2RGBA_NV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_NV21">COLOR_YUV2RGBA_NV21</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_UYNV">COLOR_YUV2RGBA_UYNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_UYVY">COLOR_YUV2RGBA_UYVY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_Y422">COLOR_YUV2RGBA_Y422</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_YUNV">COLOR_YUV2RGBA_YUNV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_YUY2">COLOR_YUV2RGBA_YUY2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_YUYV">COLOR_YUV2RGBA_YUYV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_YV12">COLOR_YUV2RGBA_YV12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV2RGBA_YVYU">COLOR_YUV2RGBA_YVYU</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420p2BGR">COLOR_YUV420p2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420p2BGRA">COLOR_YUV420p2BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420p2GRAY">COLOR_YUV420p2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420p2RGB">COLOR_YUV420p2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420p2RGBA">COLOR_YUV420p2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420sp2BGR">COLOR_YUV420sp2BGR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420sp2BGRA">COLOR_YUV420sp2BGRA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420sp2GRAY">COLOR_YUV420sp2GRAY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420sp2RGB">COLOR_YUV420sp2RGB</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#COLOR_YUV420sp2RGBA">COLOR_YUV420sp2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_BILATERAL">CV_BILATERAL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_BLUR">CV_BLUR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_BLUR_NO_SCALE">CV_BLUR_NO_SCALE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_CANNY_L2_GRADIENT">CV_CANNY_L2_GRADIENT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_CHAIN_CODE">CV_CHAIN_CODE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_CLOCKWISE">CV_CLOCKWISE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_COMP_BHATTACHARYYA">CV_COMP_BHATTACHARYYA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_COMP_CHISQR">CV_COMP_CHISQR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_COMP_CORREL">CV_COMP_CORREL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_COMP_HELLINGER">CV_COMP_HELLINGER</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_COMP_INTERSECT">CV_COMP_INTERSECT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_CONTOURS_MATCH_I1">CV_CONTOURS_MATCH_I1</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_CONTOURS_MATCH_I2">CV_CONTOURS_MATCH_I2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_CONTOURS_MATCH_I3">CV_CONTOURS_MATCH_I3</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_COUNTER_CLOCKWISE">CV_COUNTER_CLOCKWISE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_C">CV_DIST_C</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_FAIR">CV_DIST_FAIR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_HUBER">CV_DIST_HUBER</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_L1">CV_DIST_L1</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_L12">CV_DIST_L12</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_L2">CV_DIST_L2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_LABEL_CCOMP">CV_DIST_LABEL_CCOMP</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_LABEL_PIXEL">CV_DIST_LABEL_PIXEL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_MASK_3">CV_DIST_MASK_3</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_MASK_5">CV_DIST_MASK_5</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_MASK_PRECISE">CV_DIST_MASK_PRECISE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_USER">CV_DIST_USER</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_DIST_WELSCH">CV_DIST_WELSCH</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_GAUSSIAN">CV_GAUSSIAN</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_GAUSSIAN_5x5">CV_GAUSSIAN_5x5</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_HOUGH_GRADIENT">CV_HOUGH_GRADIENT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_HOUGH_MULTI_SCALE">CV_HOUGH_MULTI_SCALE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_HOUGH_PROBABILISTIC">CV_HOUGH_PROBABILISTIC</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_HOUGH_STANDARD">CV_HOUGH_STANDARD</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_LINK_RUNS">CV_LINK_RUNS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_MAX_SOBEL_KSIZE">CV_MAX_SOBEL_KSIZE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_MEDIAN">CV_MEDIAN</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_mRGBA2RGBA">CV_mRGBA2RGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_POLY_APPROX_DP">CV_POLY_APPROX_DP</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_RGBA2mRGBA">CV_RGBA2mRGBA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_SCHARR">CV_SCHARR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_SHAPE_CROSS">CV_SHAPE_CROSS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_SHAPE_CUSTOM">CV_SHAPE_CUSTOM</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_SHAPE_ELLIPSE">CV_SHAPE_ELLIPSE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_SHAPE_RECT">CV_SHAPE_RECT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_WARP_FILL_OUTLIERS">CV_WARP_FILL_OUTLIERS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#CV_WARP_INVERSE_MAP">CV_WARP_INVERSE_MAP</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#DIST_LABEL_CCOMP">DIST_LABEL_CCOMP</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#DIST_LABEL_PIXEL">DIST_LABEL_PIXEL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#FLOODFILL_FIXED_RANGE">FLOODFILL_FIXED_RANGE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#FLOODFILL_MASK_ONLY">FLOODFILL_MASK_ONLY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_BGD">GC_BGD</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_EVAL">GC_EVAL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_FGD">GC_FGD</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_INIT_WITH_MASK">GC_INIT_WITH_MASK</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_INIT_WITH_RECT">GC_INIT_WITH_RECT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_PR_BGD">GC_PR_BGD</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GC_PR_FGD">GC_PR_FGD</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GHT_POSITION">GHT_POSITION</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GHT_ROTATION">GHT_ROTATION</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GHT_SCALE">GHT_SCALE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_AREA">INTER_AREA</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_BITS">INTER_BITS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_BITS2">INTER_BITS2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_CUBIC">INTER_CUBIC</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_LANCZOS4">INTER_LANCZOS4</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_LINEAR">INTER_LINEAR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_MAX">INTER_MAX</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_NEAREST">INTER_NEAREST</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_TAB_SIZE">INTER_TAB_SIZE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#INTER_TAB_SIZE2">INTER_TAB_SIZE2</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#KERNEL_ASYMMETRICAL">KERNEL_ASYMMETRICAL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#KERNEL_GENERAL">KERNEL_GENERAL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#KERNEL_INTEGER">KERNEL_INTEGER</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#KERNEL_SMOOTH">KERNEL_SMOOTH</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#KERNEL_SYMMETRICAL">KERNEL_SYMMETRICAL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_BLACKHAT">MORPH_BLACKHAT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_CLOSE">MORPH_CLOSE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_CROSS">MORPH_CROSS</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_DILATE">MORPH_DILATE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_ELLIPSE">MORPH_ELLIPSE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_ERODE">MORPH_ERODE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_GRADIENT">MORPH_GRADIENT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_OPEN">MORPH_OPEN</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_RECT">MORPH_RECT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#MORPH_TOPHAT">MORPH_TOPHAT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#PROJ_SPHERICAL_EQRECT">PROJ_SPHERICAL_EQRECT</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#PROJ_SPHERICAL_ORTHO">PROJ_SPHERICAL_ORTHO</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#RETR_CCOMP">RETR_CCOMP</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#RETR_EXTERNAL">RETR_EXTERNAL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#RETR_FLOODFILL">RETR_FLOODFILL</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#RETR_LIST">RETR_LIST</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#RETR_TREE">RETR_TREE</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_BINARY">THRESH_BINARY</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_BINARY_INV">THRESH_BINARY_INV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_MASK">THRESH_MASK</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_OTSU">THRESH_OTSU</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_TOZERO">THRESH_TOZERO</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_TOZERO_INV">THRESH_TOZERO_INV</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#THRESH_TRUNC">THRESH_TRUNC</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#TM_CCOEFF">TM_CCOEFF</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#TM_CCOEFF_NORMED">TM_CCOEFF_NORMED</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#TM_CCORR">TM_CCORR</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#TM_CCORR_NORMED">TM_CCORR_NORMED</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#TM_SQDIFF">TM_SQDIFF</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#TM_SQDIFF_NORMED">TM_SQDIFF_NORMED</A></B></CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#WARP_INVERSE_MAP">WARP_INVERSE_MAP</A></B></CODE>
<BR>
</TD>
</TR>
</TABLE>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<A NAME="constructor_summary"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
<B>Constructor Summary</B></FONT></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Imgproc()">Imgproc</A></B>()</CODE>
<BR>
</TD>
</TR>
</TABLE>
<!-- ========== METHOD SUMMARY =========== -->
<A NAME="method_summary"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="2"><FONT SIZE="+2">
<B>Method Summary</B></FONT></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulate(org.opencv.core.Mat, org.opencv.core.Mat)">accumulate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Adds an image to the accumulator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">accumulate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</CODE>
<BR>
Adds an image to the accumulator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">accumulateProduct</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Adds the per-element product of two input images to the accumulator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">accumulateProduct</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</CODE>
<BR>
Adds the per-element product of two input images to the accumulator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat)">accumulateSquare</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Adds the square of a source image to the accumulator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">accumulateSquare</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</CODE>
<BR>
Adds the square of a source image to the accumulator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double)">accumulateWeighted</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double alpha)</CODE>
<BR>
Updates a running average.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)">accumulateWeighted</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double alpha,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</CODE>
<BR>
Updates a running average.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#adaptiveThreshold(org.opencv.core.Mat, org.opencv.core.Mat, double, int, int, int, double)">adaptiveThreshold</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double maxValue,
int adaptiveMethod,
int thresholdType,
int blockSize,
double C)</CODE>
<BR>
Applies an adaptive threshold to an array.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#approxPolyDP(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, double, boolean)">approxPolyDP</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> curve,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> approxCurve,
double epsilon,
boolean closed)</CODE>
<BR>
Approximates a polygonal curve(s) with the specified precision.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#arcLength(org.opencv.core.MatOfPoint2f, boolean)">arcLength</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> curve,
boolean closed)</CODE>
<BR>
Calculates a contour perimeter or a curve length.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double)">bilateralFilter</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int d,
double sigmaColor,
double sigmaSpace)</CODE>
<BR>
Applies the bilateral filter to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)">bilateralFilter</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int d,
double sigmaColor,
double sigmaSpace,
int borderType)</CODE>
<BR>
Applies the bilateral filter to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)">blur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize)</CODE>
<BR>
Blurs an image using the normalized box filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point)">blur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor)</CODE>
<BR>
Blurs an image using the normalized box filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)">blur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int borderType)</CODE>
<BR>
Blurs an image using the normalized box filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#borderInterpolate(int, int, int)">borderInterpolate</A></B>(int p,
int len,
int borderType)</CODE>
<BR>
Computes the source location of an extrapolated pixel.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#boundingRect(org.opencv.core.MatOfPoint)">boundingRect</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> points)</CODE>
<BR>
Calculates the up-right bounding rectangle of a point set.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size)">boxFilter</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize)</CODE>
<BR>
Blurs an image using the box filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean)">boxFilter</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
boolean normalize)</CODE>
<BR>
Blurs an image using the box filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)">boxFilter</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
boolean normalize,
int borderType)</CODE>
<BR>
Blurs an image using the box filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#calcBackProject(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfFloat, double)">calcBackProject</A></B>(java.util.List<<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A>> images,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> channels,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hist,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/MatOfFloat.html" title="class in org.opencv.core">MatOfFloat</A> ranges,
double scale)</CODE>
<BR>
Calculates the back projection of a histogram.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#calcHist(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfInt, org.opencv.core.MatOfFloat)">calcHist</A></B>(java.util.List<<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A>> images,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> channels,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hist,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> histSize,
<A HREF="../../../org/opencv/core/MatOfFloat.html" title="class in org.opencv.core">MatOfFloat</A> ranges)</CODE>
<BR>
Calculates a histogram of a set of arrays.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#calcHist(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfInt, org.opencv.core.MatOfFloat, boolean)">calcHist</A></B>(java.util.List<<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A>> images,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> channels,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hist,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> histSize,
<A HREF="../../../org/opencv/core/MatOfFloat.html" title="class in org.opencv.core">MatOfFloat</A> ranges,
boolean accumulate)</CODE>
<BR>
Calculates a histogram of a set of arrays.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Canny(org.opencv.core.Mat, org.opencv.core.Mat, double, double)">Canny</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> edges,
double threshold1,
double threshold2)</CODE>
<BR>
Finds edges in an image using the [Canny86] algorithm.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Canny(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, boolean)">Canny</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> edges,
double threshold1,
double threshold2,
int apertureSize,
boolean L2gradient)</CODE>
<BR>
Finds edges in an image using the [Canny86] algorithm.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#compareHist(org.opencv.core.Mat, org.opencv.core.Mat, int)">compareHist</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> H1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> H2,
int method)</CODE>
<BR>
Compares two histograms.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#contourArea(org.opencv.core.Mat)">contourArea</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour)</CODE>
<BR>
Calculates a contour area.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#contourArea(org.opencv.core.Mat, boolean)">contourArea</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour,
boolean oriented)</CODE>
<BR>
Calculates a contour area.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#convertMaps(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)">convertMaps</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap2,
int dstmap1type)</CODE>
<BR>
Converts image transformation maps from one representation to another.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#convertMaps(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, boolean)">convertMaps</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap2,
int dstmap1type,
boolean nninterpolation)</CODE>
<BR>
Converts image transformation maps from one representation to another.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#convexHull(org.opencv.core.MatOfPoint, org.opencv.core.MatOfInt)">convexHull</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> points,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> hull)</CODE>
<BR>
Finds the convex hull of a point set.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#convexHull(org.opencv.core.MatOfPoint, org.opencv.core.MatOfInt, boolean)">convexHull</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> points,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> hull,
boolean clockwise)</CODE>
<BR>
Finds the convex hull of a point set.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#convexityDefects(org.opencv.core.MatOfPoint, org.opencv.core.MatOfInt, org.opencv.core.MatOfInt4)">convexityDefects</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> contour,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> convexhull,
<A HREF="../../../org/opencv/core/MatOfInt4.html" title="class in org.opencv.core">MatOfInt4</A> convexityDefects)</CODE>
<BR>
Finds the convexity defects of a contour.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#copyMakeBorder(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, int)">copyMakeBorder</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int top,
int bottom,
int left,
int right,
int borderType)</CODE>
<BR>
Forms a border around an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#copyMakeBorder(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, int, org.opencv.core.Scalar)">copyMakeBorder</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int top,
int bottom,
int left,
int right,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> value)</CODE>
<BR>
Forms a border around an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerEigenValsAndVecs(org.opencv.core.Mat, org.opencv.core.Mat, int, int)">cornerEigenValsAndVecs</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize)</CODE>
<BR>
Calculates eigenvalues and eigenvectors of image blocks for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerEigenValsAndVecs(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)">cornerEigenValsAndVecs</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
int borderType)</CODE>
<BR>
Calculates eigenvalues and eigenvectors of image blocks for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double)">cornerHarris</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
double k)</CODE>
<BR>
Harris edge detector.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)">cornerHarris</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
double k,
int borderType)</CODE>
<BR>
Harris edge detector.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int)">cornerMinEigenVal</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize)</CODE>
<BR>
Calculates the minimal eigenvalue of gradient matrices for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int)">cornerMinEigenVal</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize)</CODE>
<BR>
Calculates the minimal eigenvalue of gradient matrices for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)">cornerMinEigenVal</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
int borderType)</CODE>
<BR>
Calculates the minimal eigenvalue of gradient matrices for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerSubPix(org.opencv.core.Mat, org.opencv.core.MatOfPoint2f, org.opencv.core.Size, org.opencv.core.Size, org.opencv.core.TermCriteria)">cornerSubPix</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> corners,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> winSize,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> zeroZone,
<A HREF="../../../org/opencv/core/TermCriteria.html" title="class in org.opencv.core">TermCriteria</A> criteria)</CODE>
<BR>
Refines the corner locations.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#createHanningWindow(org.opencv.core.Mat, org.opencv.core.Size, int)">createHanningWindow</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> winSize,
int type)</CODE>
<BR>
This function computes a Hanning window coefficients in two dimensions.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cvtColor(org.opencv.core.Mat, org.opencv.core.Mat, int)">cvtColor</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int code)</CODE>
<BR>
Converts an image from one color space to another.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#cvtColor(org.opencv.core.Mat, org.opencv.core.Mat, int, int)">cvtColor</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int code,
int dstCn)</CODE>
<BR>
Converts an image from one color space to another.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">dilate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</CODE>
<BR>
Dilates an image by using a specific structuring element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int)">dilate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations)</CODE>
<BR>
Dilates an image by using a specific structuring element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)">dilate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</CODE>
<BR>
Dilates an image by using a specific structuring element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#distanceTransform(org.opencv.core.Mat, org.opencv.core.Mat, int, int)">distanceTransform</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int distanceType,
int maskSize)</CODE>
<BR>
Calculates the distance to the closest zero pixel for each pixel of the
source image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#distanceTransformWithLabels(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int)">distanceTransformWithLabels</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> labels,
int distanceType,
int maskSize)</CODE>
<BR>
Calculates the distance to the closest zero pixel for each pixel of the
source image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#distanceTransformWithLabels(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)">distanceTransformWithLabels</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> labels,
int distanceType,
int maskSize,
int labelType)</CODE>
<BR>
Calculates the distance to the closest zero pixel for each pixel of the
source image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#drawContours(org.opencv.core.Mat, java.util.List, int, org.opencv.core.Scalar)">drawContours</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
int contourIdx,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> color)</CODE>
<BR>
Draws contours outlines or filled contours.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#drawContours(org.opencv.core.Mat, java.util.List, int, org.opencv.core.Scalar, int)">drawContours</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
int contourIdx,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> color,
int thickness)</CODE>
<BR>
Draws contours outlines or filled contours.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#drawContours(org.opencv.core.Mat, java.util.List, int, org.opencv.core.Scalar, int, int, org.opencv.core.Mat, int, org.opencv.core.Point)">drawContours</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
int contourIdx,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> color,
int thickness,
int lineType,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hierarchy,
int maxLevel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> offset)</CODE>
<BR>
Draws contours outlines or filled contours.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#equalizeHist(org.opencv.core.Mat, org.opencv.core.Mat)">equalizeHist</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Equalizes the histogram of a grayscale image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">erode</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</CODE>
<BR>
Erodes an image by using a specific structuring element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int)">erode</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations)</CODE>
<BR>
Erodes an image by using a specific structuring element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)">erode</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</CODE>
<BR>
Erodes an image by using a specific structuring element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat)">filter2D</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</CODE>
<BR>
Convolves an image with the kernel.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double)">filter2D</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta)</CODE>
<BR>
Convolves an image with the kernel.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)">filter2D</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta,
int borderType)</CODE>
<BR>
Convolves an image with the kernel.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int)">findContours</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hierarchy,
int mode,
int method)</CODE>
<BR>
Finds contours in a binary image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int, org.opencv.core.Point)">findContours</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hierarchy,
int mode,
int method,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> offset)</CODE>
<BR>
Finds contours in a binary image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/RotatedRect.html" title="class in org.opencv.core">RotatedRect</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#fitEllipse(org.opencv.core.MatOfPoint2f)">fitEllipse</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> points)</CODE>
<BR>
Fits an ellipse around a set of 2D points.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#fitLine(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, double)">fitLine</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> points,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> line,
int distType,
double param,
double reps,
double aeps)</CODE>
<BR>
Fits a line to a 2D or 3D point set.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#floodFill(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, org.opencv.core.Scalar)">floodFill</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> seedPoint,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> newVal)</CODE>
<BR>
Fills a connected component with the given color.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static int</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#floodFill(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, org.opencv.core.Scalar, org.opencv.core.Rect, org.opencv.core.Scalar, org.opencv.core.Scalar, int)">floodFill</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> seedPoint,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> newVal,
<A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> rect,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> loDiff,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> upDiff,
int flags)</CODE>
<BR>
Fills a connected component with the given color.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double)">GaussianBlur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigmaX)</CODE>
<BR>
Blurs an image using a Gaussian filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double)">GaussianBlur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigmaX,
double sigmaY)</CODE>
<BR>
Blurs an image using a Gaussian filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)">GaussianBlur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigmaX,
double sigmaY,
int borderType)</CODE>
<BR>
Blurs an image using a Gaussian filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getAffineTransform(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f)">getAffineTransform</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> src,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> dst)</CODE>
<BR>
Calculates an affine transform from three pairs of the corresponding points.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getDefaultNewCameraMatrix(org.opencv.core.Mat)">getDefaultNewCameraMatrix</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix)</CODE>
<BR>
Returns the default new camera matrix.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getDefaultNewCameraMatrix(org.opencv.core.Mat, org.opencv.core.Size, boolean)">getDefaultNewCameraMatrix</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> imgsize,
boolean centerPrincipalPoint)</CODE>
<BR>
Returns the default new camera matrix.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)">getDerivKernels</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kx,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> ky,
int dx,
int dy,
int ksize)</CODE>
<BR>
Returns filter coefficients for computing spatial image derivatives.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, boolean, int)">getDerivKernels</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kx,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> ky,
int dx,
int dy,
int ksize,
boolean normalize,
int ktype)</CODE>
<BR>
Returns filter coefficients for computing spatial image derivatives.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getGaborKernel(org.opencv.core.Size, double, double, double, double)">getGaborKernel</A></B>(<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigma,
double theta,
double lambd,
double gamma)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getGaborKernel(org.opencv.core.Size, double, double, double, double, double, int)">getGaborKernel</A></B>(<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigma,
double theta,
double lambd,
double gamma,
double psi,
int ktype)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getGaussianKernel(int, double)">getGaussianKernel</A></B>(int ksize,
double sigma)</CODE>
<BR>
Returns Gaussian filter coefficients.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getGaussianKernel(int, double, int)">getGaussianKernel</A></B>(int ksize,
double sigma,
int ktype)</CODE>
<BR>
Returns Gaussian filter coefficients.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getPerspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat)">getPerspectiveTransform</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Calculates a perspective transform from four pairs of the corresponding
points.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat)">getRectSubPix</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> patchSize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> patch)</CODE>
<BR>
Retrieves a pixel rectangle from an image with sub-pixel accuracy.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)">getRectSubPix</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> patchSize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> patch,
int patchType)</CODE>
<BR>
Retrieves a pixel rectangle from an image with sub-pixel accuracy.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getRotationMatrix2D(org.opencv.core.Point, double, double)">getRotationMatrix2D</A></B>(<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
double angle,
double scale)</CODE>
<BR>
Calculates an affine matrix of 2D rotation.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getStructuringElement(int, org.opencv.core.Size)">getStructuringElement</A></B>(int shape,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize)</CODE>
<BR>
Returns a structuring element of the specified size and shape for
morphological operations.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#getStructuringElement(int, org.opencv.core.Size, org.opencv.core.Point)">getStructuringElement</A></B>(int shape,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor)</CODE>
<BR>
Returns a structuring element of the specified size and shape for
morphological operations.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#goodFeaturesToTrack(org.opencv.core.Mat, org.opencv.core.MatOfPoint, int, double, double)">goodFeaturesToTrack</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> corners,
int maxCorners,
double qualityLevel,
double minDistance)</CODE>
<BR>
Determines strong corners on an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#goodFeaturesToTrack(org.opencv.core.Mat, org.opencv.core.MatOfPoint, int, double, double, org.opencv.core.Mat, int, boolean, double)">goodFeaturesToTrack</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> corners,
int maxCorners,
double qualityLevel,
double minDistance,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
int blockSize,
boolean useHarrisDetector,
double k)</CODE>
<BR>
Determines strong corners on an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#grabCut(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Rect, org.opencv.core.Mat, org.opencv.core.Mat, int)">grabCut</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> img,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> rect,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> bgdModel,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> fgdModel,
int iterCount)</CODE>
<BR>
Runs the GrabCut algorithm.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#grabCut(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Rect, org.opencv.core.Mat, org.opencv.core.Mat, int, int)">grabCut</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> img,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> rect,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> bgdModel,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> fgdModel,
int iterCount,
int mode)</CODE>
<BR>
Runs the GrabCut algorithm.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HoughCircles(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double)">HoughCircles</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> circles,
int method,
double dp,
double minDist)</CODE>
<BR>
Finds circles in a grayscale image using the Hough transform.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HoughCircles(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, double, double, int, int)">HoughCircles</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> circles,
int method,
double dp,
double minDist,
double param1,
double param2,
int minRadius,
int maxRadius)</CODE>
<BR>
Finds circles in a grayscale image using the Hough transform.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HoughLines(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)">HoughLines</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold)</CODE>
<BR>
Finds lines in a binary image using the standard Hough transform.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HoughLines(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, double, double)">HoughLines</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold,
double srn,
double stn)</CODE>
<BR>
Finds lines in a binary image using the standard Hough transform.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HoughLinesP(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)">HoughLinesP</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold)</CODE>
<BR>
Finds line segments in a binary image using the probabilistic Hough
transform.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HoughLinesP(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, double, double)">HoughLinesP</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold,
double minLineLength,
double maxLineGap)</CODE>
<BR>
Finds line segments in a binary image using the probabilistic Hough
transform.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#HuMoments(org.opencv.imgproc.Moments, org.opencv.core.Mat)">HuMoments</A></B>(<A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc">Moments</A> m,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hu)</CODE>
<BR>
Calculates seven Hu invariants.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#initUndistortRectifyMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, org.opencv.core.Mat, org.opencv.core.Mat)">initUndistortRectifyMap</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> R,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> newCameraMatrix,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> size,
int m1type,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2)</CODE>
<BR>
Computes the undistortion and rectification transformation map.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static float</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#initWideAngleProjMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Mat, org.opencv.core.Mat)">initWideAngleProjMap</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> imageSize,
int destImageWidth,
int m1type,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static float</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#initWideAngleProjMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Mat, org.opencv.core.Mat, int, double)">initWideAngleProjMap</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> imageSize,
int destImageWidth,
int m1type,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
int projType,
double alpha)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#integral(org.opencv.core.Mat, org.opencv.core.Mat)">integral</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum)</CODE>
<BR>
Calculates the integral of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#integral(org.opencv.core.Mat, org.opencv.core.Mat, int)">integral</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
int sdepth)</CODE>
<BR>
Calculates the integral of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#integral2(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">integral2</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum)</CODE>
<BR>
Calculates the integral of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#integral2(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)">integral2</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum,
int sdepth)</CODE>
<BR>
Calculates the integral of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#integral3(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">integral3</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> tilted)</CODE>
<BR>
Calculates the integral of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#integral3(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)">integral3</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> tilted,
int sdepth)</CODE>
<BR>
Calculates the integral of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static float</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#intersectConvexConvex(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">intersectConvexConvex</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p12)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static float</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#intersectConvexConvex(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)">intersectConvexConvex</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p12,
boolean handleNested)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#invertAffineTransform(org.opencv.core.Mat, org.opencv.core.Mat)">invertAffineTransform</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> iM)</CODE>
<BR>
Inverts an affine transformation.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static boolean</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#isContourConvex(org.opencv.core.MatOfPoint)">isContourConvex</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> contour)</CODE>
<BR>
Tests a contour convexity.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int)">Laplacian</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth)</CODE>
<BR>
Calculates the Laplacian of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double)">Laplacian</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int ksize,
double scale,
double delta)</CODE>
<BR>
Calculates the Laplacian of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)">Laplacian</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int ksize,
double scale,
double delta,
int borderType)</CODE>
<BR>
Calculates the Laplacian of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#matchShapes(org.opencv.core.Mat, org.opencv.core.Mat, int, double)">matchShapes</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour2,
int method,
double parameter)</CODE>
<BR>
Compares two shapes.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)">matchTemplate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> templ,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> result,
int method)</CODE>
<BR>
Compares a template against overlapped image regions.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)">medianBlur</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ksize)</CODE>
<BR>
Blurs an image using the median filter.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/RotatedRect.html" title="class in org.opencv.core">RotatedRect</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#minAreaRect(org.opencv.core.MatOfPoint2f)">minAreaRect</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> points)</CODE>
<BR>
Finds a rotated rectangle of the minimum area enclosing the input 2D point
set.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#minEnclosingCircle(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, float[])">minEnclosingCircle</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> points,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
float[] radius)</CODE>
<BR>
Finds a circle of the minimum area enclosing a 2D point set.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc">Moments</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#moments(org.opencv.core.Mat)">moments</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> array)</CODE>
<BR>
Calculates all of the moments up to the third order of a polygon or
rasterized shape.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc">Moments</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#moments(org.opencv.core.Mat, boolean)">moments</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> array,
boolean binaryImage)</CODE>
<BR>
Calculates all of the moments up to the third order of a polygon or
rasterized shape.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat)">morphologyEx</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int op,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</CODE>
<BR>
Performs advanced morphological transformations.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int)">morphologyEx</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int op,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations)</CODE>
<BR>
Performs advanced morphological transformations.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)">morphologyEx</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int op,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</CODE>
<BR>
Performs advanced morphological transformations.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#phaseCorrelate(org.opencv.core.Mat, org.opencv.core.Mat)">phaseCorrelate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2)</CODE>
<BR>
The function is used to detect translational shifts that occur between two
images.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#phaseCorrelate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">phaseCorrelate</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> window)</CODE>
<BR>
The function is used to detect translational shifts that occur between two
images.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#phaseCorrelateRes(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">phaseCorrelateRes</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> window)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A></CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#phaseCorrelateRes(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, double[])">phaseCorrelateRes</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> window,
double[] response)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pointPolygonTest(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, boolean)">pointPolygonTest</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> contour,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> pt,
boolean measureDist)</CODE>
<BR>
Performs a point-in-contour test.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int)">preCornerDetect</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ksize)</CODE>
<BR>
Calculates a feature map for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int, int)">preCornerDetect</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ksize,
int borderType)</CODE>
<BR>
Calculates a feature map for corner detection.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#PSNR(org.opencv.core.Mat, org.opencv.core.Mat)">PSNR</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2)</CODE>
<BR>
</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrDown(org.opencv.core.Mat, org.opencv.core.Mat)">pyrDown</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Blurs an image and downsamples it.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrDown(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)">pyrDown</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize)</CODE>
<BR>
Blurs an image and downsamples it.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrDown(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)">pyrDown</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize,
int borderType)</CODE>
<BR>
Blurs an image and downsamples it.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrMeanShiftFiltering(org.opencv.core.Mat, org.opencv.core.Mat, double, double)">pyrMeanShiftFiltering</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double sp,
double sr)</CODE>
<BR>
Performs initial step of meanshift segmentation of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrMeanShiftFiltering(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, org.opencv.core.TermCriteria)">pyrMeanShiftFiltering</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double sp,
double sr,
int maxLevel,
<A HREF="../../../org/opencv/core/TermCriteria.html" title="class in org.opencv.core">TermCriteria</A> termcrit)</CODE>
<BR>
Performs initial step of meanshift segmentation of an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrUp(org.opencv.core.Mat, org.opencv.core.Mat)">pyrUp</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</CODE>
<BR>
Upsamples an image and then blurs it.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrUp(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)">pyrUp</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize)</CODE>
<BR>
Upsamples an image and then blurs it.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#pyrUp(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)">pyrUp</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize,
int borderType)</CODE>
<BR>
Upsamples an image and then blurs it.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)">remap</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
int interpolation)</CODE>
<BR>
Applies a generic geometrical transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)">remap</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
int interpolation,
int borderMode,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</CODE>
<BR>
Applies a generic geometrical transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)">resize</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize)</CODE>
<BR>
Resizes an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)">resize</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
double fx,
double fy,
int interpolation)</CODE>
<BR>
Resizes an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)">Scharr</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy)</CODE>
<BR>
Calculates the first x- or y- image derivative using Scharr operator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double)">Scharr</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
double scale,
double delta)</CODE>
<BR>
Calculates the first x- or y- image derivative using Scharr operator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)">Scharr</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
double scale,
double delta,
int borderType)</CODE>
<BR>
Calculates the first x- or y- image derivative using Scharr operator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat)">sepFilter2D</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelX,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelY)</CODE>
<BR>
Applies a separable linear filter to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double)">sepFilter2D</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelX,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelY,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta)</CODE>
<BR>
Applies a separable linear filter to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)">sepFilter2D</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelX,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelY,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta,
int borderType)</CODE>
<BR>
Applies a separable linear filter to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)">Sobel</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy)</CODE>
<BR>
Calculates the first, second, third, or mixed image derivatives using an
extended Sobel operator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double)">Sobel</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
int ksize,
double scale,
double delta)</CODE>
<BR>
Calculates the first, second, third, or mixed image derivatives using an
extended Sobel operator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)">Sobel</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
int ksize,
double scale,
double delta,
int borderType)</CODE>
<BR>
Calculates the first, second, third, or mixed image derivatives using an
extended Sobel operator.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static double</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#threshold(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)">threshold</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double thresh,
double maxval,
int type)</CODE>
<BR>
Applies a fixed-level threshold to each array element.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">undistort</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs)</CODE>
<BR>
Transforms an image to compensate for lens distortion.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">undistort</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> newCameraMatrix)</CODE>
<BR>
Transforms an image to compensate for lens distortion.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#undistortPoints(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.Mat, org.opencv.core.Mat)">undistortPoints</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> src,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs)</CODE>
<BR>
Computes the ideal point coordinates from the observed point coordinates.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#undistortPoints(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)">undistortPoints</A></B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> src,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> R,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> P)</CODE>
<BR>
Computes the ideal point coordinates from the observed point coordinates.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)">warpAffine</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize)</CODE>
<BR>
Applies an affine transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)">warpAffine</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags)</CODE>
<BR>
Applies an affine transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)">warpAffine</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags,
int borderMode,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</CODE>
<BR>
Applies an affine transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)">warpPerspective</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize)</CODE>
<BR>
Applies a perspective transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)">warpPerspective</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags)</CODE>
<BR>
Applies a perspective transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)">warpPerspective</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags,
int borderMode,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</CODE>
<BR>
Applies a perspective transformation to an image.</TD>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD ALIGN="right" VALIGN="top" WIDTH="1%"><FONT SIZE="-1">
<CODE>static void</CODE></FONT></TD>
<TD><CODE><B><A HREF="../../../org/opencv/imgproc/Imgproc.html#watershed(org.opencv.core.Mat, org.opencv.core.Mat)">watershed</A></B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> markers)</CODE>
<BR>
Performs a marker-based image segmentation using the watershed algorithm.</TD>
</TR>
</TABLE>
<A NAME="methods_inherited_from_class_java.lang.Object"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#EEEEFF" CLASS="TableSubHeadingColor">
<TH ALIGN="left"><B>Methods inherited from class java.lang.Object</B></TH>
</TR>
<TR BGCOLOR="white" CLASS="TableRowColor">
<TD><CODE>equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</CODE></TD>
</TR>
</TABLE>
<P>
<!-- ============ FIELD DETAIL =========== -->
<A NAME="field_detail"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="1"><FONT SIZE="+2">
<B>Field Detail</B></FONT></TH>
</TR>
</TABLE>
<A NAME="ADAPTIVE_THRESH_GAUSSIAN_C"><!-- --></A><H3>
ADAPTIVE_THRESH_GAUSSIAN_C</H3>
<PRE>
public static final int <B>ADAPTIVE_THRESH_GAUSSIAN_C</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="ADAPTIVE_THRESH_MEAN_C"><!-- --></A><H3>
ADAPTIVE_THRESH_MEAN_C</H3>
<PRE>
public static final int <B>ADAPTIVE_THRESH_MEAN_C</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.ADAPTIVE_THRESH_MEAN_C">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_CONSTANT"><!-- --></A><H3>
BORDER_CONSTANT</H3>
<PRE>
public static final int <B>BORDER_CONSTANT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_CONSTANT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_DEFAULT"><!-- --></A><H3>
BORDER_DEFAULT</H3>
<PRE>
public static final int <B>BORDER_DEFAULT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_DEFAULT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_ISOLATED"><!-- --></A><H3>
BORDER_ISOLATED</H3>
<PRE>
public static final int <B>BORDER_ISOLATED</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_ISOLATED">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_REFLECT"><!-- --></A><H3>
BORDER_REFLECT</H3>
<PRE>
public static final int <B>BORDER_REFLECT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_REFLECT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_REFLECT_101"><!-- --></A><H3>
BORDER_REFLECT_101</H3>
<PRE>
public static final int <B>BORDER_REFLECT_101</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_REFLECT_101">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_REFLECT101"><!-- --></A><H3>
BORDER_REFLECT101</H3>
<PRE>
public static final int <B>BORDER_REFLECT101</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_REFLECT101">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_REPLICATE"><!-- --></A><H3>
BORDER_REPLICATE</H3>
<PRE>
public static final int <B>BORDER_REPLICATE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_REPLICATE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_TRANSPARENT"><!-- --></A><H3>
BORDER_TRANSPARENT</H3>
<PRE>
public static final int <B>BORDER_TRANSPARENT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_TRANSPARENT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="BORDER_WRAP"><!-- --></A><H3>
BORDER_WRAP</H3>
<PRE>
public static final int <B>BORDER_WRAP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.BORDER_WRAP">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CHAIN_APPROX_NONE"><!-- --></A><H3>
CHAIN_APPROX_NONE</H3>
<PRE>
public static final int <B>CHAIN_APPROX_NONE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CHAIN_APPROX_NONE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CHAIN_APPROX_SIMPLE"><!-- --></A><H3>
CHAIN_APPROX_SIMPLE</H3>
<PRE>
public static final int <B>CHAIN_APPROX_SIMPLE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CHAIN_APPROX_SIMPLE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CHAIN_APPROX_TC89_KCOS"><!-- --></A><H3>
CHAIN_APPROX_TC89_KCOS</H3>
<PRE>
public static final int <B>CHAIN_APPROX_TC89_KCOS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CHAIN_APPROX_TC89_KCOS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CHAIN_APPROX_TC89_L1"><!-- --></A><H3>
CHAIN_APPROX_TC89_L1</H3>
<PRE>
public static final int <B>CHAIN_APPROX_TC89_L1</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CHAIN_APPROX_TC89_L1">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerBG2BGR"><!-- --></A><H3>
COLOR_BayerBG2BGR</H3>
<PRE>
public static final int <B>COLOR_BayerBG2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerBG2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerBG2BGR_VNG"><!-- --></A><H3>
COLOR_BayerBG2BGR_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerBG2BGR_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerBG2BGR_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerBG2GRAY"><!-- --></A><H3>
COLOR_BayerBG2GRAY</H3>
<PRE>
public static final int <B>COLOR_BayerBG2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerBG2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerBG2RGB"><!-- --></A><H3>
COLOR_BayerBG2RGB</H3>
<PRE>
public static final int <B>COLOR_BayerBG2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerBG2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerBG2RGB_VNG"><!-- --></A><H3>
COLOR_BayerBG2RGB_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerBG2RGB_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerBG2RGB_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGB2BGR"><!-- --></A><H3>
COLOR_BayerGB2BGR</H3>
<PRE>
public static final int <B>COLOR_BayerGB2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGB2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGB2BGR_VNG"><!-- --></A><H3>
COLOR_BayerGB2BGR_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerGB2BGR_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGB2BGR_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGB2GRAY"><!-- --></A><H3>
COLOR_BayerGB2GRAY</H3>
<PRE>
public static final int <B>COLOR_BayerGB2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGB2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGB2RGB"><!-- --></A><H3>
COLOR_BayerGB2RGB</H3>
<PRE>
public static final int <B>COLOR_BayerGB2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGB2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGB2RGB_VNG"><!-- --></A><H3>
COLOR_BayerGB2RGB_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerGB2RGB_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGB2RGB_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGR2BGR"><!-- --></A><H3>
COLOR_BayerGR2BGR</H3>
<PRE>
public static final int <B>COLOR_BayerGR2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGR2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGR2BGR_VNG"><!-- --></A><H3>
COLOR_BayerGR2BGR_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerGR2BGR_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGR2BGR_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGR2GRAY"><!-- --></A><H3>
COLOR_BayerGR2GRAY</H3>
<PRE>
public static final int <B>COLOR_BayerGR2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGR2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGR2RGB"><!-- --></A><H3>
COLOR_BayerGR2RGB</H3>
<PRE>
public static final int <B>COLOR_BayerGR2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGR2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerGR2RGB_VNG"><!-- --></A><H3>
COLOR_BayerGR2RGB_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerGR2RGB_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerGR2RGB_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerRG2BGR"><!-- --></A><H3>
COLOR_BayerRG2BGR</H3>
<PRE>
public static final int <B>COLOR_BayerRG2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerRG2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerRG2BGR_VNG"><!-- --></A><H3>
COLOR_BayerRG2BGR_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerRG2BGR_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerRG2BGR_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerRG2GRAY"><!-- --></A><H3>
COLOR_BayerRG2GRAY</H3>
<PRE>
public static final int <B>COLOR_BayerRG2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerRG2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerRG2RGB"><!-- --></A><H3>
COLOR_BayerRG2RGB</H3>
<PRE>
public static final int <B>COLOR_BayerRG2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerRG2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BayerRG2RGB_VNG"><!-- --></A><H3>
COLOR_BayerRG2RGB_VNG</H3>
<PRE>
public static final int <B>COLOR_BayerRG2RGB_VNG</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BayerRG2RGB_VNG">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2BGR555"><!-- --></A><H3>
COLOR_BGR2BGR555</H3>
<PRE>
public static final int <B>COLOR_BGR2BGR555</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2BGR555">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2BGR565"><!-- --></A><H3>
COLOR_BGR2BGR565</H3>
<PRE>
public static final int <B>COLOR_BGR2BGR565</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2BGR565">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2BGRA"><!-- --></A><H3>
COLOR_BGR2BGRA</H3>
<PRE>
public static final int <B>COLOR_BGR2BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2GRAY"><!-- --></A><H3>
COLOR_BGR2GRAY</H3>
<PRE>
public static final int <B>COLOR_BGR2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2HLS"><!-- --></A><H3>
COLOR_BGR2HLS</H3>
<PRE>
public static final int <B>COLOR_BGR2HLS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2HLS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2HLS_FULL"><!-- --></A><H3>
COLOR_BGR2HLS_FULL</H3>
<PRE>
public static final int <B>COLOR_BGR2HLS_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2HLS_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2HSV"><!-- --></A><H3>
COLOR_BGR2HSV</H3>
<PRE>
public static final int <B>COLOR_BGR2HSV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2HSV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2HSV_FULL"><!-- --></A><H3>
COLOR_BGR2HSV_FULL</H3>
<PRE>
public static final int <B>COLOR_BGR2HSV_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2HSV_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2Lab"><!-- --></A><H3>
COLOR_BGR2Lab</H3>
<PRE>
public static final int <B>COLOR_BGR2Lab</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2Lab">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2Luv"><!-- --></A><H3>
COLOR_BGR2Luv</H3>
<PRE>
public static final int <B>COLOR_BGR2Luv</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2Luv">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2RGB"><!-- --></A><H3>
COLOR_BGR2RGB</H3>
<PRE>
public static final int <B>COLOR_BGR2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2RGBA"><!-- --></A><H3>
COLOR_BGR2RGBA</H3>
<PRE>
public static final int <B>COLOR_BGR2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2XYZ"><!-- --></A><H3>
COLOR_BGR2XYZ</H3>
<PRE>
public static final int <B>COLOR_BGR2XYZ</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2XYZ">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2YCrCb"><!-- --></A><H3>
COLOR_BGR2YCrCb</H3>
<PRE>
public static final int <B>COLOR_BGR2YCrCb</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2YCrCb">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR2YUV"><!-- --></A><H3>
COLOR_BGR2YUV</H3>
<PRE>
public static final int <B>COLOR_BGR2YUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR2YUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5552BGR"><!-- --></A><H3>
COLOR_BGR5552BGR</H3>
<PRE>
public static final int <B>COLOR_BGR5552BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5552BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5552BGRA"><!-- --></A><H3>
COLOR_BGR5552BGRA</H3>
<PRE>
public static final int <B>COLOR_BGR5552BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5552BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5552GRAY"><!-- --></A><H3>
COLOR_BGR5552GRAY</H3>
<PRE>
public static final int <B>COLOR_BGR5552GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5552GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5552RGB"><!-- --></A><H3>
COLOR_BGR5552RGB</H3>
<PRE>
public static final int <B>COLOR_BGR5552RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5552RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5552RGBA"><!-- --></A><H3>
COLOR_BGR5552RGBA</H3>
<PRE>
public static final int <B>COLOR_BGR5552RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5552RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5652BGR"><!-- --></A><H3>
COLOR_BGR5652BGR</H3>
<PRE>
public static final int <B>COLOR_BGR5652BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5652BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5652BGRA"><!-- --></A><H3>
COLOR_BGR5652BGRA</H3>
<PRE>
public static final int <B>COLOR_BGR5652BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5652BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5652GRAY"><!-- --></A><H3>
COLOR_BGR5652GRAY</H3>
<PRE>
public static final int <B>COLOR_BGR5652GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5652GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5652RGB"><!-- --></A><H3>
COLOR_BGR5652RGB</H3>
<PRE>
public static final int <B>COLOR_BGR5652RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5652RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGR5652RGBA"><!-- --></A><H3>
COLOR_BGR5652RGBA</H3>
<PRE>
public static final int <B>COLOR_BGR5652RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGR5652RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGRA2BGR"><!-- --></A><H3>
COLOR_BGRA2BGR</H3>
<PRE>
public static final int <B>COLOR_BGRA2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGRA2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGRA2BGR555"><!-- --></A><H3>
COLOR_BGRA2BGR555</H3>
<PRE>
public static final int <B>COLOR_BGRA2BGR555</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGRA2BGR555">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGRA2BGR565"><!-- --></A><H3>
COLOR_BGRA2BGR565</H3>
<PRE>
public static final int <B>COLOR_BGRA2BGR565</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGRA2BGR565">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGRA2GRAY"><!-- --></A><H3>
COLOR_BGRA2GRAY</H3>
<PRE>
public static final int <B>COLOR_BGRA2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGRA2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGRA2RGB"><!-- --></A><H3>
COLOR_BGRA2RGB</H3>
<PRE>
public static final int <B>COLOR_BGRA2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGRA2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_BGRA2RGBA"><!-- --></A><H3>
COLOR_BGRA2RGBA</H3>
<PRE>
public static final int <B>COLOR_BGRA2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_BGRA2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_COLORCVT_MAX"><!-- --></A><H3>
COLOR_COLORCVT_MAX</H3>
<PRE>
public static final int <B>COLOR_COLORCVT_MAX</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_COLORCVT_MAX">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_GRAY2BGR"><!-- --></A><H3>
COLOR_GRAY2BGR</H3>
<PRE>
public static final int <B>COLOR_GRAY2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_GRAY2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_GRAY2BGR555"><!-- --></A><H3>
COLOR_GRAY2BGR555</H3>
<PRE>
public static final int <B>COLOR_GRAY2BGR555</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_GRAY2BGR555">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_GRAY2BGR565"><!-- --></A><H3>
COLOR_GRAY2BGR565</H3>
<PRE>
public static final int <B>COLOR_GRAY2BGR565</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_GRAY2BGR565">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_GRAY2BGRA"><!-- --></A><H3>
COLOR_GRAY2BGRA</H3>
<PRE>
public static final int <B>COLOR_GRAY2BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_GRAY2BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_GRAY2RGB"><!-- --></A><H3>
COLOR_GRAY2RGB</H3>
<PRE>
public static final int <B>COLOR_GRAY2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_GRAY2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_GRAY2RGBA"><!-- --></A><H3>
COLOR_GRAY2RGBA</H3>
<PRE>
public static final int <B>COLOR_GRAY2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_GRAY2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HLS2BGR"><!-- --></A><H3>
COLOR_HLS2BGR</H3>
<PRE>
public static final int <B>COLOR_HLS2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HLS2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HLS2BGR_FULL"><!-- --></A><H3>
COLOR_HLS2BGR_FULL</H3>
<PRE>
public static final int <B>COLOR_HLS2BGR_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HLS2BGR_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HLS2RGB"><!-- --></A><H3>
COLOR_HLS2RGB</H3>
<PRE>
public static final int <B>COLOR_HLS2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HLS2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HLS2RGB_FULL"><!-- --></A><H3>
COLOR_HLS2RGB_FULL</H3>
<PRE>
public static final int <B>COLOR_HLS2RGB_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HLS2RGB_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HSV2BGR"><!-- --></A><H3>
COLOR_HSV2BGR</H3>
<PRE>
public static final int <B>COLOR_HSV2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HSV2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HSV2BGR_FULL"><!-- --></A><H3>
COLOR_HSV2BGR_FULL</H3>
<PRE>
public static final int <B>COLOR_HSV2BGR_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HSV2BGR_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HSV2RGB"><!-- --></A><H3>
COLOR_HSV2RGB</H3>
<PRE>
public static final int <B>COLOR_HSV2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HSV2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_HSV2RGB_FULL"><!-- --></A><H3>
COLOR_HSV2RGB_FULL</H3>
<PRE>
public static final int <B>COLOR_HSV2RGB_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_HSV2RGB_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Lab2BGR"><!-- --></A><H3>
COLOR_Lab2BGR</H3>
<PRE>
public static final int <B>COLOR_Lab2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Lab2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Lab2LBGR"><!-- --></A><H3>
COLOR_Lab2LBGR</H3>
<PRE>
public static final int <B>COLOR_Lab2LBGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Lab2LBGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Lab2LRGB"><!-- --></A><H3>
COLOR_Lab2LRGB</H3>
<PRE>
public static final int <B>COLOR_Lab2LRGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Lab2LRGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Lab2RGB"><!-- --></A><H3>
COLOR_Lab2RGB</H3>
<PRE>
public static final int <B>COLOR_Lab2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Lab2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_LBGR2Lab"><!-- --></A><H3>
COLOR_LBGR2Lab</H3>
<PRE>
public static final int <B>COLOR_LBGR2Lab</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_LBGR2Lab">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_LBGR2Luv"><!-- --></A><H3>
COLOR_LBGR2Luv</H3>
<PRE>
public static final int <B>COLOR_LBGR2Luv</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_LBGR2Luv">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_LRGB2Lab"><!-- --></A><H3>
COLOR_LRGB2Lab</H3>
<PRE>
public static final int <B>COLOR_LRGB2Lab</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_LRGB2Lab">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_LRGB2Luv"><!-- --></A><H3>
COLOR_LRGB2Luv</H3>
<PRE>
public static final int <B>COLOR_LRGB2Luv</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_LRGB2Luv">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Luv2BGR"><!-- --></A><H3>
COLOR_Luv2BGR</H3>
<PRE>
public static final int <B>COLOR_Luv2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Luv2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Luv2LBGR"><!-- --></A><H3>
COLOR_Luv2LBGR</H3>
<PRE>
public static final int <B>COLOR_Luv2LBGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Luv2LBGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Luv2LRGB"><!-- --></A><H3>
COLOR_Luv2LRGB</H3>
<PRE>
public static final int <B>COLOR_Luv2LRGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Luv2LRGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_Luv2RGB"><!-- --></A><H3>
COLOR_Luv2RGB</H3>
<PRE>
public static final int <B>COLOR_Luv2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_Luv2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_mRGBA2RGBA"><!-- --></A><H3>
COLOR_mRGBA2RGBA</H3>
<PRE>
public static final int <B>COLOR_mRGBA2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_mRGBA2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2BGR"><!-- --></A><H3>
COLOR_RGB2BGR</H3>
<PRE>
public static final int <B>COLOR_RGB2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2BGR555"><!-- --></A><H3>
COLOR_RGB2BGR555</H3>
<PRE>
public static final int <B>COLOR_RGB2BGR555</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2BGR555">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2BGR565"><!-- --></A><H3>
COLOR_RGB2BGR565</H3>
<PRE>
public static final int <B>COLOR_RGB2BGR565</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2BGR565">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2BGRA"><!-- --></A><H3>
COLOR_RGB2BGRA</H3>
<PRE>
public static final int <B>COLOR_RGB2BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2GRAY"><!-- --></A><H3>
COLOR_RGB2GRAY</H3>
<PRE>
public static final int <B>COLOR_RGB2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2HLS"><!-- --></A><H3>
COLOR_RGB2HLS</H3>
<PRE>
public static final int <B>COLOR_RGB2HLS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2HLS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2HLS_FULL"><!-- --></A><H3>
COLOR_RGB2HLS_FULL</H3>
<PRE>
public static final int <B>COLOR_RGB2HLS_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2HLS_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2HSV"><!-- --></A><H3>
COLOR_RGB2HSV</H3>
<PRE>
public static final int <B>COLOR_RGB2HSV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2HSV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2HSV_FULL"><!-- --></A><H3>
COLOR_RGB2HSV_FULL</H3>
<PRE>
public static final int <B>COLOR_RGB2HSV_FULL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2HSV_FULL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2Lab"><!-- --></A><H3>
COLOR_RGB2Lab</H3>
<PRE>
public static final int <B>COLOR_RGB2Lab</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2Lab">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2Luv"><!-- --></A><H3>
COLOR_RGB2Luv</H3>
<PRE>
public static final int <B>COLOR_RGB2Luv</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2Luv">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2RGBA"><!-- --></A><H3>
COLOR_RGB2RGBA</H3>
<PRE>
public static final int <B>COLOR_RGB2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2XYZ"><!-- --></A><H3>
COLOR_RGB2XYZ</H3>
<PRE>
public static final int <B>COLOR_RGB2XYZ</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2XYZ">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2YCrCb"><!-- --></A><H3>
COLOR_RGB2YCrCb</H3>
<PRE>
public static final int <B>COLOR_RGB2YCrCb</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2YCrCb">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGB2YUV"><!-- --></A><H3>
COLOR_RGB2YUV</H3>
<PRE>
public static final int <B>COLOR_RGB2YUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGB2YUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2BGR"><!-- --></A><H3>
COLOR_RGBA2BGR</H3>
<PRE>
public static final int <B>COLOR_RGBA2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2BGR555"><!-- --></A><H3>
COLOR_RGBA2BGR555</H3>
<PRE>
public static final int <B>COLOR_RGBA2BGR555</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2BGR555">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2BGR565"><!-- --></A><H3>
COLOR_RGBA2BGR565</H3>
<PRE>
public static final int <B>COLOR_RGBA2BGR565</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2BGR565">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2BGRA"><!-- --></A><H3>
COLOR_RGBA2BGRA</H3>
<PRE>
public static final int <B>COLOR_RGBA2BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2GRAY"><!-- --></A><H3>
COLOR_RGBA2GRAY</H3>
<PRE>
public static final int <B>COLOR_RGBA2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2mRGBA"><!-- --></A><H3>
COLOR_RGBA2mRGBA</H3>
<PRE>
public static final int <B>COLOR_RGBA2mRGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2mRGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_RGBA2RGB"><!-- --></A><H3>
COLOR_RGBA2RGB</H3>
<PRE>
public static final int <B>COLOR_RGBA2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_RGBA2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_XYZ2BGR"><!-- --></A><H3>
COLOR_XYZ2BGR</H3>
<PRE>
public static final int <B>COLOR_XYZ2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_XYZ2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_XYZ2RGB"><!-- --></A><H3>
COLOR_XYZ2RGB</H3>
<PRE>
public static final int <B>COLOR_XYZ2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_XYZ2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YCrCb2BGR"><!-- --></A><H3>
COLOR_YCrCb2BGR</H3>
<PRE>
public static final int <B>COLOR_YCrCb2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YCrCb2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YCrCb2RGB"><!-- --></A><H3>
COLOR_YCrCb2RGB</H3>
<PRE>
public static final int <B>COLOR_YCrCb2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YCrCb2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR"><!-- --></A><H3>
COLOR_YUV2BGR</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_I420"><!-- --></A><H3>
COLOR_YUV2BGR_I420</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_I420</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_I420">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_IYUV"><!-- --></A><H3>
COLOR_YUV2BGR_IYUV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_IYUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_IYUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_NV12"><!-- --></A><H3>
COLOR_YUV2BGR_NV12</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_NV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_NV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_NV21"><!-- --></A><H3>
COLOR_YUV2BGR_NV21</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_NV21</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_NV21">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_UYNV"><!-- --></A><H3>
COLOR_YUV2BGR_UYNV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_UYNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_UYNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_UYVY"><!-- --></A><H3>
COLOR_YUV2BGR_UYVY</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_UYVY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_UYVY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_Y422"><!-- --></A><H3>
COLOR_YUV2BGR_Y422</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_Y422</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_Y422">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_YUNV"><!-- --></A><H3>
COLOR_YUV2BGR_YUNV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_YUNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_YUNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_YUY2"><!-- --></A><H3>
COLOR_YUV2BGR_YUY2</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_YUY2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_YUY2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_YUYV"><!-- --></A><H3>
COLOR_YUV2BGR_YUYV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_YUYV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_YUYV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_YV12"><!-- --></A><H3>
COLOR_YUV2BGR_YV12</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_YV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_YV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGR_YVYU"><!-- --></A><H3>
COLOR_YUV2BGR_YVYU</H3>
<PRE>
public static final int <B>COLOR_YUV2BGR_YVYU</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGR_YVYU">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_I420"><!-- --></A><H3>
COLOR_YUV2BGRA_I420</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_I420</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_I420">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_IYUV"><!-- --></A><H3>
COLOR_YUV2BGRA_IYUV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_IYUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_IYUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_NV12"><!-- --></A><H3>
COLOR_YUV2BGRA_NV12</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_NV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_NV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_NV21"><!-- --></A><H3>
COLOR_YUV2BGRA_NV21</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_NV21</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_NV21">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_UYNV"><!-- --></A><H3>
COLOR_YUV2BGRA_UYNV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_UYNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_UYNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_UYVY"><!-- --></A><H3>
COLOR_YUV2BGRA_UYVY</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_UYVY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_UYVY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_Y422"><!-- --></A><H3>
COLOR_YUV2BGRA_Y422</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_Y422</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_Y422">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_YUNV"><!-- --></A><H3>
COLOR_YUV2BGRA_YUNV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_YUNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_YUNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_YUY2"><!-- --></A><H3>
COLOR_YUV2BGRA_YUY2</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_YUY2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_YUY2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_YUYV"><!-- --></A><H3>
COLOR_YUV2BGRA_YUYV</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_YUYV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_YUYV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_YV12"><!-- --></A><H3>
COLOR_YUV2BGRA_YV12</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_YV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_YV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2BGRA_YVYU"><!-- --></A><H3>
COLOR_YUV2BGRA_YVYU</H3>
<PRE>
public static final int <B>COLOR_YUV2BGRA_YVYU</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2BGRA_YVYU">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_420"><!-- --></A><H3>
COLOR_YUV2GRAY_420</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_420</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_420">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_I420"><!-- --></A><H3>
COLOR_YUV2GRAY_I420</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_I420</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_I420">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_IYUV"><!-- --></A><H3>
COLOR_YUV2GRAY_IYUV</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_IYUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_IYUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_NV12"><!-- --></A><H3>
COLOR_YUV2GRAY_NV12</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_NV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_NV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_NV21"><!-- --></A><H3>
COLOR_YUV2GRAY_NV21</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_NV21</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_NV21">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_UYNV"><!-- --></A><H3>
COLOR_YUV2GRAY_UYNV</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_UYNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_UYNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_UYVY"><!-- --></A><H3>
COLOR_YUV2GRAY_UYVY</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_UYVY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_UYVY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_Y422"><!-- --></A><H3>
COLOR_YUV2GRAY_Y422</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_Y422</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_Y422">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_YUNV"><!-- --></A><H3>
COLOR_YUV2GRAY_YUNV</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_YUNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_YUNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_YUY2"><!-- --></A><H3>
COLOR_YUV2GRAY_YUY2</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_YUY2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_YUY2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_YUYV"><!-- --></A><H3>
COLOR_YUV2GRAY_YUYV</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_YUYV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_YUYV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_YV12"><!-- --></A><H3>
COLOR_YUV2GRAY_YV12</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_YV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_YV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2GRAY_YVYU"><!-- --></A><H3>
COLOR_YUV2GRAY_YVYU</H3>
<PRE>
public static final int <B>COLOR_YUV2GRAY_YVYU</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2GRAY_YVYU">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB"><!-- --></A><H3>
COLOR_YUV2RGB</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_I420"><!-- --></A><H3>
COLOR_YUV2RGB_I420</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_I420</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_I420">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_IYUV"><!-- --></A><H3>
COLOR_YUV2RGB_IYUV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_IYUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_IYUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_NV12"><!-- --></A><H3>
COLOR_YUV2RGB_NV12</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_NV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_NV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_NV21"><!-- --></A><H3>
COLOR_YUV2RGB_NV21</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_NV21</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_NV21">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_UYNV"><!-- --></A><H3>
COLOR_YUV2RGB_UYNV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_UYNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_UYNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_UYVY"><!-- --></A><H3>
COLOR_YUV2RGB_UYVY</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_UYVY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_UYVY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_Y422"><!-- --></A><H3>
COLOR_YUV2RGB_Y422</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_Y422</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_Y422">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_YUNV"><!-- --></A><H3>
COLOR_YUV2RGB_YUNV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_YUNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_YUNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_YUY2"><!-- --></A><H3>
COLOR_YUV2RGB_YUY2</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_YUY2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_YUY2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_YUYV"><!-- --></A><H3>
COLOR_YUV2RGB_YUYV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_YUYV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_YUYV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_YV12"><!-- --></A><H3>
COLOR_YUV2RGB_YV12</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_YV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_YV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGB_YVYU"><!-- --></A><H3>
COLOR_YUV2RGB_YVYU</H3>
<PRE>
public static final int <B>COLOR_YUV2RGB_YVYU</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGB_YVYU">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_I420"><!-- --></A><H3>
COLOR_YUV2RGBA_I420</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_I420</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_I420">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_IYUV"><!-- --></A><H3>
COLOR_YUV2RGBA_IYUV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_IYUV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_IYUV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_NV12"><!-- --></A><H3>
COLOR_YUV2RGBA_NV12</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_NV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_NV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_NV21"><!-- --></A><H3>
COLOR_YUV2RGBA_NV21</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_NV21</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_NV21">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_UYNV"><!-- --></A><H3>
COLOR_YUV2RGBA_UYNV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_UYNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_UYNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_UYVY"><!-- --></A><H3>
COLOR_YUV2RGBA_UYVY</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_UYVY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_UYVY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_Y422"><!-- --></A><H3>
COLOR_YUV2RGBA_Y422</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_Y422</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_Y422">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_YUNV"><!-- --></A><H3>
COLOR_YUV2RGBA_YUNV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_YUNV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_YUNV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_YUY2"><!-- --></A><H3>
COLOR_YUV2RGBA_YUY2</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_YUY2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_YUY2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_YUYV"><!-- --></A><H3>
COLOR_YUV2RGBA_YUYV</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_YUYV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_YUYV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_YV12"><!-- --></A><H3>
COLOR_YUV2RGBA_YV12</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_YV12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_YV12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV2RGBA_YVYU"><!-- --></A><H3>
COLOR_YUV2RGBA_YVYU</H3>
<PRE>
public static final int <B>COLOR_YUV2RGBA_YVYU</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV2RGBA_YVYU">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420p2BGR"><!-- --></A><H3>
COLOR_YUV420p2BGR</H3>
<PRE>
public static final int <B>COLOR_YUV420p2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420p2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420p2BGRA"><!-- --></A><H3>
COLOR_YUV420p2BGRA</H3>
<PRE>
public static final int <B>COLOR_YUV420p2BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420p2BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420p2GRAY"><!-- --></A><H3>
COLOR_YUV420p2GRAY</H3>
<PRE>
public static final int <B>COLOR_YUV420p2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420p2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420p2RGB"><!-- --></A><H3>
COLOR_YUV420p2RGB</H3>
<PRE>
public static final int <B>COLOR_YUV420p2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420p2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420p2RGBA"><!-- --></A><H3>
COLOR_YUV420p2RGBA</H3>
<PRE>
public static final int <B>COLOR_YUV420p2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420p2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420sp2BGR"><!-- --></A><H3>
COLOR_YUV420sp2BGR</H3>
<PRE>
public static final int <B>COLOR_YUV420sp2BGR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420sp2BGR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420sp2BGRA"><!-- --></A><H3>
COLOR_YUV420sp2BGRA</H3>
<PRE>
public static final int <B>COLOR_YUV420sp2BGRA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420sp2BGRA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420sp2GRAY"><!-- --></A><H3>
COLOR_YUV420sp2GRAY</H3>
<PRE>
public static final int <B>COLOR_YUV420sp2GRAY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420sp2GRAY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420sp2RGB"><!-- --></A><H3>
COLOR_YUV420sp2RGB</H3>
<PRE>
public static final int <B>COLOR_YUV420sp2RGB</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420sp2RGB">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="COLOR_YUV420sp2RGBA"><!-- --></A><H3>
COLOR_YUV420sp2RGBA</H3>
<PRE>
public static final int <B>COLOR_YUV420sp2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.COLOR_YUV420sp2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_BILATERAL"><!-- --></A><H3>
CV_BILATERAL</H3>
<PRE>
public static final int <B>CV_BILATERAL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_BILATERAL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_BLUR"><!-- --></A><H3>
CV_BLUR</H3>
<PRE>
public static final int <B>CV_BLUR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_BLUR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_BLUR_NO_SCALE"><!-- --></A><H3>
CV_BLUR_NO_SCALE</H3>
<PRE>
public static final int <B>CV_BLUR_NO_SCALE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_BLUR_NO_SCALE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_CANNY_L2_GRADIENT"><!-- --></A><H3>
CV_CANNY_L2_GRADIENT</H3>
<PRE>
public static final int <B>CV_CANNY_L2_GRADIENT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_CANNY_L2_GRADIENT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_CHAIN_CODE"><!-- --></A><H3>
CV_CHAIN_CODE</H3>
<PRE>
public static final int <B>CV_CHAIN_CODE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_CHAIN_CODE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_CLOCKWISE"><!-- --></A><H3>
CV_CLOCKWISE</H3>
<PRE>
public static final int <B>CV_CLOCKWISE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_CLOCKWISE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_COMP_BHATTACHARYYA"><!-- --></A><H3>
CV_COMP_BHATTACHARYYA</H3>
<PRE>
public static final int <B>CV_COMP_BHATTACHARYYA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_COMP_BHATTACHARYYA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_COMP_CHISQR"><!-- --></A><H3>
CV_COMP_CHISQR</H3>
<PRE>
public static final int <B>CV_COMP_CHISQR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_COMP_CHISQR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_COMP_CORREL"><!-- --></A><H3>
CV_COMP_CORREL</H3>
<PRE>
public static final int <B>CV_COMP_CORREL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_COMP_CORREL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_COMP_HELLINGER"><!-- --></A><H3>
CV_COMP_HELLINGER</H3>
<PRE>
public static final int <B>CV_COMP_HELLINGER</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_COMP_HELLINGER">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_COMP_INTERSECT"><!-- --></A><H3>
CV_COMP_INTERSECT</H3>
<PRE>
public static final int <B>CV_COMP_INTERSECT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_COMP_INTERSECT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_CONTOURS_MATCH_I1"><!-- --></A><H3>
CV_CONTOURS_MATCH_I1</H3>
<PRE>
public static final int <B>CV_CONTOURS_MATCH_I1</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_CONTOURS_MATCH_I1">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_CONTOURS_MATCH_I2"><!-- --></A><H3>
CV_CONTOURS_MATCH_I2</H3>
<PRE>
public static final int <B>CV_CONTOURS_MATCH_I2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_CONTOURS_MATCH_I2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_CONTOURS_MATCH_I3"><!-- --></A><H3>
CV_CONTOURS_MATCH_I3</H3>
<PRE>
public static final int <B>CV_CONTOURS_MATCH_I3</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_CONTOURS_MATCH_I3">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_COUNTER_CLOCKWISE"><!-- --></A><H3>
CV_COUNTER_CLOCKWISE</H3>
<PRE>
public static final int <B>CV_COUNTER_CLOCKWISE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_COUNTER_CLOCKWISE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_C"><!-- --></A><H3>
CV_DIST_C</H3>
<PRE>
public static final int <B>CV_DIST_C</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_C">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_FAIR"><!-- --></A><H3>
CV_DIST_FAIR</H3>
<PRE>
public static final int <B>CV_DIST_FAIR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_FAIR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_HUBER"><!-- --></A><H3>
CV_DIST_HUBER</H3>
<PRE>
public static final int <B>CV_DIST_HUBER</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_HUBER">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_L1"><!-- --></A><H3>
CV_DIST_L1</H3>
<PRE>
public static final int <B>CV_DIST_L1</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_L1">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_L12"><!-- --></A><H3>
CV_DIST_L12</H3>
<PRE>
public static final int <B>CV_DIST_L12</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_L12">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_L2"><!-- --></A><H3>
CV_DIST_L2</H3>
<PRE>
public static final int <B>CV_DIST_L2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_L2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_LABEL_CCOMP"><!-- --></A><H3>
CV_DIST_LABEL_CCOMP</H3>
<PRE>
public static final int <B>CV_DIST_LABEL_CCOMP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_LABEL_CCOMP">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_LABEL_PIXEL"><!-- --></A><H3>
CV_DIST_LABEL_PIXEL</H3>
<PRE>
public static final int <B>CV_DIST_LABEL_PIXEL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_LABEL_PIXEL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_MASK_3"><!-- --></A><H3>
CV_DIST_MASK_3</H3>
<PRE>
public static final int <B>CV_DIST_MASK_3</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_MASK_3">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_MASK_5"><!-- --></A><H3>
CV_DIST_MASK_5</H3>
<PRE>
public static final int <B>CV_DIST_MASK_5</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_MASK_5">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_MASK_PRECISE"><!-- --></A><H3>
CV_DIST_MASK_PRECISE</H3>
<PRE>
public static final int <B>CV_DIST_MASK_PRECISE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_MASK_PRECISE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_USER"><!-- --></A><H3>
CV_DIST_USER</H3>
<PRE>
public static final int <B>CV_DIST_USER</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_USER">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_DIST_WELSCH"><!-- --></A><H3>
CV_DIST_WELSCH</H3>
<PRE>
public static final int <B>CV_DIST_WELSCH</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_DIST_WELSCH">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_GAUSSIAN"><!-- --></A><H3>
CV_GAUSSIAN</H3>
<PRE>
public static final int <B>CV_GAUSSIAN</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_GAUSSIAN">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_GAUSSIAN_5x5"><!-- --></A><H3>
CV_GAUSSIAN_5x5</H3>
<PRE>
public static final int <B>CV_GAUSSIAN_5x5</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_GAUSSIAN_5x5">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_HOUGH_GRADIENT"><!-- --></A><H3>
CV_HOUGH_GRADIENT</H3>
<PRE>
public static final int <B>CV_HOUGH_GRADIENT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_HOUGH_GRADIENT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_HOUGH_MULTI_SCALE"><!-- --></A><H3>
CV_HOUGH_MULTI_SCALE</H3>
<PRE>
public static final int <B>CV_HOUGH_MULTI_SCALE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_HOUGH_MULTI_SCALE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_HOUGH_PROBABILISTIC"><!-- --></A><H3>
CV_HOUGH_PROBABILISTIC</H3>
<PRE>
public static final int <B>CV_HOUGH_PROBABILISTIC</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_HOUGH_PROBABILISTIC">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_HOUGH_STANDARD"><!-- --></A><H3>
CV_HOUGH_STANDARD</H3>
<PRE>
public static final int <B>CV_HOUGH_STANDARD</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_HOUGH_STANDARD">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_LINK_RUNS"><!-- --></A><H3>
CV_LINK_RUNS</H3>
<PRE>
public static final int <B>CV_LINK_RUNS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_LINK_RUNS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_MAX_SOBEL_KSIZE"><!-- --></A><H3>
CV_MAX_SOBEL_KSIZE</H3>
<PRE>
public static final int <B>CV_MAX_SOBEL_KSIZE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_MAX_SOBEL_KSIZE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_MEDIAN"><!-- --></A><H3>
CV_MEDIAN</H3>
<PRE>
public static final int <B>CV_MEDIAN</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_MEDIAN">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_mRGBA2RGBA"><!-- --></A><H3>
CV_mRGBA2RGBA</H3>
<PRE>
public static final int <B>CV_mRGBA2RGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_mRGBA2RGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_POLY_APPROX_DP"><!-- --></A><H3>
CV_POLY_APPROX_DP</H3>
<PRE>
public static final int <B>CV_POLY_APPROX_DP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_POLY_APPROX_DP">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_RGBA2mRGBA"><!-- --></A><H3>
CV_RGBA2mRGBA</H3>
<PRE>
public static final int <B>CV_RGBA2mRGBA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_RGBA2mRGBA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_SCHARR"><!-- --></A><H3>
CV_SCHARR</H3>
<PRE>
public static final int <B>CV_SCHARR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_SCHARR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_SHAPE_CROSS"><!-- --></A><H3>
CV_SHAPE_CROSS</H3>
<PRE>
public static final int <B>CV_SHAPE_CROSS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_SHAPE_CROSS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_SHAPE_CUSTOM"><!-- --></A><H3>
CV_SHAPE_CUSTOM</H3>
<PRE>
public static final int <B>CV_SHAPE_CUSTOM</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_SHAPE_CUSTOM">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_SHAPE_ELLIPSE"><!-- --></A><H3>
CV_SHAPE_ELLIPSE</H3>
<PRE>
public static final int <B>CV_SHAPE_ELLIPSE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_SHAPE_ELLIPSE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_SHAPE_RECT"><!-- --></A><H3>
CV_SHAPE_RECT</H3>
<PRE>
public static final int <B>CV_SHAPE_RECT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_SHAPE_RECT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_WARP_FILL_OUTLIERS"><!-- --></A><H3>
CV_WARP_FILL_OUTLIERS</H3>
<PRE>
public static final int <B>CV_WARP_FILL_OUTLIERS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_WARP_FILL_OUTLIERS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="CV_WARP_INVERSE_MAP"><!-- --></A><H3>
CV_WARP_INVERSE_MAP</H3>
<PRE>
public static final int <B>CV_WARP_INVERSE_MAP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.CV_WARP_INVERSE_MAP">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="DIST_LABEL_CCOMP"><!-- --></A><H3>
DIST_LABEL_CCOMP</H3>
<PRE>
public static final int <B>DIST_LABEL_CCOMP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.DIST_LABEL_CCOMP">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="DIST_LABEL_PIXEL"><!-- --></A><H3>
DIST_LABEL_PIXEL</H3>
<PRE>
public static final int <B>DIST_LABEL_PIXEL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.DIST_LABEL_PIXEL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="FLOODFILL_FIXED_RANGE"><!-- --></A><H3>
FLOODFILL_FIXED_RANGE</H3>
<PRE>
public static final int <B>FLOODFILL_FIXED_RANGE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.FLOODFILL_FIXED_RANGE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="FLOODFILL_MASK_ONLY"><!-- --></A><H3>
FLOODFILL_MASK_ONLY</H3>
<PRE>
public static final int <B>FLOODFILL_MASK_ONLY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.FLOODFILL_MASK_ONLY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_BGD"><!-- --></A><H3>
GC_BGD</H3>
<PRE>
public static final int <B>GC_BGD</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_BGD">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_EVAL"><!-- --></A><H3>
GC_EVAL</H3>
<PRE>
public static final int <B>GC_EVAL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_EVAL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_FGD"><!-- --></A><H3>
GC_FGD</H3>
<PRE>
public static final int <B>GC_FGD</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_FGD">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_INIT_WITH_MASK"><!-- --></A><H3>
GC_INIT_WITH_MASK</H3>
<PRE>
public static final int <B>GC_INIT_WITH_MASK</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_INIT_WITH_MASK">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_INIT_WITH_RECT"><!-- --></A><H3>
GC_INIT_WITH_RECT</H3>
<PRE>
public static final int <B>GC_INIT_WITH_RECT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_INIT_WITH_RECT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_PR_BGD"><!-- --></A><H3>
GC_PR_BGD</H3>
<PRE>
public static final int <B>GC_PR_BGD</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_PR_BGD">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GC_PR_FGD"><!-- --></A><H3>
GC_PR_FGD</H3>
<PRE>
public static final int <B>GC_PR_FGD</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GC_PR_FGD">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GHT_POSITION"><!-- --></A><H3>
GHT_POSITION</H3>
<PRE>
public static final int <B>GHT_POSITION</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GHT_POSITION">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GHT_ROTATION"><!-- --></A><H3>
GHT_ROTATION</H3>
<PRE>
public static final int <B>GHT_ROTATION</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GHT_ROTATION">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="GHT_SCALE"><!-- --></A><H3>
GHT_SCALE</H3>
<PRE>
public static final int <B>GHT_SCALE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.GHT_SCALE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_AREA"><!-- --></A><H3>
INTER_AREA</H3>
<PRE>
public static final int <B>INTER_AREA</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_AREA">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_BITS"><!-- --></A><H3>
INTER_BITS</H3>
<PRE>
public static final int <B>INTER_BITS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_BITS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_BITS2"><!-- --></A><H3>
INTER_BITS2</H3>
<PRE>
public static final int <B>INTER_BITS2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_BITS2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_CUBIC"><!-- --></A><H3>
INTER_CUBIC</H3>
<PRE>
public static final int <B>INTER_CUBIC</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_CUBIC">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_LANCZOS4"><!-- --></A><H3>
INTER_LANCZOS4</H3>
<PRE>
public static final int <B>INTER_LANCZOS4</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_LANCZOS4">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_LINEAR"><!-- --></A><H3>
INTER_LINEAR</H3>
<PRE>
public static final int <B>INTER_LINEAR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_LINEAR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_MAX"><!-- --></A><H3>
INTER_MAX</H3>
<PRE>
public static final int <B>INTER_MAX</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_MAX">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_NEAREST"><!-- --></A><H3>
INTER_NEAREST</H3>
<PRE>
public static final int <B>INTER_NEAREST</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_NEAREST">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_TAB_SIZE"><!-- --></A><H3>
INTER_TAB_SIZE</H3>
<PRE>
public static final int <B>INTER_TAB_SIZE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_TAB_SIZE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="INTER_TAB_SIZE2"><!-- --></A><H3>
INTER_TAB_SIZE2</H3>
<PRE>
public static final int <B>INTER_TAB_SIZE2</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.INTER_TAB_SIZE2">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="KERNEL_ASYMMETRICAL"><!-- --></A><H3>
KERNEL_ASYMMETRICAL</H3>
<PRE>
public static final int <B>KERNEL_ASYMMETRICAL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.KERNEL_ASYMMETRICAL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="KERNEL_GENERAL"><!-- --></A><H3>
KERNEL_GENERAL</H3>
<PRE>
public static final int <B>KERNEL_GENERAL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.KERNEL_GENERAL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="KERNEL_INTEGER"><!-- --></A><H3>
KERNEL_INTEGER</H3>
<PRE>
public static final int <B>KERNEL_INTEGER</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.KERNEL_INTEGER">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="KERNEL_SMOOTH"><!-- --></A><H3>
KERNEL_SMOOTH</H3>
<PRE>
public static final int <B>KERNEL_SMOOTH</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.KERNEL_SMOOTH">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="KERNEL_SYMMETRICAL"><!-- --></A><H3>
KERNEL_SYMMETRICAL</H3>
<PRE>
public static final int <B>KERNEL_SYMMETRICAL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.KERNEL_SYMMETRICAL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_BLACKHAT"><!-- --></A><H3>
MORPH_BLACKHAT</H3>
<PRE>
public static final int <B>MORPH_BLACKHAT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_BLACKHAT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_CLOSE"><!-- --></A><H3>
MORPH_CLOSE</H3>
<PRE>
public static final int <B>MORPH_CLOSE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_CLOSE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_CROSS"><!-- --></A><H3>
MORPH_CROSS</H3>
<PRE>
public static final int <B>MORPH_CROSS</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_CROSS">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_DILATE"><!-- --></A><H3>
MORPH_DILATE</H3>
<PRE>
public static final int <B>MORPH_DILATE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_DILATE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_ELLIPSE"><!-- --></A><H3>
MORPH_ELLIPSE</H3>
<PRE>
public static final int <B>MORPH_ELLIPSE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_ELLIPSE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_ERODE"><!-- --></A><H3>
MORPH_ERODE</H3>
<PRE>
public static final int <B>MORPH_ERODE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_ERODE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_GRADIENT"><!-- --></A><H3>
MORPH_GRADIENT</H3>
<PRE>
public static final int <B>MORPH_GRADIENT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_GRADIENT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_OPEN"><!-- --></A><H3>
MORPH_OPEN</H3>
<PRE>
public static final int <B>MORPH_OPEN</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_OPEN">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_RECT"><!-- --></A><H3>
MORPH_RECT</H3>
<PRE>
public static final int <B>MORPH_RECT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_RECT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="MORPH_TOPHAT"><!-- --></A><H3>
MORPH_TOPHAT</H3>
<PRE>
public static final int <B>MORPH_TOPHAT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.MORPH_TOPHAT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="PROJ_SPHERICAL_EQRECT"><!-- --></A><H3>
PROJ_SPHERICAL_EQRECT</H3>
<PRE>
public static final int <B>PROJ_SPHERICAL_EQRECT</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.PROJ_SPHERICAL_EQRECT">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="PROJ_SPHERICAL_ORTHO"><!-- --></A><H3>
PROJ_SPHERICAL_ORTHO</H3>
<PRE>
public static final int <B>PROJ_SPHERICAL_ORTHO</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.PROJ_SPHERICAL_ORTHO">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="RETR_CCOMP"><!-- --></A><H3>
RETR_CCOMP</H3>
<PRE>
public static final int <B>RETR_CCOMP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.RETR_CCOMP">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="RETR_EXTERNAL"><!-- --></A><H3>
RETR_EXTERNAL</H3>
<PRE>
public static final int <B>RETR_EXTERNAL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.RETR_EXTERNAL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="RETR_FLOODFILL"><!-- --></A><H3>
RETR_FLOODFILL</H3>
<PRE>
public static final int <B>RETR_FLOODFILL</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.RETR_FLOODFILL">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="RETR_LIST"><!-- --></A><H3>
RETR_LIST</H3>
<PRE>
public static final int <B>RETR_LIST</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.RETR_LIST">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="RETR_TREE"><!-- --></A><H3>
RETR_TREE</H3>
<PRE>
public static final int <B>RETR_TREE</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.RETR_TREE">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_BINARY"><!-- --></A><H3>
THRESH_BINARY</H3>
<PRE>
public static final int <B>THRESH_BINARY</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_BINARY">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_BINARY_INV"><!-- --></A><H3>
THRESH_BINARY_INV</H3>
<PRE>
public static final int <B>THRESH_BINARY_INV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_BINARY_INV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_MASK"><!-- --></A><H3>
THRESH_MASK</H3>
<PRE>
public static final int <B>THRESH_MASK</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_MASK">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_OTSU"><!-- --></A><H3>
THRESH_OTSU</H3>
<PRE>
public static final int <B>THRESH_OTSU</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_OTSU">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_TOZERO"><!-- --></A><H3>
THRESH_TOZERO</H3>
<PRE>
public static final int <B>THRESH_TOZERO</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_TOZERO">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_TOZERO_INV"><!-- --></A><H3>
THRESH_TOZERO_INV</H3>
<PRE>
public static final int <B>THRESH_TOZERO_INV</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_TOZERO_INV">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="THRESH_TRUNC"><!-- --></A><H3>
THRESH_TRUNC</H3>
<PRE>
public static final int <B>THRESH_TRUNC</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.THRESH_TRUNC">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="TM_CCOEFF"><!-- --></A><H3>
TM_CCOEFF</H3>
<PRE>
public static final int <B>TM_CCOEFF</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.TM_CCOEFF">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="TM_CCOEFF_NORMED"><!-- --></A><H3>
TM_CCOEFF_NORMED</H3>
<PRE>
public static final int <B>TM_CCOEFF_NORMED</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.TM_CCOEFF_NORMED">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="TM_CCORR"><!-- --></A><H3>
TM_CCORR</H3>
<PRE>
public static final int <B>TM_CCORR</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.TM_CCORR">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="TM_CCORR_NORMED"><!-- --></A><H3>
TM_CCORR_NORMED</H3>
<PRE>
public static final int <B>TM_CCORR_NORMED</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.TM_CCORR_NORMED">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="TM_SQDIFF"><!-- --></A><H3>
TM_SQDIFF</H3>
<PRE>
public static final int <B>TM_SQDIFF</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.TM_SQDIFF">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="TM_SQDIFF_NORMED"><!-- --></A><H3>
TM_SQDIFF_NORMED</H3>
<PRE>
public static final int <B>TM_SQDIFF_NORMED</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.TM_SQDIFF_NORMED">Constant Field Values</A></DL>
</DL>
<HR>
<A NAME="WARP_INVERSE_MAP"><!-- --></A><H3>
WARP_INVERSE_MAP</H3>
<PRE>
public static final int <B>WARP_INVERSE_MAP</B></PRE>
<DL>
<DL>
<DT><B>See Also:</B><DD><A HREF="../../../constant-values.html#org.opencv.imgproc.Imgproc.WARP_INVERSE_MAP">Constant Field Values</A></DL>
</DL>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<A NAME="constructor_detail"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="1"><FONT SIZE="+2">
<B>Constructor Detail</B></FONT></TH>
</TR>
</TABLE>
<A NAME="Imgproc()"><!-- --></A><H3>
Imgproc</H3>
<PRE>
public <B>Imgproc</B>()</PRE>
<DL>
</DL>
<!-- ============ METHOD DETAIL ========== -->
<A NAME="method_detail"><!-- --></A>
<TABLE BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
<TR BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
<TH ALIGN="left" COLSPAN="1"><FONT SIZE="+2">
<B>Method Detail</B></FONT></TH>
</TR>
</TABLE>
<A NAME="accumulate(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
accumulate</H3>
<PRE>
public static void <B>accumulate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Adds an image to the accumulator.</p>
<p>The function adds <code>src</code> or some of its elements to
<code>dst</code> :</p>
<p><em>dst(x,y) <- dst(x,y) + src(x,y) if mask(x,y) != 0</em></p>
<p>The function supports multi-channel images. Each channel is processed
independently.</p>
<p>The functions <code>accumulate*</code> can be used, for example, to collect
statistics of a scene background viewed by a still camera and for the further
foreground-background segmentation.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.<DD><CODE>dst</CODE> - Accumulator image with the same number of channels as input image,
32-bit or 64-bit floating-point.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulate">org.opencv.imgproc.Imgproc.accumulate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><CODE>accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
accumulate</H3>
<PRE>
public static void <B>accumulate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</PRE>
<DL>
<DD><p>Adds an image to the accumulator.</p>
<p>The function adds <code>src</code> or some of its elements to
<code>dst</code> :</p>
<p><em>dst(x,y) <- dst(x,y) + src(x,y) if mask(x,y) != 0</em></p>
<p>The function supports multi-channel images. Each channel is processed
independently.</p>
<p>The functions <code>accumulate*</code> can be used, for example, to collect
statistics of a scene background viewed by a still camera and for the further
foreground-background segmentation.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.<DD><CODE>dst</CODE> - Accumulator image with the same number of channels as input image,
32-bit or 64-bit floating-point.<DD><CODE>mask</CODE> - Optional operation mask.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulate">org.opencv.imgproc.Imgproc.accumulate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><CODE>accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
accumulateProduct</H3>
<PRE>
public static void <B>accumulateProduct</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Adds the per-element product of two input images to the accumulator.</p>
<p>The function adds the product of two images or their selected regions to the
accumulator <code>dst</code> :</p>
<p><em>dst(x,y) <- dst(x,y) + src1(x,y) * src2(x,y) if mask(x,y) != 0</em></p>
<p>The function supports multi-channel images. Each channel is processed
independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src1</CODE> - First input image, 1- or 3-channel, 8-bit or 32-bit floating
point.<DD><CODE>src2</CODE> - Second input image of the same type and the same size as
<code>src1</code>.<DD><CODE>dst</CODE> - Accumulator with the same number of channels as input images,
32-bit or 64-bit floating-point.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulateproduct">org.opencv.imgproc.Imgproc.accumulateProduct</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><CODE>accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
accumulateProduct</H3>
<PRE>
public static void <B>accumulateProduct</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</PRE>
<DL>
<DD><p>Adds the per-element product of two input images to the accumulator.</p>
<p>The function adds the product of two images or their selected regions to the
accumulator <code>dst</code> :</p>
<p><em>dst(x,y) <- dst(x,y) + src1(x,y) * src2(x,y) if mask(x,y) != 0</em></p>
<p>The function supports multi-channel images. Each channel is processed
independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src1</CODE> - First input image, 1- or 3-channel, 8-bit or 32-bit floating
point.<DD><CODE>src2</CODE> - Second input image of the same type and the same size as
<code>src1</code>.<DD><CODE>dst</CODE> - Accumulator with the same number of channels as input images,
32-bit or 64-bit floating-point.<DD><CODE>mask</CODE> - Optional operation mask.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulateproduct">org.opencv.imgproc.Imgproc.accumulateProduct</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><CODE>accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
accumulateSquare</H3>
<PRE>
public static void <B>accumulateSquare</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Adds the square of a source image to the accumulator.</p>
<p>The function adds the input image <code>src</code> or its selected region,
raised to a power of 2, to the accumulator <code>dst</code> :</p>
<p><em>dst(x,y) <- dst(x,y) + src(x,y)^2 if mask(x,y) != 0</em></p>
<p>The function supports multi-channel images. Each channel is processed
independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.<DD><CODE>dst</CODE> - Accumulator image with the same number of channels as input image,
32-bit or 64-bit floating-point.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulatesquare">org.opencv.imgproc.Imgproc.accumulateSquare</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><CODE>accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
accumulateSquare</H3>
<PRE>
public static void <B>accumulateSquare</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</PRE>
<DL>
<DD><p>Adds the square of a source image to the accumulator.</p>
<p>The function adds the input image <code>src</code> or its selected region,
raised to a power of 2, to the accumulator <code>dst</code> :</p>
<p><em>dst(x,y) <- dst(x,y) + src(x,y)^2 if mask(x,y) != 0</em></p>
<p>The function supports multi-channel images. Each channel is processed
independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.<DD><CODE>dst</CODE> - Accumulator image with the same number of channels as input image,
32-bit or 64-bit floating-point.<DD><CODE>mask</CODE> - Optional operation mask.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulatesquare">org.opencv.imgproc.Imgproc.accumulateSquare</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><CODE>accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double)"><!-- --></A><H3>
accumulateWeighted</H3>
<PRE>
public static void <B>accumulateWeighted</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double alpha)</PRE>
<DL>
<DD><p>Updates a running average.</p>
<p>The function calculates the weighted sum of the input image <code>src</code>
and the accumulator <code>dst</code> so that <code>dst</code> becomes a
running average of a frame sequence:</p>
<p><em>dst(x,y) <- (1- alpha) * dst(x,y) + alpha * src(x,y) if mask(x,y) !=
0</em></p>
<p>That is, <code>alpha</code> regulates the update speed (how fast the
accumulator "forgets" about earlier images).
The function supports multi-channel images. Each channel is processed
independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.<DD><CODE>dst</CODE> - Accumulator image with the same number of channels as input image,
32-bit or 64-bit floating-point.<DD><CODE>alpha</CODE> - Weight of the input image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulateweighted">org.opencv.imgproc.Imgproc.accumulateWeighted</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="accumulateWeighted(org.opencv.core.Mat, org.opencv.core.Mat, double, org.opencv.core.Mat)"><!-- --></A><H3>
accumulateWeighted</H3>
<PRE>
public static void <B>accumulateWeighted</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double alpha,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask)</PRE>
<DL>
<DD><p>Updates a running average.</p>
<p>The function calculates the weighted sum of the input image <code>src</code>
and the accumulator <code>dst</code> so that <code>dst</code> becomes a
running average of a frame sequence:</p>
<p><em>dst(x,y) <- (1- alpha) * dst(x,y) + alpha * src(x,y) if mask(x,y) !=
0</em></p>
<p>That is, <code>alpha</code> regulates the update speed (how fast the
accumulator "forgets" about earlier images).
The function supports multi-channel images. Each channel is processed
independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input image as 1- or 3-channel, 8-bit or 32-bit floating point.<DD><CODE>dst</CODE> - Accumulator image with the same number of channels as input image,
32-bit or 64-bit floating-point.<DD><CODE>alpha</CODE> - Weight of the input image.<DD><CODE>mask</CODE> - Optional operation mask.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#accumulateweighted">org.opencv.imgproc.Imgproc.accumulateWeighted</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateProduct(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>accumulateSquare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="adaptiveThreshold(org.opencv.core.Mat, org.opencv.core.Mat, double, int, int, int, double)"><!-- --></A><H3>
adaptiveThreshold</H3>
<PRE>
public static void <B>adaptiveThreshold</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double maxValue,
int adaptiveMethod,
int thresholdType,
int blockSize,
double C)</PRE>
<DL>
<DD><p>Applies an adaptive threshold to an array.</p>
<p>The function transforms a grayscale image to a binary image according to the
formulae:</p>
<ul>
<li> THRESH_BINARY
</ul>
<p><em>dst(x,y) = maxValue if src(x,y) > T(x,y); 0 otherwise</em></p>
<ul>
<li> THRESH_BINARY_INV
</ul>
<p><em>dst(x,y) = 0 if src(x,y) > T(x,y); maxValue otherwise</em></p>
<p>where <em>T(x,y)</em> is a threshold calculated individually for each pixel.</p>
<ul>
<li> For the method <code>ADAPTIVE_THRESH_MEAN_C</code>, the threshold
value <em>T(x,y)</em> is a mean of the <em>blockSize x blockSize</em>
neighborhood of <em>(x, y)</em> minus <code>C</code>.
<li> For the method <code>ADAPTIVE_THRESH_GAUSSIAN_C</code>, the threshold
value <em>T(x, y)</em> is a weighted sum (cross-correlation with a Gaussian
window) of the <em>blockSize x blockSize</em> neighborhood of <em>(x, y)</em>
minus <code>C</code>. The default sigma (standard deviation) is used for the
specified <code>blockSize</code>. See "getGaussianKernel".
</ul>
<p>The function can process the image in-place.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source 8-bit single-channel image.<DD><CODE>dst</CODE> - Destination image of the same size and the same type as
<code>src</code>.<DD><CODE>maxValue</CODE> - Non-zero value assigned to the pixels for which the condition
is satisfied. See the details below.<DD><CODE>adaptiveMethod</CODE> - Adaptive thresholding algorithm to use,
<code>ADAPTIVE_THRESH_MEAN_C</code> or <code>ADAPTIVE_THRESH_GAUSSIAN_C</code>.
See the details below.<DD><CODE>thresholdType</CODE> - Thresholding type that must be either <code>THRESH_BINARY</code>
or <code>THRESH_BINARY_INV</code>.<DD><CODE>blockSize</CODE> - Size of a pixel neighborhood that is used to calculate a
threshold value for the pixel: 3, 5, 7, and so on.<DD><CODE>C</CODE> - Constant subtracted from the mean or weighted mean (see the details
below). Normally, it is positive but may be zero or negative as well.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#adaptivethreshold">org.opencv.imgproc.Imgproc.adaptiveThreshold</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#threshold(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)"><CODE>threshold(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="approxPolyDP(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, double, boolean)"><!-- --></A><H3>
approxPolyDP</H3>
<PRE>
public static void <B>approxPolyDP</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> curve,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> approxCurve,
double epsilon,
boolean closed)</PRE>
<DL>
<DD><p>Approximates a polygonal curve(s) with the specified precision.</p>
<p>The functions <code>approxPolyDP</code> approximate a curve or a polygon with
another curve/polygon with less vertices so that the distance between them is
less or equal to the specified precision. It uses the Douglas-Peucker
algorithm http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm</p>
<p>See http://code.opencv.org/projects/opencv/repository/revisions/master/entry/samples/cpp/contours.cpp
for the function usage model.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>curve</CODE> - Input vector of a 2D point stored in:
<ul>
<li> <code>std.vector</code> or <code>Mat</code> (C++ interface)
<li> <code>Nx2</code> numpy array (Python interface)
<li> <code>CvSeq</code> or <code> </code>CvMat" (C interface)
</ul><DD><CODE>approxCurve</CODE> - Result of the approximation. The type should match the
type of the input curve. In case of C interface the approximated curve is
stored in the memory storage and pointer to it is returned.<DD><CODE>epsilon</CODE> - Parameter specifying the approximation accuracy. This is the
maximum distance between the original curve and its approximation.<DD><CODE>closed</CODE> - If true, the approximated curve is closed (its first and last
vertices are connected). Otherwise, it is not closed.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#approxpolydp">org.opencv.imgproc.Imgproc.approxPolyDP</a></DL>
</DD>
</DL>
<HR>
<A NAME="arcLength(org.opencv.core.MatOfPoint2f, boolean)"><!-- --></A><H3>
arcLength</H3>
<PRE>
public static double <B>arcLength</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> curve,
boolean closed)</PRE>
<DL>
<DD><p>Calculates a contour perimeter or a curve length.</p>
<p>The function computes a curve length or a closed contour perimeter.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>curve</CODE> - Input vector of 2D points, stored in <code>std.vector</code> or
<code>Mat</code>.<DD><CODE>closed</CODE> - Flag indicating whether the curve is closed or not.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#arclength">org.opencv.imgproc.Imgproc.arcLength</a></DL>
</DD>
</DL>
<HR>
<A NAME="bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double)"><!-- --></A><H3>
bilateralFilter</H3>
<PRE>
public static void <B>bilateralFilter</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int d,
double sigmaColor,
double sigmaSpace)</PRE>
<DL>
<DD><p>Applies the bilateral filter to an image.</p>
<p>The function applies bilateral filtering to the input image, as described in
http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
<code>bilateralFilter</code> can reduce unwanted noise very well while
keeping edges fairly sharp. However, it is very slow compared to most
filters.</p>
<ul>
<li>Sigma values*: For simplicity, you can set the 2 sigma values to be the
same. If they are small (< 10), the filter will not have much effect, whereas
if they are large (> 150), they will have a very strong effect, making the
image look "cartoonish".
<li>Filter size*: Large filters (d > 5) are very slow, so it is recommended
to use d=5 for real-time applications, and perhaps d=9 for offline
applications that need heavy noise filtering.
</ul>
<p>This filter does not work inplace.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source 8-bit or floating-point, 1-channel or 3-channel image.<DD><CODE>dst</CODE> - Destination image of the same size and type as <code>src</code>.<DD><CODE>d</CODE> - Diameter of each pixel neighborhood that is used during filtering.
If it is non-positive, it is computed from <code>sigmaSpace</code>.<DD><CODE>sigmaColor</CODE> - Filter sigma in the color space. A larger value of the
parameter means that farther colors within the pixel neighborhood (see
<code>sigmaSpace</code>) will be mixed together, resulting in larger areas of
semi-equal color.<DD><CODE>sigmaSpace</CODE> - Filter sigma in the coordinate space. A larger value of the
parameter means that farther pixels will influence each other as long as
their colors are close enough (see <code>sigmaColor</code>). When
<code>d>0</code>, it specifies the neighborhood size regardless of
<code>sigmaSpace</code>. Otherwise, <code>d</code> is proportional to
<code>sigmaSpace</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#bilateralfilter">org.opencv.imgproc.Imgproc.bilateralFilter</a></DL>
</DD>
</DL>
<HR>
<A NAME="bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><!-- --></A><H3>
bilateralFilter</H3>
<PRE>
public static void <B>bilateralFilter</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int d,
double sigmaColor,
double sigmaSpace,
int borderType)</PRE>
<DL>
<DD><p>Applies the bilateral filter to an image.</p>
<p>The function applies bilateral filtering to the input image, as described in
http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html
<code>bilateralFilter</code> can reduce unwanted noise very well while
keeping edges fairly sharp. However, it is very slow compared to most
filters.</p>
<ul>
<li>Sigma values*: For simplicity, you can set the 2 sigma values to be the
same. If they are small (< 10), the filter will not have much effect, whereas
if they are large (> 150), they will have a very strong effect, making the
image look "cartoonish".
<li>Filter size*: Large filters (d > 5) are very slow, so it is recommended
to use d=5 for real-time applications, and perhaps d=9 for offline
applications that need heavy noise filtering.
</ul>
<p>This filter does not work inplace.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source 8-bit or floating-point, 1-channel or 3-channel image.<DD><CODE>dst</CODE> - Destination image of the same size and type as <code>src</code>.<DD><CODE>d</CODE> - Diameter of each pixel neighborhood that is used during filtering.
If it is non-positive, it is computed from <code>sigmaSpace</code>.<DD><CODE>sigmaColor</CODE> - Filter sigma in the color space. A larger value of the
parameter means that farther colors within the pixel neighborhood (see
<code>sigmaSpace</code>) will be mixed together, resulting in larger areas of
semi-equal color.<DD><CODE>sigmaSpace</CODE> - Filter sigma in the coordinate space. A larger value of the
parameter means that farther pixels will influence each other as long as
their colors are close enough (see <code>sigmaColor</code>). When
<code>d>0</code>, it specifies the neighborhood size regardless of
<code>sigmaSpace</code>. Otherwise, <code>d</code> is proportional to
<code>sigmaSpace</code>.<DD><CODE>borderType</CODE> - a borderType<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#bilateralfilter">org.opencv.imgproc.Imgproc.bilateralFilter</a></DL>
</DD>
</DL>
<HR>
<A NAME="blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)"><!-- --></A><H3>
blur</H3>
<PRE>
public static void <B>blur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize)</PRE>
<DL>
<DD><p>Blurs an image using the normalized box filter.</p>
<p>The function smoothes an image using the kernel:</p>
<p><em>K = 1/(ksize.width*ksize.height) 1 1 1 *s 1 1
1 1 1 *s 1 1..................
1 1 1 *s 1 1
</em></p>
<p>The call <code>blur(src, dst, ksize, anchor, borderType)</code> is equivalent
to <code>boxFilter(src, dst, src.type(), anchor, true, borderType)</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; it can have any number of channels, which are
processed independently, but the depth should be <code>CV_8U</code>,
<code>CV_16U</code>, <code>CV_16S</code>, <code>CV_32F</code> or
<code>CV_64F</code>.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - blurring kernel size.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#blur">org.opencv.imgproc.Imgproc.blur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point)"><!-- --></A><H3>
blur</H3>
<PRE>
public static void <B>blur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor)</PRE>
<DL>
<DD><p>Blurs an image using the normalized box filter.</p>
<p>The function smoothes an image using the kernel:</p>
<p><em>K = 1/(ksize.width*ksize.height) 1 1 1 *s 1 1
1 1 1 *s 1 1..................
1 1 1 *s 1 1
</em></p>
<p>The call <code>blur(src, dst, ksize, anchor, borderType)</code> is equivalent
to <code>boxFilter(src, dst, src.type(), anchor, true, borderType)</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; it can have any number of channels, which are
processed independently, but the depth should be <code>CV_8U</code>,
<code>CV_16U</code>, <code>CV_16S</code>, <code>CV_32F</code> or
<code>CV_64F</code>.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - blurring kernel size.<DD><CODE>anchor</CODE> - anchor point; default value <code>Point(-1,-1)</code> means
that the anchor is at the kernel center.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#blur">org.opencv.imgproc.Imgproc.blur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><!-- --></A><H3>
blur</H3>
<PRE>
public static void <B>blur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int borderType)</PRE>
<DL>
<DD><p>Blurs an image using the normalized box filter.</p>
<p>The function smoothes an image using the kernel:</p>
<p><em>K = 1/(ksize.width*ksize.height) 1 1 1 *s 1 1
1 1 1 *s 1 1..................
1 1 1 *s 1 1
</em></p>
<p>The call <code>blur(src, dst, ksize, anchor, borderType)</code> is equivalent
to <code>boxFilter(src, dst, src.type(), anchor, true, borderType)</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; it can have any number of channels, which are
processed independently, but the depth should be <code>CV_8U</code>,
<code>CV_16U</code>, <code>CV_16S</code>, <code>CV_32F</code> or
<code>CV_64F</code>.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - blurring kernel size.<DD><CODE>anchor</CODE> - anchor point; default value <code>Point(-1,-1)</code> means
that the anchor is at the kernel center.<DD><CODE>borderType</CODE> - border mode used to extrapolate pixels outside of the
image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#blur">org.opencv.imgproc.Imgproc.blur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="borderInterpolate(int, int, int)"><!-- --></A><H3>
borderInterpolate</H3>
<PRE>
public static int <B>borderInterpolate</B>(int p,
int len,
int borderType)</PRE>
<DL>
<DD><p>Computes the source location of an extrapolated pixel.</p>
<p>The function computes and returns the coordinate of a donor pixel
corresponding to the specified extrapolated pixel when using the specified
extrapolation border mode. For example, if you use <code>BORDER_WRAP</code>
mode in the horizontal direction, <code>BORDER_REFLECT_101</code> in the
vertical direction and want to compute value of the "virtual" pixel
<code>Point(-5, 100)</code> in a floating-point image <code>img</code>, it
looks like: <code></p>
<p>// C++ code:</p>
<p>float val = img.at<float>(borderInterpolate(100, img.rows, BORDER_REFLECT_101),</p>
<p>borderInterpolate(-5, img.cols, BORDER_WRAP));</p>
<p>Normally, the function is not called directly. It is used inside </code></p>
<p>"FilterEngine" and "copyMakeBorder" to compute tables for quick
extrapolation.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>p</CODE> - 0-based coordinate of the extrapolated pixel along one of the axes,
likely <0 or >= <code>len</code>.<DD><CODE>len</CODE> - Length of the array along the corresponding axis.<DD><CODE>borderType</CODE> - Border type, one of the <code>BORDER_*</code>, except for
<code>BORDER_TRANSPARENT</code> and <code>BORDER_ISOLATED</code>. When
<code>borderType==BORDER_CONSTANT</code>, the function always returns -1,
regardless of <code>p</code> and <code>len</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#borderinterpolate">org.opencv.imgproc.Imgproc.borderInterpolate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#copyMakeBorder(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, int, org.opencv.core.Scalar)"><CODE>copyMakeBorder(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="boundingRect(org.opencv.core.MatOfPoint)"><!-- --></A><H3>
boundingRect</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> <B>boundingRect</B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> points)</PRE>
<DL>
<DD><p>Calculates the up-right bounding rectangle of a point set.</p>
<p>The function calculates and returns the minimal up-right bounding rectangle
for the specified point set.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input 2D point set, stored in <code>std.vector</code> or
<code>Mat</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#boundingrect">org.opencv.imgproc.Imgproc.boundingRect</a></DL>
</DD>
</DL>
<HR>
<A NAME="boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size)"><!-- --></A><H3>
boxFilter</H3>
<PRE>
public static void <B>boxFilter</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize)</PRE>
<DL>
<DD><p>Blurs an image using the box filter.</p>
<p>The function smoothes an image using the kernel:</p>
<p><em>K = alpha 1 1 1 *s 1 1
1 1 1 *s 1 1..................
1 1 1 *s 1 1 </em></p>
<p>where</p>
<p><em>alpha = 1/(ksize.width*ksize.height) when normalize=true; 1
otherwise</em></p>
<p>Unnormalized box filter is useful for computing various integral
characteristics over each pixel neighborhood, such as covariance matrices of
image derivatives (used in dense optical flow algorithms, and so on). If you
need to compute pixel sums over variable-size windows, use "integral".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ddepth</CODE> - a ddepth<DD><CODE>ksize</CODE> - blurring kernel size.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#boxfilter">org.opencv.imgproc.Imgproc.boxFilter</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#integral(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>integral(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean)"><!-- --></A><H3>
boxFilter</H3>
<PRE>
public static void <B>boxFilter</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
boolean normalize)</PRE>
<DL>
<DD><p>Blurs an image using the box filter.</p>
<p>The function smoothes an image using the kernel:</p>
<p><em>K = alpha 1 1 1 *s 1 1
1 1 1 *s 1 1..................
1 1 1 *s 1 1 </em></p>
<p>where</p>
<p><em>alpha = 1/(ksize.width*ksize.height) when normalize=true; 1
otherwise</em></p>
<p>Unnormalized box filter is useful for computing various integral
characteristics over each pixel neighborhood, such as covariance matrices of
image derivatives (used in dense optical flow algorithms, and so on). If you
need to compute pixel sums over variable-size windows, use "integral".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ddepth</CODE> - a ddepth<DD><CODE>ksize</CODE> - blurring kernel size.<DD><CODE>anchor</CODE> - anchor point; default value <code>Point(-1,-1)</code> means
that the anchor is at the kernel center.<DD><CODE>normalize</CODE> - flag, specifying whether the kernel is normalized by its
area or not.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#boxfilter">org.opencv.imgproc.Imgproc.boxFilter</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#integral(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>integral(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><!-- --></A><H3>
boxFilter</H3>
<PRE>
public static void <B>boxFilter</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
boolean normalize,
int borderType)</PRE>
<DL>
<DD><p>Blurs an image using the box filter.</p>
<p>The function smoothes an image using the kernel:</p>
<p><em>K = alpha 1 1 1 *s 1 1
1 1 1 *s 1 1..................
1 1 1 *s 1 1 </em></p>
<p>where</p>
<p><em>alpha = 1/(ksize.width*ksize.height) when normalize=true; 1
otherwise</em></p>
<p>Unnormalized box filter is useful for computing various integral
characteristics over each pixel neighborhood, such as covariance matrices of
image derivatives (used in dense optical flow algorithms, and so on). If you
need to compute pixel sums over variable-size windows, use "integral".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ddepth</CODE> - a ddepth<DD><CODE>ksize</CODE> - blurring kernel size.<DD><CODE>anchor</CODE> - anchor point; default value <code>Point(-1,-1)</code> means
that the anchor is at the kernel center.<DD><CODE>normalize</CODE> - flag, specifying whether the kernel is normalized by its
area or not.<DD><CODE>borderType</CODE> - border mode used to extrapolate pixels outside of the
image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#boxfilter">org.opencv.imgproc.Imgproc.boxFilter</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#integral(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>integral(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="calcBackProject(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfFloat, double)"><!-- --></A><H3>
calcBackProject</H3>
<PRE>
public static void <B>calcBackProject</B>(java.util.List<<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A>> images,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> channels,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hist,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/MatOfFloat.html" title="class in org.opencv.core">MatOfFloat</A> ranges,
double scale)</PRE>
<DL>
<DD><p>Calculates the back projection of a histogram.</p>
<p>The functions <code>calcBackProject</code> calculate the back project of the
histogram. That is, similarly to <code>calcHist</code>, at each location
<code>(x, y)</code> the function collects the values from the selected
channels in the input images and finds the corresponding histogram bin. But
instead of incrementing it, the function reads the bin value, scales it by
<code>scale</code>, and stores in <code>backProject(x,y)</code>. In terms of
statistics, the function computes probability of each element value in
respect with the empirical probability distribution represented by the
histogram. See how, for example, you can find and track a bright-colored
object in a scene:</p>
<ul>
<li> Before tracking, show the object to the camera so that it covers
almost the whole frame. Calculate a hue histogram. The histogram may have
strong maximums, corresponding to the dominant colors in the object.
<li> When tracking, calculate a back projection of a hue plane of each
input video frame using that pre-computed histogram. Threshold the back
projection to suppress weak colors. It may also make sense to suppress pixels
with non-sufficient color saturation and too dark or too bright pixels.
<li> Find connected components in the resulting picture and choose, for
example, the largest component.
</ul>
<p>This is an approximate algorithm of the "CamShift" color object tracker.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>images</CODE> - Source arrays. They all should have the same depth,
<code>CV_8U</code> or <code>CV_32F</code>, and the same size. Each of them
can have an arbitrary number of channels.<DD><CODE>channels</CODE> - The list of channels used to compute the back projection. The
number of channels must match the histogram dimensionality. The first array
channels are numerated from 0 to <code>images[0].channels()-1</code>, the
second array channels are counted from <code>images[0].channels()</code> to
<code>images[0].channels() + images[1].channels()-1</code>, and so on.<DD><CODE>hist</CODE> - Input histogram that can be dense or sparse.<DD><CODE>dst</CODE> - a dst<DD><CODE>ranges</CODE> - Array of arrays of the histogram bin boundaries in each
dimension. See "calcHist".<DD><CODE>scale</CODE> - Optional scale factor for the output back projection.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/histograms.html#calcbackproject">org.opencv.imgproc.Imgproc.calcBackProject</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#calcHist(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfInt, org.opencv.core.MatOfFloat, boolean)"><CODE>calcHist(java.util.List<org.opencv.core.Mat>, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfInt, org.opencv.core.MatOfFloat, boolean)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="calcHist(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfInt, org.opencv.core.MatOfFloat)"><!-- --></A><H3>
calcHist</H3>
<PRE>
public static void <B>calcHist</B>(java.util.List<<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A>> images,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> channels,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hist,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> histSize,
<A HREF="../../../org/opencv/core/MatOfFloat.html" title="class in org.opencv.core">MatOfFloat</A> ranges)</PRE>
<DL>
<DD><p>Calculates a histogram of a set of arrays.</p>
<p>The functions <code>calcHist</code> calculate the histogram of one or more
arrays. The elements of a tuple used to increment a histogram bin are taken
from the correspondinginput arrays at the same location. The sample below
shows how to compute a 2D Hue-Saturation histogram for a color image.
<code></p>
<p>// C++ code:</p>
<p>#include <cv.h></p>
<p>#include <highgui.h></p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src, hsv;</p>
<p>if(argc != 2 || !(src=imread(argv[1], 1)).data)</p>
<p>return -1;</p>
<p>cvtColor(src, hsv, CV_BGR2HSV);</p>
<p>// Quantize the hue to 30 levels</p>
<p>// and the saturation to 32 levels</p>
<p>int hbins = 30, sbins = 32;</p>
<p>int histSize[] = {hbins, sbins};</p>
<p>// hue varies from 0 to 179, see cvtColor</p>
<p>float hranges[] = { 0, 180 };</p>
<p>// saturation varies from 0 (black-gray-white) to</p>
<p>// 255 (pure spectrum color)</p>
<p>float sranges[] = { 0, 256 };</p>
<p>const float* ranges[] = { hranges, sranges };</p>
<p>MatND hist;</p>
<p>// we compute the histogram from the 0-th and 1-st channels</p>
<p>int channels[] = {0, 1};</p>
<p>calcHist(&hsv, 1, channels, Mat(), // do not use mask</p>
<p>hist, 2, histSize, ranges,</p>
<p>true, // the histogram is uniform</p>
<p>false);</p>
<p>double maxVal=0;</p>
<p>minMaxLoc(hist, 0, &maxVal, 0, 0);</p>
<p>int scale = 10;</p>
<p>Mat histImg = Mat.zeros(sbins*scale, hbins*10, CV_8UC3);</p>
<p>for(int h = 0; h < hbins; h++)</p>
<p>for(int s = 0; s < sbins; s++)</p>
<p>float binVal = hist.at<float>(h, s);</p>
<p>int intensity = cvRound(binVal*255/maxVal);</p>
<p>rectangle(histImg, Point(h*scale, s*scale),</p>
<p>Point((h+1)*scale - 1, (s+1)*scale - 1),</p>
<p>Scalar.all(intensity),</p>
<p>CV_FILLED);</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>namedWindow("H-S Histogram", 1);</p>
<p>imshow("H-S Histogram", histImg);</p>
<p>waitKey();</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>images</CODE> - Source arrays. They all should have the same depth,
<code>CV_8U</code> or <code>CV_32F</code>, and the same size. Each of them
can have an arbitrary number of channels.<DD><CODE>channels</CODE> - List of the <code>dims</code> channels used to compute the
histogram. The first array channels are numerated from 0 to <code>images[0].channels()-1</code>,
the second array channels are counted from <code>images[0].channels()</code>
to <code>images[0].channels() + images[1].channels()-1</code>, and so on.<DD><CODE>mask</CODE> - Optional mask. If the matrix is not empty, it must be an 8-bit
array of the same size as <code>images[i]</code>. The non-zero mask elements
mark the array elements counted in the histogram.<DD><CODE>hist</CODE> - Output histogram, which is a dense or sparse <code>dims</code>
-dimensional array.<DD><CODE>histSize</CODE> - Array of histogram sizes in each dimension.<DD><CODE>ranges</CODE> - Array of the <code>dims</code> arrays of the histogram bin
boundaries in each dimension. When the histogram is uniform (<code>uniform</code>
=true), then for each dimension <code>i</code> it is enough to specify the
lower (inclusive) boundary <em>L_0</em> of the 0-th histogram bin and the
upper (exclusive) boundary <em>U_(histSize[i]-1)</em> for the last histogram
bin <code>histSize[i]-1</code>. That is, in case of a uniform histogram each
of <code>ranges[i]</code> is an array of 2 elements. When the histogram is
not uniform (<code>uniform=false</code>), then each of <code>ranges[i]</code>
contains <code>histSize[i]+1</code> elements: <em>L_0, U_0=L_1, U_1=L_2,...,
U_(histSize[i]-2)=L_(histSize[i]-1), U_(histSize[i]-1)</em>. The array
elements, that are not between <em>L_0</em> and <em>U_(histSize[i]-1)</em>,
are not counted in the histogram.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/histograms.html#calchist">org.opencv.imgproc.Imgproc.calcHist</a></DL>
</DD>
</DL>
<HR>
<A NAME="calcHist(java.util.List, org.opencv.core.MatOfInt, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfInt, org.opencv.core.MatOfFloat, boolean)"><!-- --></A><H3>
calcHist</H3>
<PRE>
public static void <B>calcHist</B>(java.util.List<<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A>> images,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> channels,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hist,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> histSize,
<A HREF="../../../org/opencv/core/MatOfFloat.html" title="class in org.opencv.core">MatOfFloat</A> ranges,
boolean accumulate)</PRE>
<DL>
<DD><p>Calculates a histogram of a set of arrays.</p>
<p>The functions <code>calcHist</code> calculate the histogram of one or more
arrays. The elements of a tuple used to increment a histogram bin are taken
from the correspondinginput arrays at the same location. The sample below
shows how to compute a 2D Hue-Saturation histogram for a color image.
<code></p>
<p>// C++ code:</p>
<p>#include <cv.h></p>
<p>#include <highgui.h></p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src, hsv;</p>
<p>if(argc != 2 || !(src=imread(argv[1], 1)).data)</p>
<p>return -1;</p>
<p>cvtColor(src, hsv, CV_BGR2HSV);</p>
<p>// Quantize the hue to 30 levels</p>
<p>// and the saturation to 32 levels</p>
<p>int hbins = 30, sbins = 32;</p>
<p>int histSize[] = {hbins, sbins};</p>
<p>// hue varies from 0 to 179, see cvtColor</p>
<p>float hranges[] = { 0, 180 };</p>
<p>// saturation varies from 0 (black-gray-white) to</p>
<p>// 255 (pure spectrum color)</p>
<p>float sranges[] = { 0, 256 };</p>
<p>const float* ranges[] = { hranges, sranges };</p>
<p>MatND hist;</p>
<p>// we compute the histogram from the 0-th and 1-st channels</p>
<p>int channels[] = {0, 1};</p>
<p>calcHist(&hsv, 1, channels, Mat(), // do not use mask</p>
<p>hist, 2, histSize, ranges,</p>
<p>true, // the histogram is uniform</p>
<p>false);</p>
<p>double maxVal=0;</p>
<p>minMaxLoc(hist, 0, &maxVal, 0, 0);</p>
<p>int scale = 10;</p>
<p>Mat histImg = Mat.zeros(sbins*scale, hbins*10, CV_8UC3);</p>
<p>for(int h = 0; h < hbins; h++)</p>
<p>for(int s = 0; s < sbins; s++)</p>
<p>float binVal = hist.at<float>(h, s);</p>
<p>int intensity = cvRound(binVal*255/maxVal);</p>
<p>rectangle(histImg, Point(h*scale, s*scale),</p>
<p>Point((h+1)*scale - 1, (s+1)*scale - 1),</p>
<p>Scalar.all(intensity),</p>
<p>CV_FILLED);</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>namedWindow("H-S Histogram", 1);</p>
<p>imshow("H-S Histogram", histImg);</p>
<p>waitKey();</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>images</CODE> - Source arrays. They all should have the same depth,
<code>CV_8U</code> or <code>CV_32F</code>, and the same size. Each of them
can have an arbitrary number of channels.<DD><CODE>channels</CODE> - List of the <code>dims</code> channels used to compute the
histogram. The first array channels are numerated from 0 to <code>images[0].channels()-1</code>,
the second array channels are counted from <code>images[0].channels()</code>
to <code>images[0].channels() + images[1].channels()-1</code>, and so on.<DD><CODE>mask</CODE> - Optional mask. If the matrix is not empty, it must be an 8-bit
array of the same size as <code>images[i]</code>. The non-zero mask elements
mark the array elements counted in the histogram.<DD><CODE>hist</CODE> - Output histogram, which is a dense or sparse <code>dims</code>
-dimensional array.<DD><CODE>histSize</CODE> - Array of histogram sizes in each dimension.<DD><CODE>ranges</CODE> - Array of the <code>dims</code> arrays of the histogram bin
boundaries in each dimension. When the histogram is uniform (<code>uniform</code>
=true), then for each dimension <code>i</code> it is enough to specify the
lower (inclusive) boundary <em>L_0</em> of the 0-th histogram bin and the
upper (exclusive) boundary <em>U_(histSize[i]-1)</em> for the last histogram
bin <code>histSize[i]-1</code>. That is, in case of a uniform histogram each
of <code>ranges[i]</code> is an array of 2 elements. When the histogram is
not uniform (<code>uniform=false</code>), then each of <code>ranges[i]</code>
contains <code>histSize[i]+1</code> elements: <em>L_0, U_0=L_1, U_1=L_2,...,
U_(histSize[i]-2)=L_(histSize[i]-1), U_(histSize[i]-1)</em>. The array
elements, that are not between <em>L_0</em> and <em>U_(histSize[i]-1)</em>,
are not counted in the histogram.<DD><CODE>accumulate</CODE> - Accumulation flag. If it is set, the histogram is not
cleared in the beginning when it is allocated. This feature enables you to
compute a single histogram from several sets of arrays, or to update the
histogram in time.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/histograms.html#calchist">org.opencv.imgproc.Imgproc.calcHist</a></DL>
</DD>
</DL>
<HR>
<A NAME="Canny(org.opencv.core.Mat, org.opencv.core.Mat, double, double)"><!-- --></A><H3>
Canny</H3>
<PRE>
public static void <B>Canny</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> edges,
double threshold1,
double threshold2)</PRE>
<DL>
<DD><p>Finds edges in an image using the [Canny86] algorithm.</p>
<p>The function finds edges in the input image <code>image</code> and marks them
in the output map <code>edges</code> using the Canny algorithm. The smallest
value between <code>threshold1</code> and <code>threshold2</code> is used for
edge linking. The largest value is used to find initial segments of strong
edges. See http://en.wikipedia.org/wiki/Canny_edge_detector</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - single-channel 8-bit input image.<DD><CODE>edges</CODE> - output edge map; it has the same size and type as
<code>image</code>.<DD><CODE>threshold1</CODE> - first threshold for the hysteresis procedure.<DD><CODE>threshold2</CODE> - second threshold for the hysteresis procedure.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#canny">org.opencv.imgproc.Imgproc.Canny</a></DL>
</DD>
</DL>
<HR>
<A NAME="Canny(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, boolean)"><!-- --></A><H3>
Canny</H3>
<PRE>
public static void <B>Canny</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> edges,
double threshold1,
double threshold2,
int apertureSize,
boolean L2gradient)</PRE>
<DL>
<DD><p>Finds edges in an image using the [Canny86] algorithm.</p>
<p>The function finds edges in the input image <code>image</code> and marks them
in the output map <code>edges</code> using the Canny algorithm. The smallest
value between <code>threshold1</code> and <code>threshold2</code> is used for
edge linking. The largest value is used to find initial segments of strong
edges. See http://en.wikipedia.org/wiki/Canny_edge_detector</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - single-channel 8-bit input image.<DD><CODE>edges</CODE> - output edge map; it has the same size and type as
<code>image</code>.<DD><CODE>threshold1</CODE> - first threshold for the hysteresis procedure.<DD><CODE>threshold2</CODE> - second threshold for the hysteresis procedure.<DD><CODE>apertureSize</CODE> - aperture size for the "Sobel" operator.<DD><CODE>L2gradient</CODE> - a flag, indicating whether a more accurate <em>L_2</em>
norm <em>=sqrt((dI/dx)^2 + (dI/dy)^2)</em> should be used to calculate the
image gradient magnitude (<code>L2gradient=true</code>), or whether the
default <em>L_1</em> norm <em>=|dI/dx|+|dI/dy|</em> is enough
(<code>L2gradient=false</code>).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#canny">org.opencv.imgproc.Imgproc.Canny</a></DL>
</DD>
</DL>
<HR>
<A NAME="compareHist(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
compareHist</H3>
<PRE>
public static double <B>compareHist</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> H1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> H2,
int method)</PRE>
<DL>
<DD><p>Compares two histograms.</p>
<p>The functions <code>compareHist</code> compare two dense or two sparse
histograms using the specified method:</p>
<ul>
<li> Correlation (<code>method=CV_COMP_CORREL</code>)
</ul>
<p><em>d(H_1,H_2) = (sum_I(H_1(I) - H_1")(H_2(I) - H_2"))/(sqrt(sum_I(H_1(I) -
H_1")^2 sum_I(H_2(I) - H_2")^2))</em></p>
<p>where</p>
<p><em>H_k" = 1/(N) sum _J H_k(J)</em></p>
<p>and <em>N</em> is a total number of histogram bins.</p>
<ul>
<li> Chi-Square (<code>method=CV_COMP_CHISQR</code>)
</ul>
<p><em>d(H_1,H_2) = sum _I((H_1(I)-H_2(I))^2)/(H_1(I))</em></p>
<ul>
<li> Intersection (<code>method=CV_COMP_INTERSECT</code>)
</ul>
<p><em>d(H_1,H_2) = sum _I min(H_1(I), H_2(I))</em></p>
<ul>
<li> Bhattacharyya distance (<code>method=CV_COMP_BHATTACHARYYA</code> or
<code>method=CV_COMP_HELLINGER</code>). In fact, OpenCV computes Hellinger
distance, which is related to Bhattacharyya coefficient.
</ul>
<p><em>d(H_1,H_2) = sqrt(1 - frac(1)(sqrt(H_1" H_2" N^2)) sum_I sqrt(H_1(I) *
H_2(I)))</em></p>
<p>The function returns <em>d(H_1, H_2)</em>.</p>
<p>While the function works well with 1-, 2-, 3-dimensional dense histograms, it
may not be suitable for high-dimensional sparse histograms. In such
histograms, because of aliasing and sampling problems, the coordinates of
non-zero histogram bins can slightly shift. To compare such histograms or
more general sparse configurations of weighted points, consider using the
"EMD" function.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>H1</CODE> - First compared histogram.<DD><CODE>H2</CODE> - Second compared histogram of the same size as <code>H1</code>.<DD><CODE>method</CODE> - Comparison method that could be one of the following:
<ul>
<li> CV_COMP_CORREL Correlation
<li> CV_COMP_CHISQR Chi-Square
<li> CV_COMP_INTERSECT Intersection
<li> CV_COMP_BHATTACHARYYA Bhattacharyya distance
<li> CV_COMP_HELLINGER Synonym for <code>CV_COMP_BHATTACHARYYA</code>
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/histograms.html#comparehist">org.opencv.imgproc.Imgproc.compareHist</a></DL>
</DD>
</DL>
<HR>
<A NAME="contourArea(org.opencv.core.Mat)"><!-- --></A><H3>
contourArea</H3>
<PRE>
public static double <B>contourArea</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour)</PRE>
<DL>
<DD><p>Calculates a contour area.</p>
<p>The function computes a contour area. Similarly to "moments", the area is
computed using the Green formula. Thus, the returned area and the number of
non-zero pixels, if you draw the contour using "drawContours" or "fillPoly",
can be different.
Also, the function will most certainly give a wrong results for contours with
self-intersections.
Example: <code></p>
<p>// C++ code:</p>
<p>vector<Point> contour;</p>
<p>contour.push_back(Point2f(0, 0));</p>
<p>contour.push_back(Point2f(10, 0));</p>
<p>contour.push_back(Point2f(10, 10));</p>
<p>contour.push_back(Point2f(5, 4));</p>
<p>double area0 = contourArea(contour);</p>
<p>vector<Point> approx;</p>
<p>approxPolyDP(contour, approx, 5, true);</p>
<p>double area1 = contourArea(approx);</p>
<p>cout << "area0 =" << area0 << endl <<</p>
<p>"area1 =" << area1 << endl <<</p>
<p>"approx poly vertices" << approx.size() << endl;</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>contour</CODE> - Input vector of 2D points (contour vertices), stored in
<code>std.vector</code> or <code>Mat</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#contourarea">org.opencv.imgproc.Imgproc.contourArea</a></DL>
</DD>
</DL>
<HR>
<A NAME="contourArea(org.opencv.core.Mat, boolean)"><!-- --></A><H3>
contourArea</H3>
<PRE>
public static double <B>contourArea</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour,
boolean oriented)</PRE>
<DL>
<DD><p>Calculates a contour area.</p>
<p>The function computes a contour area. Similarly to "moments", the area is
computed using the Green formula. Thus, the returned area and the number of
non-zero pixels, if you draw the contour using "drawContours" or "fillPoly",
can be different.
Also, the function will most certainly give a wrong results for contours with
self-intersections.
Example: <code></p>
<p>// C++ code:</p>
<p>vector<Point> contour;</p>
<p>contour.push_back(Point2f(0, 0));</p>
<p>contour.push_back(Point2f(10, 0));</p>
<p>contour.push_back(Point2f(10, 10));</p>
<p>contour.push_back(Point2f(5, 4));</p>
<p>double area0 = contourArea(contour);</p>
<p>vector<Point> approx;</p>
<p>approxPolyDP(contour, approx, 5, true);</p>
<p>double area1 = contourArea(approx);</p>
<p>cout << "area0 =" << area0 << endl <<</p>
<p>"area1 =" << area1 << endl <<</p>
<p>"approx poly vertices" << approx.size() << endl;</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>contour</CODE> - Input vector of 2D points (contour vertices), stored in
<code>std.vector</code> or <code>Mat</code>.<DD><CODE>oriented</CODE> - Oriented area flag. If it is true, the function returns a
signed area value, depending on the contour orientation (clockwise or
counter-clockwise). Using this feature you can determine orientation of a
contour by taking the sign of an area. By default, the parameter is
<code>false</code>, which means that the absolute value is returned.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#contourarea">org.opencv.imgproc.Imgproc.contourArea</a></DL>
</DD>
</DL>
<HR>
<A NAME="convertMaps(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
convertMaps</H3>
<PRE>
public static void <B>convertMaps</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap2,
int dstmap1type)</PRE>
<DL>
<DD><p>Converts image transformation maps from one representation to another.</p>
<p>The function converts a pair of maps for "remap" from one representation to
another. The following options (<code>(map1.type(), map2.type())</code>
<em>-></em> <code>(dstmap1.type(), dstmap2.type())</code>) are supported:</p>
<ul>
<li> <em>(CV_32FC1, CV_32FC1) -> (CV_16SC2, CV_16UC1)</em>. This is the
most frequently used conversion operation, in which the original
floating-point maps (see "remap") are converted to a more compact and much
faster fixed-point representation. The first output array contains the
rounded coordinates and the second array (created only when <code>nninterpolation=false</code>)
contains indices in the interpolation tables.
<li> <em>(CV_32FC2) -> (CV_16SC2, CV_16UC1)</em>. The same as above but the
original maps are stored in one 2-channel matrix.
<li> Reverse conversion. Obviously, the reconstructed floating-point maps
will not be exactly the same as the originals.
</ul>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>map1</CODE> - The first input map of type <code>CV_16SC2</code>,
<code>CV_32FC1</code>, or <code>CV_32FC2</code>.<DD><CODE>map2</CODE> - The second input map of type <code>CV_16UC1</code>,
<code>CV_32FC1</code>, or none (empty matrix), respectively.<DD><CODE>dstmap1</CODE> - The first output map that has the type <code>dstmap1type</code>
and the same size as <code>src</code>.<DD><CODE>dstmap2</CODE> - The second output map.<DD><CODE>dstmap1type</CODE> - Type of the first output map that should be
<code>CV_16SC2</code>, <code>CV_32FC1</code>, or <code>CV_32FC2</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#convertmaps">org.opencv.imgproc.Imgproc.convertMaps</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#initUndistortRectifyMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>initUndistortRectifyMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="convertMaps(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, boolean)"><!-- --></A><H3>
convertMaps</H3>
<PRE>
public static void <B>convertMaps</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dstmap2,
int dstmap1type,
boolean nninterpolation)</PRE>
<DL>
<DD><p>Converts image transformation maps from one representation to another.</p>
<p>The function converts a pair of maps for "remap" from one representation to
another. The following options (<code>(map1.type(), map2.type())</code>
<em>-></em> <code>(dstmap1.type(), dstmap2.type())</code>) are supported:</p>
<ul>
<li> <em>(CV_32FC1, CV_32FC1) -> (CV_16SC2, CV_16UC1)</em>. This is the
most frequently used conversion operation, in which the original
floating-point maps (see "remap") are converted to a more compact and much
faster fixed-point representation. The first output array contains the
rounded coordinates and the second array (created only when <code>nninterpolation=false</code>)
contains indices in the interpolation tables.
<li> <em>(CV_32FC2) -> (CV_16SC2, CV_16UC1)</em>. The same as above but the
original maps are stored in one 2-channel matrix.
<li> Reverse conversion. Obviously, the reconstructed floating-point maps
will not be exactly the same as the originals.
</ul>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>map1</CODE> - The first input map of type <code>CV_16SC2</code>,
<code>CV_32FC1</code>, or <code>CV_32FC2</code>.<DD><CODE>map2</CODE> - The second input map of type <code>CV_16UC1</code>,
<code>CV_32FC1</code>, or none (empty matrix), respectively.<DD><CODE>dstmap1</CODE> - The first output map that has the type <code>dstmap1type</code>
and the same size as <code>src</code>.<DD><CODE>dstmap2</CODE> - The second output map.<DD><CODE>dstmap1type</CODE> - Type of the first output map that should be
<code>CV_16SC2</code>, <code>CV_32FC1</code>, or <code>CV_32FC2</code>.<DD><CODE>nninterpolation</CODE> - Flag indicating whether the fixed-point maps are used
for the nearest-neighbor or for a more complex interpolation.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#convertmaps">org.opencv.imgproc.Imgproc.convertMaps</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#initUndistortRectifyMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>initUndistortRectifyMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="convexHull(org.opencv.core.MatOfPoint, org.opencv.core.MatOfInt)"><!-- --></A><H3>
convexHull</H3>
<PRE>
public static void <B>convexHull</B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> points,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> hull)</PRE>
<DL>
<DD><p>Finds the convex hull of a point set.</p>
<p>The functions find the convex hull of a 2D point set using the Sklansky's
algorithm [Sklansky82] that has *O(N logN)* complexity in the current
implementation. See the OpenCV sample <code>convexhull.cpp</code> that
demonstrates the usage of different function variants.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input 2D point set, stored in <code>std.vector</code> or
<code>Mat</code>.<DD><CODE>hull</CODE> - Output convex hull. It is either an integer vector of indices or
vector of points. In the first case, the <code>hull</code> elements are
0-based indices of the convex hull points in the original array (since the
set of convex hull points is a subset of the original point set). In the
second case, <code>hull</code> elements are the convex hull points
themselves.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#convexhull">org.opencv.imgproc.Imgproc.convexHull</a></DL>
</DD>
</DL>
<HR>
<A NAME="convexHull(org.opencv.core.MatOfPoint, org.opencv.core.MatOfInt, boolean)"><!-- --></A><H3>
convexHull</H3>
<PRE>
public static void <B>convexHull</B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> points,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> hull,
boolean clockwise)</PRE>
<DL>
<DD><p>Finds the convex hull of a point set.</p>
<p>The functions find the convex hull of a 2D point set using the Sklansky's
algorithm [Sklansky82] that has *O(N logN)* complexity in the current
implementation. See the OpenCV sample <code>convexhull.cpp</code> that
demonstrates the usage of different function variants.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input 2D point set, stored in <code>std.vector</code> or
<code>Mat</code>.<DD><CODE>hull</CODE> - Output convex hull. It is either an integer vector of indices or
vector of points. In the first case, the <code>hull</code> elements are
0-based indices of the convex hull points in the original array (since the
set of convex hull points is a subset of the original point set). In the
second case, <code>hull</code> elements are the convex hull points
themselves.<DD><CODE>clockwise</CODE> - Orientation flag. If it is true, the output convex hull is
oriented clockwise. Otherwise, it is oriented counter-clockwise. The usual
screen coordinate system is assumed so that the origin is at the top-left
corner, x axis is oriented to the right, and y axis is oriented downwards.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#convexhull">org.opencv.imgproc.Imgproc.convexHull</a></DL>
</DD>
</DL>
<HR>
<A NAME="convexityDefects(org.opencv.core.MatOfPoint, org.opencv.core.MatOfInt, org.opencv.core.MatOfInt4)"><!-- --></A><H3>
convexityDefects</H3>
<PRE>
public static void <B>convexityDefects</B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> contour,
<A HREF="../../../org/opencv/core/MatOfInt.html" title="class in org.opencv.core">MatOfInt</A> convexhull,
<A HREF="../../../org/opencv/core/MatOfInt4.html" title="class in org.opencv.core">MatOfInt4</A> convexityDefects)</PRE>
<DL>
<DD><p>Finds the convexity defects of a contour.</p>
<p>The function finds all convexity defects of the input contour and returns a
sequence of the <code>CvConvexityDefect</code> structures, where
<code>CvConvexityDetect</code> is defined as: <code></p>
<p>// C++ code:</p>
<p>struct CvConvexityDefect</p>
<p>CvPoint* start; // point of the contour where the defect begins</p>
<p>CvPoint* end; // point of the contour where the defect ends</p>
<p>CvPoint* depth_point; // the farthest from the convex hull point within the
defect</p>
<p>float depth; // distance between the farthest point and the convex hull</p>
<p>};</p>
<p>The figure below displays convexity defects of a hand contour: </code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>contour</CODE> - Input contour.<DD><CODE>convexhull</CODE> - Convex hull obtained using "convexHull" that should contain
indices of the contour points that make the hull.<DD><CODE>convexityDefects</CODE> - The output vector of convexity defects. In C++ and
the new Python/Java interface each convexity defect is represented as
4-element integer vector (a.k.a. <code>cv.Vec4i</code>): <code>(start_index,
end_index, farthest_pt_index, fixpt_depth)</code>, where indices are 0-based
indices in the original contour of the convexity defect beginning, end and
the farthest point, and <code>fixpt_depth</code> is fixed-point approximation
(with 8 fractional bits) of the distance between the farthest contour point
and the hull. That is, to get the floating-point value of the depth will be
<code>fixpt_depth/256.0</code>. In C interface convexity defect is
represented by <code>CvConvexityDefect</code> structure - see below.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#convexitydefects">org.opencv.imgproc.Imgproc.convexityDefects</a></DL>
</DD>
</DL>
<HR>
<A NAME="copyMakeBorder(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, int)"><!-- --></A><H3>
copyMakeBorder</H3>
<PRE>
public static void <B>copyMakeBorder</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int top,
int bottom,
int left,
int right,
int borderType)</PRE>
<DL>
<DD><p>Forms a border around an image.</p>
<p>The function copies the source image into the middle of the destination
image. The areas to the left, to the right, above and below the copied source
image will be filled with extrapolated pixels. This is not what
"FilterEngine" or filtering functions based on it do (they extrapolate pixels
on-fly), but what other more complex functions, including your own, may do to
simplify image boundary handling.
The function supports the mode when <code>src</code> is already in the middle
of <code>dst</code>. In this case, the function does not copy
<code>src</code> itself but simply constructs the border, for example: <code></p>
<p>// C++ code:</p>
<p>// let border be the same in all directions</p>
<p>int border=2;</p>
<p>// constructs a larger image to fit both the image and the border</p>
<p>Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());</p>
<p>// select the middle part of it w/o copying data</p>
<p>Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));</p>
<p>// convert image from RGB to grayscale</p>
<p>cvtColor(rgb, gray, CV_RGB2GRAY);</p>
<p>// form a border in-place</p>
<p>copyMakeBorder(gray, gray_buf, border, border,</p>
<p>border, border, BORDER_REPLICATE);</p>
<p>// now do some custom filtering......</p>
<p>Note: </code></p>
<p>When the source image is a part (ROI) of a bigger image, the function will
try to use the pixels outside of the ROI to form a border. To disable this
feature and always do extrapolation, as if <code>src</code> was not a ROI,
use <code>borderType | BORDER_ISOLATED</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same type as <code>src</code> and the
size <code>Size(src.cols+left+right, src.rows+top+bottom)</code>.<DD><CODE>top</CODE> - a top<DD><CODE>bottom</CODE> - a bottom<DD><CODE>left</CODE> - a left<DD><CODE>right</CODE> - Parameter specifying how many pixels in each direction from the
source image rectangle to extrapolate. For example, <code>top=1, bottom=1,
left=1, right=1</code> mean that 1 pixel-wide border needs to be built.<DD><CODE>borderType</CODE> - Border type. See "borderInterpolate" for details.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#copymakeborder">org.opencv.imgproc.Imgproc.copyMakeBorder</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#borderInterpolate(int, int, int)"><CODE>borderInterpolate(int, int, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="copyMakeBorder(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
copyMakeBorder</H3>
<PRE>
public static void <B>copyMakeBorder</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int top,
int bottom,
int left,
int right,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> value)</PRE>
<DL>
<DD><p>Forms a border around an image.</p>
<p>The function copies the source image into the middle of the destination
image. The areas to the left, to the right, above and below the copied source
image will be filled with extrapolated pixels. This is not what
"FilterEngine" or filtering functions based on it do (they extrapolate pixels
on-fly), but what other more complex functions, including your own, may do to
simplify image boundary handling.
The function supports the mode when <code>src</code> is already in the middle
of <code>dst</code>. In this case, the function does not copy
<code>src</code> itself but simply constructs the border, for example: <code></p>
<p>// C++ code:</p>
<p>// let border be the same in all directions</p>
<p>int border=2;</p>
<p>// constructs a larger image to fit both the image and the border</p>
<p>Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());</p>
<p>// select the middle part of it w/o copying data</p>
<p>Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));</p>
<p>// convert image from RGB to grayscale</p>
<p>cvtColor(rgb, gray, CV_RGB2GRAY);</p>
<p>// form a border in-place</p>
<p>copyMakeBorder(gray, gray_buf, border, border,</p>
<p>border, border, BORDER_REPLICATE);</p>
<p>// now do some custom filtering......</p>
<p>Note: </code></p>
<p>When the source image is a part (ROI) of a bigger image, the function will
try to use the pixels outside of the ROI to form a border. To disable this
feature and always do extrapolation, as if <code>src</code> was not a ROI,
use <code>borderType | BORDER_ISOLATED</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same type as <code>src</code> and the
size <code>Size(src.cols+left+right, src.rows+top+bottom)</code>.<DD><CODE>top</CODE> - a top<DD><CODE>bottom</CODE> - a bottom<DD><CODE>left</CODE> - a left<DD><CODE>right</CODE> - Parameter specifying how many pixels in each direction from the
source image rectangle to extrapolate. For example, <code>top=1, bottom=1,
left=1, right=1</code> mean that 1 pixel-wide border needs to be built.<DD><CODE>borderType</CODE> - Border type. See "borderInterpolate" for details.<DD><CODE>value</CODE> - Border value if <code>borderType==BORDER_CONSTANT</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#copymakeborder">org.opencv.imgproc.Imgproc.copyMakeBorder</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#borderInterpolate(int, int, int)"><CODE>borderInterpolate(int, int, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="cornerEigenValsAndVecs(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
cornerEigenValsAndVecs</H3>
<PRE>
public static void <B>cornerEigenValsAndVecs</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize)</PRE>
<DL>
<DD><p>Calculates eigenvalues and eigenvectors of image blocks for corner detection.</p>
<p>For every pixel <em>p</em>, the function <code>cornerEigenValsAndVecs</code>
considers a <code>blockSize</code> <em>x</em> <code>blockSize</code>
neighborhood <em>S(p)</em>. It calculates the covariation matrix of
derivatives over the neighborhood as:</p>
<p><em>M = sum(by: S(p))(dI/dx)^2 sum(by: S(p))(dI/dx dI/dy)^2
sum(by: S(p))(dI/dx dI/dy)^2 sum(by: S(p))(dI/dy)^2 </em></p>
<p>where the derivatives are computed using the "Sobel" operator.</p>
<p>After that, it finds eigenvectors and eigenvalues of <em>M</em> and stores
them in the destination image as <em>(lambda_1, lambda_2, x_1, y_1, x_2,
y_2)</em> where</p>
<ul>
<li> <em>lambda_1, lambda_2</em> are the non-sorted eigenvalues of
<em>M</em>
<li> <em>x_1, y_1</em> are the eigenvectors corresponding to
<em>lambda_1</em>
<li> <em>x_2, y_2</em> are the eigenvectors corresponding to
<em>lambda_2</em>
</ul>
<p>The output of the function can be used for robust edge or corner detection.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the results. It has the same size as
<code>src</code> and the type <code>CV_32FC(6)</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see details below).<DD><CODE>ksize</CODE> - Aperture parameter for the "Sobel" operator.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornereigenvalsandvecs">org.opencv.imgproc.Imgproc.cornerEigenValsAndVecs</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)"><CODE>cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><CODE>cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="cornerEigenValsAndVecs(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><!-- --></A><H3>
cornerEigenValsAndVecs</H3>
<PRE>
public static void <B>cornerEigenValsAndVecs</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
int borderType)</PRE>
<DL>
<DD><p>Calculates eigenvalues and eigenvectors of image blocks for corner detection.</p>
<p>For every pixel <em>p</em>, the function <code>cornerEigenValsAndVecs</code>
considers a <code>blockSize</code> <em>x</em> <code>blockSize</code>
neighborhood <em>S(p)</em>. It calculates the covariation matrix of
derivatives over the neighborhood as:</p>
<p><em>M = sum(by: S(p))(dI/dx)^2 sum(by: S(p))(dI/dx dI/dy)^2
sum(by: S(p))(dI/dx dI/dy)^2 sum(by: S(p))(dI/dy)^2 </em></p>
<p>where the derivatives are computed using the "Sobel" operator.</p>
<p>After that, it finds eigenvectors and eigenvalues of <em>M</em> and stores
them in the destination image as <em>(lambda_1, lambda_2, x_1, y_1, x_2,
y_2)</em> where</p>
<ul>
<li> <em>lambda_1, lambda_2</em> are the non-sorted eigenvalues of
<em>M</em>
<li> <em>x_1, y_1</em> are the eigenvectors corresponding to
<em>lambda_1</em>
<li> <em>x_2, y_2</em> are the eigenvectors corresponding to
<em>lambda_2</em>
</ul>
<p>The output of the function can be used for robust edge or corner detection.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the results. It has the same size as
<code>src</code> and the type <code>CV_32FC(6)</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see details below).<DD><CODE>ksize</CODE> - Aperture parameter for the "Sobel" operator.<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate".<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornereigenvalsandvecs">org.opencv.imgproc.Imgproc.cornerEigenValsAndVecs</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)"><CODE>cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><CODE>cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double)"><!-- --></A><H3>
cornerHarris</H3>
<PRE>
public static void <B>cornerHarris</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
double k)</PRE>
<DL>
<DD><p>Harris edge detector.</p>
<p>The function runs the Harris edge detector on the image. Similarly to
"cornerMinEigenVal" and "cornerEigenValsAndVecs", for each pixel <em>(x,
y)</em> it calculates a <em>2x2</em> gradient covariance matrix
<em>M^((x,y))</em> over a <em>blockSize x blockSize</em> neighborhood. Then,
it computes the following characteristic:</p>
<p><em>dst(x,y) = det M^((x,y)) - k * (tr M^((x,y)))^2</em></p>
<p>Corners in the image can be found as the local maxima of this response map.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the Harris detector responses. It has the type
<code>CV_32FC1</code> and the same size as <code>src</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see the details on "cornerEigenValsAndVecs").<DD><CODE>ksize</CODE> - Aperture parameter for the "Sobel" operator.<DD><CODE>k</CODE> - Harris detector free parameter. See the formula below.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornerharris">org.opencv.imgproc.Imgproc.cornerHarris</a></DL>
</DD>
</DL>
<HR>
<A NAME="cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)"><!-- --></A><H3>
cornerHarris</H3>
<PRE>
public static void <B>cornerHarris</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
double k,
int borderType)</PRE>
<DL>
<DD><p>Harris edge detector.</p>
<p>The function runs the Harris edge detector on the image. Similarly to
"cornerMinEigenVal" and "cornerEigenValsAndVecs", for each pixel <em>(x,
y)</em> it calculates a <em>2x2</em> gradient covariance matrix
<em>M^((x,y))</em> over a <em>blockSize x blockSize</em> neighborhood. Then,
it computes the following characteristic:</p>
<p><em>dst(x,y) = det M^((x,y)) - k * (tr M^((x,y)))^2</em></p>
<p>Corners in the image can be found as the local maxima of this response map.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the Harris detector responses. It has the type
<code>CV_32FC1</code> and the same size as <code>src</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see the details on "cornerEigenValsAndVecs").<DD><CODE>ksize</CODE> - Aperture parameter for the "Sobel" operator.<DD><CODE>k</CODE> - Harris detector free parameter. See the formula below.<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate".<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornerharris">org.opencv.imgproc.Imgproc.cornerHarris</a></DL>
</DD>
</DL>
<HR>
<A NAME="cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
cornerMinEigenVal</H3>
<PRE>
public static void <B>cornerMinEigenVal</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize)</PRE>
<DL>
<DD><p>Calculates the minimal eigenvalue of gradient matrices for corner detection.</p>
<p>The function is similar to "cornerEigenValsAndVecs" but it calculates and
stores only the minimal eigenvalue of the covariance matrix of derivatives,
that is, <em>min(lambda_1, lambda_2)</em> in terms of the formulae in the
"cornerEigenValsAndVecs" description.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the minimal eigenvalues. It has the type
<code>CV_32FC1</code> and the same size as <code>src</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see the details on "cornerEigenValsAndVecs").<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornermineigenval">org.opencv.imgproc.Imgproc.cornerMinEigenVal</a></DL>
</DD>
</DL>
<HR>
<A NAME="cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
cornerMinEigenVal</H3>
<PRE>
public static void <B>cornerMinEigenVal</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize)</PRE>
<DL>
<DD><p>Calculates the minimal eigenvalue of gradient matrices for corner detection.</p>
<p>The function is similar to "cornerEigenValsAndVecs" but it calculates and
stores only the minimal eigenvalue of the covariance matrix of derivatives,
that is, <em>min(lambda_1, lambda_2)</em> in terms of the formulae in the
"cornerEigenValsAndVecs" description.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the minimal eigenvalues. It has the type
<code>CV_32FC1</code> and the same size as <code>src</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see the details on "cornerEigenValsAndVecs").<DD><CODE>ksize</CODE> - Aperture parameter for the "Sobel" operator.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornermineigenval">org.opencv.imgproc.Imgproc.cornerMinEigenVal</a></DL>
</DD>
</DL>
<HR>
<A NAME="cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><!-- --></A><H3>
cornerMinEigenVal</H3>
<PRE>
public static void <B>cornerMinEigenVal</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int blockSize,
int ksize,
int borderType)</PRE>
<DL>
<DD><p>Calculates the minimal eigenvalue of gradient matrices for corner detection.</p>
<p>The function is similar to "cornerEigenValsAndVecs" but it calculates and
stores only the minimal eigenvalue of the covariance matrix of derivatives,
that is, <em>min(lambda_1, lambda_2)</em> in terms of the formulae in the
"cornerEigenValsAndVecs" description.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input single-channel 8-bit or floating-point image.<DD><CODE>dst</CODE> - Image to store the minimal eigenvalues. It has the type
<code>CV_32FC1</code> and the same size as <code>src</code>.<DD><CODE>blockSize</CODE> - Neighborhood size (see the details on "cornerEigenValsAndVecs").<DD><CODE>ksize</CODE> - Aperture parameter for the "Sobel" operator.<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate".<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornermineigenval">org.opencv.imgproc.Imgproc.cornerMinEigenVal</a></DL>
</DD>
</DL>
<HR>
<A NAME="cornerSubPix(org.opencv.core.Mat, org.opencv.core.MatOfPoint2f, org.opencv.core.Size, org.opencv.core.Size, org.opencv.core.TermCriteria)"><!-- --></A><H3>
cornerSubPix</H3>
<PRE>
public static void <B>cornerSubPix</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> corners,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> winSize,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> zeroZone,
<A HREF="../../../org/opencv/core/TermCriteria.html" title="class in org.opencv.core">TermCriteria</A> criteria)</PRE>
<DL>
<DD><p>Refines the corner locations.</p>
<p>The function iterates to find the sub-pixel accurate location of corners or
radial saddle points, as shown on the figure below.</p>
<p>Sub-pixel accurate corner locator is based on the observation that every
vector from the center <em>q</em> to a point <em>p</em> located within a
neighborhood of <em>q</em> is orthogonal to the image gradient at <em>p</em>
subject to image and measurement noise. Consider the expression:</p>
<p><em>epsilon _i = (DI_(p_i))^T * (q - p_i)</em></p>
<p>where <em>(DI_(p_i))</em> is an image gradient at one of the points
<em>p_i</em> in a neighborhood of <em>q</em>. The value of <em>q</em> is to
be found so that <em>epsilon_i</em> is minimized. A system of equations may
be set up with <em>epsilon_i</em> set to zero:</p>
<p><em>sum _i(DI_(p_i) * (DI_(p_i))^T) - sum _i(DI_(p_i) * (DI_(p_i))^T *
p_i)</em></p>
<p>where the gradients are summed within a neighborhood ("search window") of
<em>q</em>. Calling the first gradient term <em>G</em> and the second
gradient term <em>b</em> gives:</p>
<p><em>q = G^(-1) * b</em></p>
<p>The algorithm sets the center of the neighborhood window at this new center
<em>q</em> and then iterates until the center stays within a set threshold.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Input image.<DD><CODE>corners</CODE> - Initial coordinates of the input corners and refined
coordinates provided for output.<DD><CODE>winSize</CODE> - Half of the side length of the search window. For example, if
<code>winSize=Size(5,5)</code>, then a <em>5*2+1 x 5*2+1 = 11 x 11</em>
search window is used.<DD><CODE>zeroZone</CODE> - Half of the size of the dead region in the middle of the
search zone over which the summation in the formula below is not done. It is
used sometimes to avoid possible singularities of the autocorrelation matrix.
The value of (-1,-1) indicates that there is no such a size.<DD><CODE>criteria</CODE> - Criteria for termination of the iterative process of corner
refinement. That is, the process of corner position refinement stops either
after <code>criteria.maxCount</code> iterations or when the corner position
moves by less than <code>criteria.epsilon</code> on some iteration.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#cornersubpix">org.opencv.imgproc.Imgproc.cornerSubPix</a></DL>
</DD>
</DL>
<HR>
<A NAME="createHanningWindow(org.opencv.core.Mat, org.opencv.core.Size, int)"><!-- --></A><H3>
createHanningWindow</H3>
<PRE>
public static void <B>createHanningWindow</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> winSize,
int type)</PRE>
<DL>
<DD><p>This function computes a Hanning window coefficients in two dimensions. See
http://en.wikipedia.org/wiki/Hann_function and http://en.wikipedia.org/wiki/Window_function
for more information.</p>
<p>An example is shown below: <code></p>
<p>// C++ code:</p>
<p>// create hanning window of size 100x100 and type CV_32F</p>
<p>Mat hann;</p>
<p>createHanningWindow(hann, Size(100, 100), CV_32F);</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>dst</CODE> - Destination array to place Hann coefficients in<DD><CODE>winSize</CODE> - The window size specifications<DD><CODE>type</CODE> - Created array type<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#createhanningwindow">org.opencv.imgproc.Imgproc.createHanningWindow</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#phaseCorrelate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>phaseCorrelate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="cvtColor(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
cvtColor</H3>
<PRE>
public static void <B>cvtColor</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int code)</PRE>
<DL>
<DD><p>Converts an image from one color space to another.</p>
<p>The function converts an input image from one color space to another. In case
of a transformation to-from RGB color space, the order of the channels should
be specified explicitly (RGB or BGR).
Note that the default color format in OpenCV is often referred to as RGB but
it is actually BGR (the bytes are reversed). So the first byte in a standard
(24-bit) color image will be an 8-bit Blue component, the second byte will be
Green, and the third byte will be Red. The fourth, fifth, and sixth bytes
would then be the second pixel (Blue, then Green, then Red), and so on.</p>
<p>The conventional ranges for R, G, and B channel values are:</p>
<ul>
<li> 0 to 255 for <code>CV_8U</code> images
<li> 0 to 65535 for <code>CV_16U</code> images
<li> 0 to 1 for <code>CV_32F</code> images
</ul>
<p>In case of linear transformations, the range does not matter.
But in case of a non-linear transformation, an input RGB image should be
normalized to the proper value range to get the correct results, for example,
for RGB<em>-></em> L*u*v* transformation. For example, if you have a 32-bit
floating-point image directly converted from an 8-bit image without any
scaling, then it will have the 0..255 value range instead of 0..1 assumed by
the function. So, before calling <code>cvtColor</code>, you need first to
scale the image down: <code></p>
<p>// C++ code:</p>
<p>img *= 1./255;</p>
<p>cvtColor(img, img, CV_BGR2Luv);</p>
<p>If you use <code>cvtColor</code> with 8-bit images, the conversion will have
some information lost. For many applications, this will not be noticeable but
it is recommended to use 32-bit images in applications that need the full
range of colors or that convert an image before an operation and then convert
back.
</code></p>
<p>The function can do the following transformations:</p>
<ul>
<li> Transformations within RGB space like adding/removing the alpha
channel, reversing the channel order, conversion to/from 16-bit RGB color
(R5:G6:B5 or R5:G5:B5), as well as conversion to/from grayscale using:
</ul>
<p><em>RGB[A] to Gray: Y <- 0.299 * R + 0.587 * G + 0.114 * B</em></p>
<p>and</p>
<p><em>Gray to RGB[A]: R <- Y, G <- Y, B <- Y, A <- 0</em></p>
<p>The conversion from a RGB image to gray is done with:</p>
<p><code></p>
<p>// C++ code:</p>
<p>cvtColor(src, bwsrc, CV_RGB2GRAY);</p>
<p></code></p>
<p>More advanced channel reordering can also be done with "mixChannels".</p>
<ul>
<li> RGB <em><-></em> CIE XYZ.Rec 709 with D65 white point
(<code>CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB</code>):
</ul>
<p><em>X
Z ltBR gt <- 0.412453 0.357580 0.180423
0.212671 0.715160 0.072169
0.019334 0.119193 0.950227 ltBR gt * R
B ltBR gt</em></p>
<p><em>R
B ltBR gt <- 3.240479 -1.53715 -0.498535
-0.969256 1.875991 0.041556
0.055648 -0.204043 1.057311 ltBR gt * X
Z ltBR gt</em></p>
<p><em>X</em>, <em>Y</em> and <em>Z</em> cover the whole value range (in case of
floating-point images, <em>Z</em> may exceed 1).</p>
<ul>
<li> RGB <em><-></em> YCrCb JPEG (or YCC) (<code>CV_BGR2YCrCb,
CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB</code>)
</ul>
<p><em>Y <- 0.299 * R + 0.587 * G + 0.114 * B</em></p>
<p><em>Cr <- (R-Y) * 0.713 + delta</em></p>
<p><em>Cb <- (B-Y) * 0.564 + delta</em></p>
<p><em>R <- Y + 1.403 * (Cr - delta)</em></p>
<p><em>G <- Y - 0.344 * (Cr - delta) - 0.714 * (Cb - delta)</em></p>
<p><em>B <- Y + 1.773 * (Cb - delta)</em></p>
<p>where</p>
<p><em>delta = <= ft (128 for 8-bit images
32768 for 16-bit images
0.5 for floating-point images right.</em></p>
<p>Y, Cr, and Cb cover the whole value range.</p>
<ul>
<li> RGB <em><-></em> HSV (<code>CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR,
CV_HSV2RGB</code>) In case of 8-bit and 16-bit images, R, G, and B are
converted to the floating-point format and scaled to fit the 0 to 1 range.
</ul>
<p><em>V <- max(R,G,B)</em></p>
<p><em>S <- (V-min(R,G,B))/(V) if V != 0; 0 otherwise</em></p>
<p><em>H <- (60(G - B))/((V-min(R,G,B))) if V=R; (120+60(B - R))/((V-min(R,G,B)))
if V=G; (240+60(R - G))/((V-min(R,G,B))) if V=B</em></p>
<p>If <em>H<0</em> then <em>H <- H+360</em>. On output <em>0 <= V <= 1</em>,
<em>0 <= S <= 1</em>, <em>0 <= H <= 360</em>.</p>
<p>The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>V <- 255 V, S <- 255 S, H <- H/2(to fit to 0 to 255)</em></p>
<ul>
<li> 16-bit images (currently not supported)
</ul>
<p><em>V <- 65535 V, S <- 65535 S, H <- H</em></p>
<ul>
<li> 32-bit images H, S, and V are left as is
<li> RGB <em><-></em> HLS (<code>CV_BGR2HLS, CV_RGB2HLS, CV_HLS2BGR,
CV_HLS2RGB</code>).
</ul>
<p>In case of 8-bit and 16-bit images, R, G, and B are converted to the
floating-point format and scaled to fit the 0 to 1 range.</p>
<p><em>V_(max) <- (max)(R,G,B)</em></p>
<p><em>V_(min) <- (min)(R,G,B)</em></p>
<p><em>L <- (V_(max) + V_(min))/2</em></p>
<p><em>S <- fork ((V_(max) - V_(min))/(V_(max) + V_(min)))(if L <
0.5)<BR>((V_(max) - V_(min))/(2 - (V_(max) + V_(min))))(if L >= 0.5)</em></p>
<p><em>H <- forkthree ((60(G - B))/(S))(if V_(max)=R)<BR>((120+60(B -
R))/(S))(if V_(max)=G)<BR>((240+60(R - G))/(S))(if V_(max)=B)</em></p>
<p>If <em>H<0</em> then <em>H <- H+360</em>. On output <em>0 <= L <= 1</em>,
<em>0 <= S <= 1</em>, <em>0 <= H <= 360</em>.</p>
<p>The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>V <- 255 * V, S <- 255 * S, H <- H/2(to fit to 0 to 255)</em></p>
<ul>
<li> 16-bit images (currently not supported)
</ul>
<p><em>V <- 65535 * V, S <- 65535 * S, H <- H</em></p>
<ul>
<li> 32-bit images H, S, V are left as is
<li> RGB <em><-></em> CIE L*a*b* (<code>CV_BGR2Lab, CV_RGB2Lab, CV_Lab2BGR,
CV_Lab2RGB</code>).
</ul>
<p>In case of 8-bit and 16-bit images, R, G, and B are converted to the
floating-point format and scaled to fit the 0 to 1 range.</p>
<p><em>[X Y Z] <-
|0.412453 0.357580 0.180423|
|0.212671 0.715160 0.072169|
|0.019334 0.119193 0.950227|</p>
<ul>
<li> [R G B]</em>
</ul>
<p><em>X <- X/X_n, where X_n = 0.950456</em></p>
<p><em>Z <- Z/Z_n, where Z_n = 1.088754</em></p>
<p><em>L <- 116*Y^(1/3)-16 for Y>0.008856; 903.3*Y for Y <= 0.008856</em></p>
<p><em>a <- 500(f(X)-f(Y)) + delta</em></p>
<p><em>b <- 200(f(Y)-f(Z)) + delta</em></p>
<p>where</p>
<p><em>f(t)= t^(1/3) for t>0.008856; 7.787 t+16/116 for t <= 0.008856</em></p>
<p>and</p>
<p><em>delta = 128 for 8-bit images; 0 for floating-point images</em></p>
<p>This outputs <em>0 <= L <= 100</em>, <em>-127 <= a <= 127</em>, <em>-127 <= b
<= 127</em>. The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>L <- L*255/100, a <- a + 128, b <- b + 128</em></p>
<ul>
<li> 16-bit images (currently not supported)
<li> 32-bit images L, a, and b are left as is
<li> RGB <em><-></em> CIE L*u*v* (<code>CV_BGR2Luv, CV_RGB2Luv, CV_Luv2BGR,
CV_Luv2RGB</code>).
</ul>
<p>In case of 8-bit and 16-bit images, R, G, and B are converted to the
floating-point format and scaled to fit 0 to 1 range.</p>
<p><em>[X Y Z] <-
|0.412453 0.357580 0.180423|
|0.212671 0.715160 0.072169|
|0.019334 0.119193 0.950227|</p>
<ul>
<li> [R G B]</em>
</ul>
<p><em>L <- 116 Y^(1/3) for Y>0.008856; 903.3 Y for Y <= 0.008856</em></p>
<p><em>u' <- 4*X/(X + 15*Y + 3 Z)</em></p>
<p><em>v' <- 9*Y/(X + 15*Y + 3 Z)</em></p>
<p><em>u <- 13*L*(u' - u_n) where u_n=0.19793943</em></p>
<p><em>v <- 13*L*(v' - v_n) where v_n=0.46831096</em></p>
<p>This outputs <em>0 <= L <= 100</em>, <em>-134 <= u <= 220</em>, <em>-140 <= v
<= 122</em>.</p>
<p>The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>L <- 255/100 L, u <- 255/354(u + 134), v <- 255/256(v + 140)</em></p>
<ul>
<li> 16-bit images (currently not supported)
<li> 32-bit images L, u, and v are left as is
</ul>
<p>The above formulae for converting RGB to/from various color spaces have been
taken from multiple sources on the web, primarily from the Charles Poynton
site http://www.poynton.com/ColorFAQ.html</p>
<ul>
<li> Bayer <em>-></em> RGB (<code>CV_BayerBG2BGR, CV_BayerGB2BGR,
CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerGB2RGB,
CV_BayerRG2RGB, CV_BayerGR2RGB</code>). The Bayer pattern is widely used in
CCD and CMOS cameras. It enables you to get color pictures from a single
plane where R,G, and B pixels (sensors of a particular component) are
interleaved as follows: The output RGB components of a pixel are interpolated
from 1, 2, or <code>
</ul>
<p>// C++ code:</p>
<p>4 neighbors of the pixel having the same color. There are several</p>
<p>modifications of the above pattern that can be achieved by shifting</p>
<p>the pattern one pixel left and/or one pixel up. The two letters</p>
<p><em>C_1</em> and</p>
<p><em>C_2</em> in the conversion constants <code>CV_Bayer</code> <em>C_1
C_2</em> <code>2BGR</code> and <code>CV_Bayer</code> <em>C_1 C_2</em>
<code>2RGB</code> indicate the particular pattern</p>
<p>type. These are components from the second row, second and third</p>
<p>columns, respectively. For example, the above pattern has a very</p>
<p>popular "BG" type.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image: 8-bit unsigned, 16-bit unsigned (<code>CV_16UC...</code>),
or single-precision floating-point.<DD><CODE>dst</CODE> - output image of the same size and depth as <code>src</code>.<DD><CODE>code</CODE> - color space conversion code (see the description below).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#cvtcolor">org.opencv.imgproc.Imgproc.cvtColor</a></DL>
</DD>
</DL>
<HR>
<A NAME="cvtColor(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
cvtColor</H3>
<PRE>
public static void <B>cvtColor</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int code,
int dstCn)</PRE>
<DL>
<DD><p>Converts an image from one color space to another.</p>
<p>The function converts an input image from one color space to another. In case
of a transformation to-from RGB color space, the order of the channels should
be specified explicitly (RGB or BGR).
Note that the default color format in OpenCV is often referred to as RGB but
it is actually BGR (the bytes are reversed). So the first byte in a standard
(24-bit) color image will be an 8-bit Blue component, the second byte will be
Green, and the third byte will be Red. The fourth, fifth, and sixth bytes
would then be the second pixel (Blue, then Green, then Red), and so on.</p>
<p>The conventional ranges for R, G, and B channel values are:</p>
<ul>
<li> 0 to 255 for <code>CV_8U</code> images
<li> 0 to 65535 for <code>CV_16U</code> images
<li> 0 to 1 for <code>CV_32F</code> images
</ul>
<p>In case of linear transformations, the range does not matter.
But in case of a non-linear transformation, an input RGB image should be
normalized to the proper value range to get the correct results, for example,
for RGB<em>-></em> L*u*v* transformation. For example, if you have a 32-bit
floating-point image directly converted from an 8-bit image without any
scaling, then it will have the 0..255 value range instead of 0..1 assumed by
the function. So, before calling <code>cvtColor</code>, you need first to
scale the image down: <code></p>
<p>// C++ code:</p>
<p>img *= 1./255;</p>
<p>cvtColor(img, img, CV_BGR2Luv);</p>
<p>If you use <code>cvtColor</code> with 8-bit images, the conversion will have
some information lost. For many applications, this will not be noticeable but
it is recommended to use 32-bit images in applications that need the full
range of colors or that convert an image before an operation and then convert
back.
</code></p>
<p>The function can do the following transformations:</p>
<ul>
<li> Transformations within RGB space like adding/removing the alpha
channel, reversing the channel order, conversion to/from 16-bit RGB color
(R5:G6:B5 or R5:G5:B5), as well as conversion to/from grayscale using:
</ul>
<p><em>RGB[A] to Gray: Y <- 0.299 * R + 0.587 * G + 0.114 * B</em></p>
<p>and</p>
<p><em>Gray to RGB[A]: R <- Y, G <- Y, B <- Y, A <- 0</em></p>
<p>The conversion from a RGB image to gray is done with:</p>
<p><code></p>
<p>// C++ code:</p>
<p>cvtColor(src, bwsrc, CV_RGB2GRAY);</p>
<p></code></p>
<p>More advanced channel reordering can also be done with "mixChannels".</p>
<ul>
<li> RGB <em><-></em> CIE XYZ.Rec 709 with D65 white point
(<code>CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB</code>):
</ul>
<p><em>X
Z ltBR gt <- 0.412453 0.357580 0.180423
0.212671 0.715160 0.072169
0.019334 0.119193 0.950227 ltBR gt * R
B ltBR gt</em></p>
<p><em>R
B ltBR gt <- 3.240479 -1.53715 -0.498535
-0.969256 1.875991 0.041556
0.055648 -0.204043 1.057311 ltBR gt * X
Z ltBR gt</em></p>
<p><em>X</em>, <em>Y</em> and <em>Z</em> cover the whole value range (in case of
floating-point images, <em>Z</em> may exceed 1).</p>
<ul>
<li> RGB <em><-></em> YCrCb JPEG (or YCC) (<code>CV_BGR2YCrCb,
CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB</code>)
</ul>
<p><em>Y <- 0.299 * R + 0.587 * G + 0.114 * B</em></p>
<p><em>Cr <- (R-Y) * 0.713 + delta</em></p>
<p><em>Cb <- (B-Y) * 0.564 + delta</em></p>
<p><em>R <- Y + 1.403 * (Cr - delta)</em></p>
<p><em>G <- Y - 0.344 * (Cr - delta) - 0.714 * (Cb - delta)</em></p>
<p><em>B <- Y + 1.773 * (Cb - delta)</em></p>
<p>where</p>
<p><em>delta = <= ft (128 for 8-bit images
32768 for 16-bit images
0.5 for floating-point images right.</em></p>
<p>Y, Cr, and Cb cover the whole value range.</p>
<ul>
<li> RGB <em><-></em> HSV (<code>CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR,
CV_HSV2RGB</code>) In case of 8-bit and 16-bit images, R, G, and B are
converted to the floating-point format and scaled to fit the 0 to 1 range.
</ul>
<p><em>V <- max(R,G,B)</em></p>
<p><em>S <- (V-min(R,G,B))/(V) if V != 0; 0 otherwise</em></p>
<p><em>H <- (60(G - B))/((V-min(R,G,B))) if V=R; (120+60(B - R))/((V-min(R,G,B)))
if V=G; (240+60(R - G))/((V-min(R,G,B))) if V=B</em></p>
<p>If <em>H<0</em> then <em>H <- H+360</em>. On output <em>0 <= V <= 1</em>,
<em>0 <= S <= 1</em>, <em>0 <= H <= 360</em>.</p>
<p>The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>V <- 255 V, S <- 255 S, H <- H/2(to fit to 0 to 255)</em></p>
<ul>
<li> 16-bit images (currently not supported)
</ul>
<p><em>V <- 65535 V, S <- 65535 S, H <- H</em></p>
<ul>
<li> 32-bit images H, S, and V are left as is
<li> RGB <em><-></em> HLS (<code>CV_BGR2HLS, CV_RGB2HLS, CV_HLS2BGR,
CV_HLS2RGB</code>).
</ul>
<p>In case of 8-bit and 16-bit images, R, G, and B are converted to the
floating-point format and scaled to fit the 0 to 1 range.</p>
<p><em>V_(max) <- (max)(R,G,B)</em></p>
<p><em>V_(min) <- (min)(R,G,B)</em></p>
<p><em>L <- (V_(max) + V_(min))/2</em></p>
<p><em>S <- fork ((V_(max) - V_(min))/(V_(max) + V_(min)))(if L <
0.5)<BR>((V_(max) - V_(min))/(2 - (V_(max) + V_(min))))(if L >= 0.5)</em></p>
<p><em>H <- forkthree ((60(G - B))/(S))(if V_(max)=R)<BR>((120+60(B -
R))/(S))(if V_(max)=G)<BR>((240+60(R - G))/(S))(if V_(max)=B)</em></p>
<p>If <em>H<0</em> then <em>H <- H+360</em>. On output <em>0 <= L <= 1</em>,
<em>0 <= S <= 1</em>, <em>0 <= H <= 360</em>.</p>
<p>The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>V <- 255 * V, S <- 255 * S, H <- H/2(to fit to 0 to 255)</em></p>
<ul>
<li> 16-bit images (currently not supported)
</ul>
<p><em>V <- 65535 * V, S <- 65535 * S, H <- H</em></p>
<ul>
<li> 32-bit images H, S, V are left as is
<li> RGB <em><-></em> CIE L*a*b* (<code>CV_BGR2Lab, CV_RGB2Lab, CV_Lab2BGR,
CV_Lab2RGB</code>).
</ul>
<p>In case of 8-bit and 16-bit images, R, G, and B are converted to the
floating-point format and scaled to fit the 0 to 1 range.</p>
<p><em>[X Y Z] <-
|0.412453 0.357580 0.180423|
|0.212671 0.715160 0.072169|
|0.019334 0.119193 0.950227|</p>
<ul>
<li> [R G B]</em>
</ul>
<p><em>X <- X/X_n, where X_n = 0.950456</em></p>
<p><em>Z <- Z/Z_n, where Z_n = 1.088754</em></p>
<p><em>L <- 116*Y^(1/3)-16 for Y>0.008856; 903.3*Y for Y <= 0.008856</em></p>
<p><em>a <- 500(f(X)-f(Y)) + delta</em></p>
<p><em>b <- 200(f(Y)-f(Z)) + delta</em></p>
<p>where</p>
<p><em>f(t)= t^(1/3) for t>0.008856; 7.787 t+16/116 for t <= 0.008856</em></p>
<p>and</p>
<p><em>delta = 128 for 8-bit images; 0 for floating-point images</em></p>
<p>This outputs <em>0 <= L <= 100</em>, <em>-127 <= a <= 127</em>, <em>-127 <= b
<= 127</em>. The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>L <- L*255/100, a <- a + 128, b <- b + 128</em></p>
<ul>
<li> 16-bit images (currently not supported)
<li> 32-bit images L, a, and b are left as is
<li> RGB <em><-></em> CIE L*u*v* (<code>CV_BGR2Luv, CV_RGB2Luv, CV_Luv2BGR,
CV_Luv2RGB</code>).
</ul>
<p>In case of 8-bit and 16-bit images, R, G, and B are converted to the
floating-point format and scaled to fit 0 to 1 range.</p>
<p><em>[X Y Z] <-
|0.412453 0.357580 0.180423|
|0.212671 0.715160 0.072169|
|0.019334 0.119193 0.950227|</p>
<ul>
<li> [R G B]</em>
</ul>
<p><em>L <- 116 Y^(1/3) for Y>0.008856; 903.3 Y for Y <= 0.008856</em></p>
<p><em>u' <- 4*X/(X + 15*Y + 3 Z)</em></p>
<p><em>v' <- 9*Y/(X + 15*Y + 3 Z)</em></p>
<p><em>u <- 13*L*(u' - u_n) where u_n=0.19793943</em></p>
<p><em>v <- 13*L*(v' - v_n) where v_n=0.46831096</em></p>
<p>This outputs <em>0 <= L <= 100</em>, <em>-134 <= u <= 220</em>, <em>-140 <= v
<= 122</em>.</p>
<p>The values are then converted to the destination data type:</p>
<ul>
<li> 8-bit images
</ul>
<p><em>L <- 255/100 L, u <- 255/354(u + 134), v <- 255/256(v + 140)</em></p>
<ul>
<li> 16-bit images (currently not supported)
<li> 32-bit images L, u, and v are left as is
</ul>
<p>The above formulae for converting RGB to/from various color spaces have been
taken from multiple sources on the web, primarily from the Charles Poynton
site http://www.poynton.com/ColorFAQ.html</p>
<ul>
<li> Bayer <em>-></em> RGB (<code>CV_BayerBG2BGR, CV_BayerGB2BGR,
CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerGB2RGB,
CV_BayerRG2RGB, CV_BayerGR2RGB</code>). The Bayer pattern is widely used in
CCD and CMOS cameras. It enables you to get color pictures from a single
plane where R,G, and B pixels (sensors of a particular component) are
interleaved as follows: The output RGB components of a pixel are interpolated
from 1, 2, or <code>
</ul>
<p>// C++ code:</p>
<p>4 neighbors of the pixel having the same color. There are several</p>
<p>modifications of the above pattern that can be achieved by shifting</p>
<p>the pattern one pixel left and/or one pixel up. The two letters</p>
<p><em>C_1</em> and</p>
<p><em>C_2</em> in the conversion constants <code>CV_Bayer</code> <em>C_1
C_2</em> <code>2BGR</code> and <code>CV_Bayer</code> <em>C_1 C_2</em>
<code>2RGB</code> indicate the particular pattern</p>
<p>type. These are components from the second row, second and third</p>
<p>columns, respectively. For example, the above pattern has a very</p>
<p>popular "BG" type.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image: 8-bit unsigned, 16-bit unsigned (<code>CV_16UC...</code>),
or single-precision floating-point.<DD><CODE>dst</CODE> - output image of the same size and depth as <code>src</code>.<DD><CODE>code</CODE> - color space conversion code (see the description below).<DD><CODE>dstCn</CODE> - number of channels in the destination image; if the parameter is
0, the number of the channels is derived automatically from <code>src</code>
and <code>code</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#cvtcolor">org.opencv.imgproc.Imgproc.cvtColor</a></DL>
</DD>
</DL>
<HR>
<A NAME="dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
dilate</H3>
<PRE>
public static void <B>dilate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</PRE>
<DL>
<DD><p>Dilates an image by using a specific structuring element.</p>
<p>The function dilates the source image using the specified structuring element
that determines the shape of a pixel neighborhood over which the maximum is
taken:</p>
<p><em>dst(x,y) = max _((x',y'): element(x',y') != 0) src(x+x',y+y')</em></p>
<p>The function supports the in-place mode. Dilation can be applied several
(<code>iterations</code>) times. In case of multi-channel images, each
channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the number of channels can be arbitrary, but the
depth should be one of <code>CV_8U</code>, <code>CV_16U</code>,
<code>CV_16S</code>, <code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>kernel</CODE> - a kernel<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#dilate">org.opencv.imgproc.Imgproc.dilate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int)"><!-- --></A><H3>
dilate</H3>
<PRE>
public static void <B>dilate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations)</PRE>
<DL>
<DD><p>Dilates an image by using a specific structuring element.</p>
<p>The function dilates the source image using the specified structuring element
that determines the shape of a pixel neighborhood over which the maximum is
taken:</p>
<p><em>dst(x,y) = max _((x',y'): element(x',y') != 0) src(x+x',y+y')</em></p>
<p>The function supports the in-place mode. Dilation can be applied several
(<code>iterations</code>) times. In case of multi-channel images, each
channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the number of channels can be arbitrary, but the
depth should be one of <code>CV_8U</code>, <code>CV_16U</code>,
<code>CV_16S</code>, <code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>kernel</CODE> - a kernel<DD><CODE>anchor</CODE> - position of the anchor within the element; default value
<code>(-1, -1)</code> means that the anchor is at the element center.<DD><CODE>iterations</CODE> - number of times dilation is applied.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#dilate">org.opencv.imgproc.Imgproc.dilate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
dilate</H3>
<PRE>
public static void <B>dilate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</PRE>
<DL>
<DD><p>Dilates an image by using a specific structuring element.</p>
<p>The function dilates the source image using the specified structuring element
that determines the shape of a pixel neighborhood over which the maximum is
taken:</p>
<p><em>dst(x,y) = max _((x',y'): element(x',y') != 0) src(x+x',y+y')</em></p>
<p>The function supports the in-place mode. Dilation can be applied several
(<code>iterations</code>) times. In case of multi-channel images, each
channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the number of channels can be arbitrary, but the
depth should be one of <code>CV_8U</code>, <code>CV_16U</code>,
<code>CV_16S</code>, <code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>kernel</CODE> - a kernel<DD><CODE>anchor</CODE> - position of the anchor within the element; default value
<code>(-1, -1)</code> means that the anchor is at the element center.<DD><CODE>iterations</CODE> - number of times dilation is applied.<DD><CODE>borderType</CODE> - pixel extrapolation method (see "borderInterpolate" for
details).<DD><CODE>borderValue</CODE> - border value in case of a constant border (see
"createMorphologyFilter" for details).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#dilate">org.opencv.imgproc.Imgproc.dilate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="distanceTransform(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
distanceTransform</H3>
<PRE>
public static void <B>distanceTransform</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int distanceType,
int maskSize)</PRE>
<DL>
<DD><p>Calculates the distance to the closest zero pixel for each pixel of the
source image.</p>
<p>The functions <code>distanceTransform</code> calculate the approximate or
precise distance from every binary image pixel to the nearest zero pixel.
For zero image pixels, the distance will obviously be zero.</p>
<p>When <code>maskSize == CV_DIST_MASK_PRECISE</code> and <code>distanceType ==
CV_DIST_L2</code>, the function runs the algorithm described in
[Felzenszwalb04]. This algorithm is parallelized with the TBB library.</p>
<p>In other cases, the algorithm [Borgefors86] is used. This means that for a
pixel the function finds the shortest path to the nearest zero pixel
consisting of basic shifts: horizontal, vertical, diagonal, or knight's move
(the latest is available for a <em>5x 5</em> mask). The overall distance is
calculated as a sum of these basic distances. Since the distance function
should be symmetric, all of the horizontal and vertical shifts must have the
same cost (denoted as <code>a</code>), all the diagonal shifts must have the
same cost (denoted as <code>b</code>), and all knight's moves must have the
same cost (denoted as <code>c</code>). For the <code>CV_DIST_C</code> and
<code>CV_DIST_L1</code> types, the distance is calculated precisely, whereas
for <code>CV_DIST_L2</code> (Euclidean distance) the distance can be
calculated only with a relative error (a <em>5x 5</em> mask gives more
accurate results). For <code>a</code>,<code>b</code>, and <code>c</code>,
OpenCV uses the values suggested in the original paper:</p>
<p>============== =================== ======================
<code>CV_DIST_C</code> <em>(3x 3)</em> a = 1, b = 1 \
============== =================== ======================
<code>CV_DIST_L1</code> <em>(3x 3)</em> a = 1, b = 2 \
<code>CV_DIST_L2</code> <em>(3x 3)</em> a=0.955, b=1.3693 \
<code>CV_DIST_L2</code> <em>(5x 5)</em> a=1, b=1.4, c=2.1969 \
============== =================== ======================</p>
<p>Typically, for a fast, coarse distance estimation <code>CV_DIST_L2</code>, a
<em>3x 3</em> mask is used. For a more accurate distance estimation
<code>CV_DIST_L2</code>, a <em>5x 5</em> mask or the precise algorithm is
used.
Note that both the precise and the approximate algorithms are linear on the
number of pixels.</p>
<p>The second variant of the function does not only compute the minimum distance
for each pixel <em>(x, y)</em> but also identifies the nearest connected
component consisting of zero pixels (<code>labelType==DIST_LABEL_CCOMP</code>)
or the nearest zero pixel (<code>labelType==DIST_LABEL_PIXEL</code>). Index
of the component/pixel is stored in <em>labels(x, y)</em>.
When <code>labelType==DIST_LABEL_CCOMP</code>, the function automatically
finds connected components of zero pixels in the input image and marks them
with distinct labels. When <code>labelType==DIST_LABEL_CCOMP</code>, the
function scans through the input image and marks all the zero pixels with
distinct labels.</p>
<p>In this mode, the complexity is still linear.
That is, the function provides a very fast way to compute the Voronoi diagram
for a binary image.
Currently, the second variant can use only the approximate distance transform
algorithm, i.e. <code>maskSize=CV_DIST_MASK_PRECISE</code> is not supported
yet.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - 8-bit, single-channel (binary) source image.<DD><CODE>dst</CODE> - Output image with calculated distances. It is a 32-bit
floating-point, single-channel image of the same size as <code>src</code>.<DD><CODE>distanceType</CODE> - Type of distance. It can be <code>CV_DIST_L1,
CV_DIST_L2</code>, or <code>CV_DIST_C</code>.<DD><CODE>maskSize</CODE> - Size of the distance transform mask. It can be 3, 5, or
<code>CV_DIST_MASK_PRECISE</code> (the latter option is only supported by the
first function). In case of the <code>CV_DIST_L1</code> or <code>CV_DIST_C</code>
distance type, the parameter is forced to 3 because a <em>3x 3</em> mask
gives the same result as <em>5x 5</em> or any larger aperture.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#distancetransform">org.opencv.imgproc.Imgproc.distanceTransform</a></DL>
</DD>
</DL>
<HR>
<A NAME="distanceTransformWithLabels(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
distanceTransformWithLabels</H3>
<PRE>
public static void <B>distanceTransformWithLabels</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> labels,
int distanceType,
int maskSize)</PRE>
<DL>
<DD><p>Calculates the distance to the closest zero pixel for each pixel of the
source image.</p>
<p>The functions <code>distanceTransform</code> calculate the approximate or
precise distance from every binary image pixel to the nearest zero pixel.
For zero image pixels, the distance will obviously be zero.</p>
<p>When <code>maskSize == CV_DIST_MASK_PRECISE</code> and <code>distanceType ==
CV_DIST_L2</code>, the function runs the algorithm described in
[Felzenszwalb04]. This algorithm is parallelized with the TBB library.</p>
<p>In other cases, the algorithm [Borgefors86] is used. This means that for a
pixel the function finds the shortest path to the nearest zero pixel
consisting of basic shifts: horizontal, vertical, diagonal, or knight's move
(the latest is available for a <em>5x 5</em> mask). The overall distance is
calculated as a sum of these basic distances. Since the distance function
should be symmetric, all of the horizontal and vertical shifts must have the
same cost (denoted as <code>a</code>), all the diagonal shifts must have the
same cost (denoted as <code>b</code>), and all knight's moves must have the
same cost (denoted as <code>c</code>). For the <code>CV_DIST_C</code> and
<code>CV_DIST_L1</code> types, the distance is calculated precisely, whereas
for <code>CV_DIST_L2</code> (Euclidean distance) the distance can be
calculated only with a relative error (a <em>5x 5</em> mask gives more
accurate results). For <code>a</code>,<code>b</code>, and <code>c</code>,
OpenCV uses the values suggested in the original paper:</p>
<p>============== =================== ======================
<code>CV_DIST_C</code> <em>(3x 3)</em> a = 1, b = 1 \
============== =================== ======================
<code>CV_DIST_L1</code> <em>(3x 3)</em> a = 1, b = 2 \
<code>CV_DIST_L2</code> <em>(3x 3)</em> a=0.955, b=1.3693 \
<code>CV_DIST_L2</code> <em>(5x 5)</em> a=1, b=1.4, c=2.1969 \
============== =================== ======================</p>
<p>Typically, for a fast, coarse distance estimation <code>CV_DIST_L2</code>, a
<em>3x 3</em> mask is used. For a more accurate distance estimation
<code>CV_DIST_L2</code>, a <em>5x 5</em> mask or the precise algorithm is
used.
Note that both the precise and the approximate algorithms are linear on the
number of pixels.</p>
<p>The second variant of the function does not only compute the minimum distance
for each pixel <em>(x, y)</em> but also identifies the nearest connected
component consisting of zero pixels (<code>labelType==DIST_LABEL_CCOMP</code>)
or the nearest zero pixel (<code>labelType==DIST_LABEL_PIXEL</code>). Index
of the component/pixel is stored in <em>labels(x, y)</em>.
When <code>labelType==DIST_LABEL_CCOMP</code>, the function automatically
finds connected components of zero pixels in the input image and marks them
with distinct labels. When <code>labelType==DIST_LABEL_CCOMP</code>, the
function scans through the input image and marks all the zero pixels with
distinct labels.</p>
<p>In this mode, the complexity is still linear.
That is, the function provides a very fast way to compute the Voronoi diagram
for a binary image.
Currently, the second variant can use only the approximate distance transform
algorithm, i.e. <code>maskSize=CV_DIST_MASK_PRECISE</code> is not supported
yet.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - 8-bit, single-channel (binary) source image.<DD><CODE>dst</CODE> - Output image with calculated distances. It is a 32-bit
floating-point, single-channel image of the same size as <code>src</code>.<DD><CODE>labels</CODE> - Optional output 2D array of labels (the discrete Voronoi
diagram). It has the type <code>CV_32SC1</code> and the same size as
<code>src</code>. See the details below.<DD><CODE>distanceType</CODE> - Type of distance. It can be <code>CV_DIST_L1,
CV_DIST_L2</code>, or <code>CV_DIST_C</code>.<DD><CODE>maskSize</CODE> - Size of the distance transform mask. It can be 3, 5, or
<code>CV_DIST_MASK_PRECISE</code> (the latter option is only supported by the
first function). In case of the <code>CV_DIST_L1</code> or <code>CV_DIST_C</code>
distance type, the parameter is forced to 3 because a <em>3x 3</em> mask
gives the same result as <em>5x 5</em> or any larger aperture.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#distancetransform">org.opencv.imgproc.Imgproc.distanceTransform</a></DL>
</DD>
</DL>
<HR>
<A NAME="distanceTransformWithLabels(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><!-- --></A><H3>
distanceTransformWithLabels</H3>
<PRE>
public static void <B>distanceTransformWithLabels</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> labels,
int distanceType,
int maskSize,
int labelType)</PRE>
<DL>
<DD><p>Calculates the distance to the closest zero pixel for each pixel of the
source image.</p>
<p>The functions <code>distanceTransform</code> calculate the approximate or
precise distance from every binary image pixel to the nearest zero pixel.
For zero image pixels, the distance will obviously be zero.</p>
<p>When <code>maskSize == CV_DIST_MASK_PRECISE</code> and <code>distanceType ==
CV_DIST_L2</code>, the function runs the algorithm described in
[Felzenszwalb04]. This algorithm is parallelized with the TBB library.</p>
<p>In other cases, the algorithm [Borgefors86] is used. This means that for a
pixel the function finds the shortest path to the nearest zero pixel
consisting of basic shifts: horizontal, vertical, diagonal, or knight's move
(the latest is available for a <em>5x 5</em> mask). The overall distance is
calculated as a sum of these basic distances. Since the distance function
should be symmetric, all of the horizontal and vertical shifts must have the
same cost (denoted as <code>a</code>), all the diagonal shifts must have the
same cost (denoted as <code>b</code>), and all knight's moves must have the
same cost (denoted as <code>c</code>). For the <code>CV_DIST_C</code> and
<code>CV_DIST_L1</code> types, the distance is calculated precisely, whereas
for <code>CV_DIST_L2</code> (Euclidean distance) the distance can be
calculated only with a relative error (a <em>5x 5</em> mask gives more
accurate results). For <code>a</code>,<code>b</code>, and <code>c</code>,
OpenCV uses the values suggested in the original paper:</p>
<p>============== =================== ======================
<code>CV_DIST_C</code> <em>(3x 3)</em> a = 1, b = 1 \
============== =================== ======================
<code>CV_DIST_L1</code> <em>(3x 3)</em> a = 1, b = 2 \
<code>CV_DIST_L2</code> <em>(3x 3)</em> a=0.955, b=1.3693 \
<code>CV_DIST_L2</code> <em>(5x 5)</em> a=1, b=1.4, c=2.1969 \
============== =================== ======================</p>
<p>Typically, for a fast, coarse distance estimation <code>CV_DIST_L2</code>, a
<em>3x 3</em> mask is used. For a more accurate distance estimation
<code>CV_DIST_L2</code>, a <em>5x 5</em> mask or the precise algorithm is
used.
Note that both the precise and the approximate algorithms are linear on the
number of pixels.</p>
<p>The second variant of the function does not only compute the minimum distance
for each pixel <em>(x, y)</em> but also identifies the nearest connected
component consisting of zero pixels (<code>labelType==DIST_LABEL_CCOMP</code>)
or the nearest zero pixel (<code>labelType==DIST_LABEL_PIXEL</code>). Index
of the component/pixel is stored in <em>labels(x, y)</em>.
When <code>labelType==DIST_LABEL_CCOMP</code>, the function automatically
finds connected components of zero pixels in the input image and marks them
with distinct labels. When <code>labelType==DIST_LABEL_CCOMP</code>, the
function scans through the input image and marks all the zero pixels with
distinct labels.</p>
<p>In this mode, the complexity is still linear.
That is, the function provides a very fast way to compute the Voronoi diagram
for a binary image.
Currently, the second variant can use only the approximate distance transform
algorithm, i.e. <code>maskSize=CV_DIST_MASK_PRECISE</code> is not supported
yet.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - 8-bit, single-channel (binary) source image.<DD><CODE>dst</CODE> - Output image with calculated distances. It is a 32-bit
floating-point, single-channel image of the same size as <code>src</code>.<DD><CODE>labels</CODE> - Optional output 2D array of labels (the discrete Voronoi
diagram). It has the type <code>CV_32SC1</code> and the same size as
<code>src</code>. See the details below.<DD><CODE>distanceType</CODE> - Type of distance. It can be <code>CV_DIST_L1,
CV_DIST_L2</code>, or <code>CV_DIST_C</code>.<DD><CODE>maskSize</CODE> - Size of the distance transform mask. It can be 3, 5, or
<code>CV_DIST_MASK_PRECISE</code> (the latter option is only supported by the
first function). In case of the <code>CV_DIST_L1</code> or <code>CV_DIST_C</code>
distance type, the parameter is forced to 3 because a <em>3x 3</em> mask
gives the same result as <em>5x 5</em> or any larger aperture.<DD><CODE>labelType</CODE> - Type of the label array to build. If <code>labelType==DIST_LABEL_CCOMP</code>
then each connected component of zeros in <code>src</code> (as well as all
the non-zero pixels closest to the connected component) will be assigned the
same label. If <code>labelType==DIST_LABEL_PIXEL</code> then each zero pixel
(and all the non-zero pixels closest to it) gets its own label.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#distancetransform">org.opencv.imgproc.Imgproc.distanceTransform</a></DL>
</DD>
</DL>
<HR>
<A NAME="drawContours(org.opencv.core.Mat, java.util.List, int, org.opencv.core.Scalar)"><!-- --></A><H3>
drawContours</H3>
<PRE>
public static void <B>drawContours</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
int contourIdx,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> color)</PRE>
<DL>
<DD><p>Draws contours outlines or filled contours.</p>
<p>The function draws contour outlines in the image if <em>thickness >= 0</em>
or fills the area bounded by the contours if<em>thickness<0</em>. The
example below shows how to retrieve connected components from the binary
image and label them: <code></p>
<p>// C++ code:</p>
<p>#include "cv.h"</p>
<p>#include "highgui.h"</p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src;</p>
<p>// the first command-line parameter must be a filename of the binary</p>
<p>// (black-n-white) image</p>
<p>if(argc != 2 || !(src=imread(argv[1], 0)).data)</p>
<p>return -1;</p>
<p>Mat dst = Mat.zeros(src.rows, src.cols, CV_8UC3);</p>
<p>src = src > 1;</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>vector<vector<Point> > contours;</p>
<p>vector<Vec4i> hierarchy;</p>
<p>findContours(src, contours, hierarchy,</p>
<p>CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);</p>
<p>// iterate through all the top-level contours,</p>
<p>// draw each connected component with its own random color</p>
<p>int idx = 0;</p>
<p>for(; idx >= 0; idx = hierarchy[idx][0])</p>
<p>Scalar color(rand()&255, rand()&255, rand()&255);</p>
<p>drawContours(dst, contours, idx, color, CV_FILLED, 8, hierarchy);</p>
<p>namedWindow("Components", 1);</p>
<p>imshow("Components", dst);</p>
<p>waitKey(0);</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Destination image.<DD><CODE>contours</CODE> - All the input contours. Each contour is stored as a point
vector.<DD><CODE>contourIdx</CODE> - Parameter indicating a contour to draw. If it is negative,
all the contours are drawn.<DD><CODE>color</CODE> - Color of the contours.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#drawcontours">org.opencv.imgproc.Imgproc.drawContours</a></DL>
</DD>
</DL>
<HR>
<A NAME="drawContours(org.opencv.core.Mat, java.util.List, int, org.opencv.core.Scalar, int)"><!-- --></A><H3>
drawContours</H3>
<PRE>
public static void <B>drawContours</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
int contourIdx,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> color,
int thickness)</PRE>
<DL>
<DD><p>Draws contours outlines or filled contours.</p>
<p>The function draws contour outlines in the image if <em>thickness >= 0</em>
or fills the area bounded by the contours if<em>thickness<0</em>. The
example below shows how to retrieve connected components from the binary
image and label them: <code></p>
<p>// C++ code:</p>
<p>#include "cv.h"</p>
<p>#include "highgui.h"</p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src;</p>
<p>// the first command-line parameter must be a filename of the binary</p>
<p>// (black-n-white) image</p>
<p>if(argc != 2 || !(src=imread(argv[1], 0)).data)</p>
<p>return -1;</p>
<p>Mat dst = Mat.zeros(src.rows, src.cols, CV_8UC3);</p>
<p>src = src > 1;</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>vector<vector<Point> > contours;</p>
<p>vector<Vec4i> hierarchy;</p>
<p>findContours(src, contours, hierarchy,</p>
<p>CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);</p>
<p>// iterate through all the top-level contours,</p>
<p>// draw each connected component with its own random color</p>
<p>int idx = 0;</p>
<p>for(; idx >= 0; idx = hierarchy[idx][0])</p>
<p>Scalar color(rand()&255, rand()&255, rand()&255);</p>
<p>drawContours(dst, contours, idx, color, CV_FILLED, 8, hierarchy);</p>
<p>namedWindow("Components", 1);</p>
<p>imshow("Components", dst);</p>
<p>waitKey(0);</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Destination image.<DD><CODE>contours</CODE> - All the input contours. Each contour is stored as a point
vector.<DD><CODE>contourIdx</CODE> - Parameter indicating a contour to draw. If it is negative,
all the contours are drawn.<DD><CODE>color</CODE> - Color of the contours.<DD><CODE>thickness</CODE> - Thickness of lines the contours are drawn with. If it is
negative (for example, <code>thickness=CV_FILLED</code>), the contour
interiors are drawn.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#drawcontours">org.opencv.imgproc.Imgproc.drawContours</a></DL>
</DD>
</DL>
<HR>
<A NAME="drawContours(org.opencv.core.Mat, java.util.List, int, org.opencv.core.Scalar, int, int, org.opencv.core.Mat, int, org.opencv.core.Point)"><!-- --></A><H3>
drawContours</H3>
<PRE>
public static void <B>drawContours</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
int contourIdx,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> color,
int thickness,
int lineType,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hierarchy,
int maxLevel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> offset)</PRE>
<DL>
<DD><p>Draws contours outlines or filled contours.</p>
<p>The function draws contour outlines in the image if <em>thickness >= 0</em>
or fills the area bounded by the contours if<em>thickness<0</em>. The
example below shows how to retrieve connected components from the binary
image and label them: <code></p>
<p>// C++ code:</p>
<p>#include "cv.h"</p>
<p>#include "highgui.h"</p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src;</p>
<p>// the first command-line parameter must be a filename of the binary</p>
<p>// (black-n-white) image</p>
<p>if(argc != 2 || !(src=imread(argv[1], 0)).data)</p>
<p>return -1;</p>
<p>Mat dst = Mat.zeros(src.rows, src.cols, CV_8UC3);</p>
<p>src = src > 1;</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>vector<vector<Point> > contours;</p>
<p>vector<Vec4i> hierarchy;</p>
<p>findContours(src, contours, hierarchy,</p>
<p>CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);</p>
<p>// iterate through all the top-level contours,</p>
<p>// draw each connected component with its own random color</p>
<p>int idx = 0;</p>
<p>for(; idx >= 0; idx = hierarchy[idx][0])</p>
<p>Scalar color(rand()&255, rand()&255, rand()&255);</p>
<p>drawContours(dst, contours, idx, color, CV_FILLED, 8, hierarchy);</p>
<p>namedWindow("Components", 1);</p>
<p>imshow("Components", dst);</p>
<p>waitKey(0);</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Destination image.<DD><CODE>contours</CODE> - All the input contours. Each contour is stored as a point
vector.<DD><CODE>contourIdx</CODE> - Parameter indicating a contour to draw. If it is negative,
all the contours are drawn.<DD><CODE>color</CODE> - Color of the contours.<DD><CODE>thickness</CODE> - Thickness of lines the contours are drawn with. If it is
negative (for example, <code>thickness=CV_FILLED</code>), the contour
interiors are drawn.<DD><CODE>lineType</CODE> - Line connectivity. See "line" for details.<DD><CODE>hierarchy</CODE> - Optional information about hierarchy. It is only needed if
you want to draw only some of the contours (see <code>maxLevel</code>).<DD><CODE>maxLevel</CODE> - Maximal level for drawn contours. If it is 0, only the
specified contour is drawn. If it is 1, the function draws the contour(s) and
all the nested contours. If it is 2, the function draws the contours, all the
nested contours, all the nested-to-nested contours, and so on. This parameter
is only taken into account when there is <code>hierarchy</code> available.<DD><CODE>offset</CODE> - Optional contour shift parameter. Shift all the drawn contours
by the specified <em>offset=(dx,dy)</em>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#drawcontours">org.opencv.imgproc.Imgproc.drawContours</a></DL>
</DD>
</DL>
<HR>
<A NAME="equalizeHist(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
equalizeHist</H3>
<PRE>
public static void <B>equalizeHist</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Equalizes the histogram of a grayscale image.</p>
<p>The function equalizes the histogram of the input image using the following
algorithm:</p>
<ul>
<li> Calculate the histogram <em>H</em> for <code>src</code>.
<li> Normalize the histogram so that the sum of histogram bins is 255.
<li> Compute the integral of the histogram:
</ul>
<p><em>H'_i = sum(by: 0 <= j < i) H(j)</em></p>
<ul>
<li>
</ul>
<p>Transform the image using <em>H'</em> as a look-up table: <em>dst(x,y) =
H'(src(x,y))</em></p>
<p>The algorithm normalizes the brightness and increases the contrast of the
image.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source 8-bit single channel image.<DD><CODE>dst</CODE> - Destination image of the same size and type as <code>src</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/histograms.html#equalizehist">org.opencv.imgproc.Imgproc.equalizeHist</a></DL>
</DD>
</DL>
<HR>
<A NAME="erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
erode</H3>
<PRE>
public static void <B>erode</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</PRE>
<DL>
<DD><p>Erodes an image by using a specific structuring element.</p>
<p>The function erodes the source image using the specified structuring element
that determines the shape of a pixel neighborhood over which the minimum is
taken:</p>
<p><em>dst(x,y) = min _((x',y'): element(x',y') != 0) src(x+x',y+y')</em></p>
<p>The function supports the in-place mode. Erosion can be applied several
(<code>iterations</code>) times. In case of multi-channel images, each
channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the number of channels can be arbitrary, but the
depth should be one of <code>CV_8U</code>, <code>CV_16U</code>,
<code>CV_16S</code>, <code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>kernel</CODE> - a kernel<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#erode">org.opencv.imgproc.Imgproc.erode</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int)"><!-- --></A><H3>
erode</H3>
<PRE>
public static void <B>erode</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations)</PRE>
<DL>
<DD><p>Erodes an image by using a specific structuring element.</p>
<p>The function erodes the source image using the specified structuring element
that determines the shape of a pixel neighborhood over which the minimum is
taken:</p>
<p><em>dst(x,y) = min _((x',y'): element(x',y') != 0) src(x+x',y+y')</em></p>
<p>The function supports the in-place mode. Erosion can be applied several
(<code>iterations</code>) times. In case of multi-channel images, each
channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the number of channels can be arbitrary, but the
depth should be one of <code>CV_8U</code>, <code>CV_16U</code>,
<code>CV_16S</code>, <code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>kernel</CODE> - a kernel<DD><CODE>anchor</CODE> - position of the anchor within the element; default value
<code>(-1, -1)</code> means that the anchor is at the element center.<DD><CODE>iterations</CODE> - number of times erosion is applied.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#erode">org.opencv.imgproc.Imgproc.erode</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
erode</H3>
<PRE>
public static void <B>erode</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</PRE>
<DL>
<DD><p>Erodes an image by using a specific structuring element.</p>
<p>The function erodes the source image using the specified structuring element
that determines the shape of a pixel neighborhood over which the minimum is
taken:</p>
<p><em>dst(x,y) = min _((x',y'): element(x',y') != 0) src(x+x',y+y')</em></p>
<p>The function supports the in-place mode. Erosion can be applied several
(<code>iterations</code>) times. In case of multi-channel images, each
channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the number of channels can be arbitrary, but the
depth should be one of <code>CV_8U</code>, <code>CV_16U</code>,
<code>CV_16S</code>, <code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>kernel</CODE> - a kernel<DD><CODE>anchor</CODE> - position of the anchor within the element; default value
<code>(-1, -1)</code> means that the anchor is at the element center.<DD><CODE>iterations</CODE> - number of times erosion is applied.<DD><CODE>borderType</CODE> - pixel extrapolation method (see "borderInterpolate" for
details).<DD><CODE>borderValue</CODE> - border value in case of a constant border (see
"createMorphologyFilter" for details).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#erode">org.opencv.imgproc.Imgproc.erode</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat)"><!-- --></A><H3>
filter2D</H3>
<PRE>
public static void <B>filter2D</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</PRE>
<DL>
<DD><p>Convolves an image with the kernel.</p>
<p>The function applies an arbitrary linear filter to an image. In-place
operation is supported. When the aperture is partially outside the image, the
function interpolates outlier pixel values according to the specified border
mode.</p>
<p>The function does actually compute correlation, not the convolution:</p>
<p><em>dst(x,y) = sum(by: 0 <= x' < kernel.cols, 0 <= y' < kernel.rows)
kernel(x',y')* src(x+x'- anchor.x,y+y'- anchor.y)</em></p>
<p>That is, the kernel is not mirrored around the anchor point. If you need a
real convolution, flip the kernel using "flip" and set the new anchor to
<code>(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)</code>.</p>
<p>The function uses the DFT-based algorithm in case of sufficiently large
kernels (~<code>11 x 11</code> or larger) and the direct algorithm (that uses
the engine retrieved by "createLinearFilter") for small kernels.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - desired depth of the destination image; if it is negative, it
will be the same as <code>src.depth()</code>; the following combinations of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the output image will have the same depth as the
source.</p><DD><CODE>kernel</CODE> - convolution kernel (or rather a correlation kernel), a
single-channel floating point matrix; if you want to apply different kernels
to different channels, split the image into separate color planes using
"split" and process them individually.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#filter2d">org.opencv.imgproc.Imgproc.filter2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double)"><!-- --></A><H3>
filter2D</H3>
<PRE>
public static void <B>filter2D</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta)</PRE>
<DL>
<DD><p>Convolves an image with the kernel.</p>
<p>The function applies an arbitrary linear filter to an image. In-place
operation is supported. When the aperture is partially outside the image, the
function interpolates outlier pixel values according to the specified border
mode.</p>
<p>The function does actually compute correlation, not the convolution:</p>
<p><em>dst(x,y) = sum(by: 0 <= x' < kernel.cols, 0 <= y' < kernel.rows)
kernel(x',y')* src(x+x'- anchor.x,y+y'- anchor.y)</em></p>
<p>That is, the kernel is not mirrored around the anchor point. If you need a
real convolution, flip the kernel using "flip" and set the new anchor to
<code>(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)</code>.</p>
<p>The function uses the DFT-based algorithm in case of sufficiently large
kernels (~<code>11 x 11</code> or larger) and the direct algorithm (that uses
the engine retrieved by "createLinearFilter") for small kernels.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - desired depth of the destination image; if it is negative, it
will be the same as <code>src.depth()</code>; the following combinations of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the output image will have the same depth as the
source.</p><DD><CODE>kernel</CODE> - convolution kernel (or rather a correlation kernel), a
single-channel floating point matrix; if you want to apply different kernels
to different channels, split the image into separate color planes using
"split" and process them individually.<DD><CODE>anchor</CODE> - anchor of the kernel that indicates the relative position of a
filtered point within the kernel; the anchor should lie within the kernel;
default value (-1,-1) means that the anchor is at the kernel center.<DD><CODE>delta</CODE> - optional value added to the filtered pixels before storing them
in <code>dst</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#filter2d">org.opencv.imgproc.Imgproc.filter2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><!-- --></A><H3>
filter2D</H3>
<PRE>
public static void <B>filter2D</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta,
int borderType)</PRE>
<DL>
<DD><p>Convolves an image with the kernel.</p>
<p>The function applies an arbitrary linear filter to an image. In-place
operation is supported. When the aperture is partially outside the image, the
function interpolates outlier pixel values according to the specified border
mode.</p>
<p>The function does actually compute correlation, not the convolution:</p>
<p><em>dst(x,y) = sum(by: 0 <= x' < kernel.cols, 0 <= y' < kernel.rows)
kernel(x',y')* src(x+x'- anchor.x,y+y'- anchor.y)</em></p>
<p>That is, the kernel is not mirrored around the anchor point. If you need a
real convolution, flip the kernel using "flip" and set the new anchor to
<code>(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)</code>.</p>
<p>The function uses the DFT-based algorithm in case of sufficiently large
kernels (~<code>11 x 11</code> or larger) and the direct algorithm (that uses
the engine retrieved by "createLinearFilter") for small kernels.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - desired depth of the destination image; if it is negative, it
will be the same as <code>src.depth()</code>; the following combinations of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the output image will have the same depth as the
source.</p><DD><CODE>kernel</CODE> - convolution kernel (or rather a correlation kernel), a
single-channel floating point matrix; if you want to apply different kernels
to different channels, split the image into separate color planes using
"split" and process them individually.<DD><CODE>anchor</CODE> - anchor of the kernel that indicates the relative position of a
filtered point within the kernel; the anchor should lie within the kernel;
default value (-1,-1) means that the anchor is at the kernel center.<DD><CODE>delta</CODE> - optional value added to the filtered pixels before storing them
in <code>dst</code>.<DD><CODE>borderType</CODE> - pixel extrapolation method (see "borderInterpolate" for
details).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#filter2d">org.opencv.imgproc.Imgproc.filter2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
findContours</H3>
<PRE>
public static void <B>findContours</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hierarchy,
int mode,
int method)</PRE>
<DL>
<DD><p>Finds contours in a binary image.</p>
<p>The function retrieves contours from the binary image using the algorithm
[Suzuki85]. The contours are a useful tool for shape analysis and object
detection and recognition. See <code>squares.c</code> in the OpenCV sample
directory.</p>
<p>Note: Source <code>image</code> is modified by this function. Also, the
function does not take into account 1-pixel border of the image (it's filled
with 0's and used for neighbor analysis in the algorithm), therefore the
contours touching the image border will be clipped.</p>
<p>Note: If you use the new Python interface then the <code>CV_</code> prefix
has to be omitted in contour retrieval mode and contour approximation method
parameters (for example, use <code>cv2.RETR_LIST</code> and <code>cv2.CHAIN_APPROX_NONE</code>
parameters). If you use the old Python interface then these parameters have
the <code>CV_</code> prefix (for example, use <code>cv.CV_RETR_LIST</code>
and <code>cv.CV_CHAIN_APPROX_NONE</code>).</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Source, an 8-bit single-channel image. Non-zero pixels are
treated as 1's. Zero pixels remain 0's, so the image is treated as
<code>binary</code>. You can use "compare", "inRange", "threshold",
"adaptiveThreshold", "Canny", and others to create a binary image out of a
grayscale or color one. The function modifies the <code>image</code> while
extracting the contours.<DD><CODE>contours</CODE> - Detected contours. Each contour is stored as a vector of
points.<DD><CODE>hierarchy</CODE> - Optional output vector, containing information about the
image topology. It has as many elements as the number of contours. For each
i-th contour <code>contours[i]</code>, the elements <code>hierarchy[i][0]</code>,
<code>hiearchy[i][1]</code>, <code>hiearchy[i][2]</code>, and
<code>hiearchy[i][3]</code> are set to 0-based indices in <code>contours</code>
of the next and previous contours at the same hierarchical level, the first
child contour and the parent contour, respectively. If for the contour
<code>i</code> there are no next, previous, parent, or nested contours, the
corresponding elements of <code>hierarchy[i]</code> will be negative.<DD><CODE>mode</CODE> - Contour retrieval mode (if you use Python see also a note below).
<ul>
<li> CV_RETR_EXTERNAL retrieves only the extreme outer contours. It sets
<code>hierarchy[i][2]=hierarchy[i][3]=-1</code> for all the contours.
<li> CV_RETR_LIST retrieves all of the contours without establishing any
hierarchical relationships.
<li> CV_RETR_CCOMP retrieves all of the contours and organizes them into a
two-level hierarchy. At the top level, there are external boundaries of the
components. At the second level, there are boundaries of the holes. If there
is another contour inside a hole of a connected component, it is still put at
the top level.
<li> CV_RETR_TREE retrieves all of the contours and reconstructs a full
hierarchy of nested contours. This full hierarchy is built and shown in the
OpenCV <code>contours.c</code> demo.
</ul><DD><CODE>method</CODE> - Contour approximation method (if you use Python see also a note
below).
<ul>
<li> CV_CHAIN_APPROX_NONE stores absolutely all the contour points. That
is, any 2 subsequent points <code>(x1,y1)</code> and <code>(x2,y2)</code> of
the contour will be either horizontal, vertical or diagonal neighbors, that
is, <code>max(abs(x1-x2),abs(y2-y1))==1</code>.
<li> CV_CHAIN_APPROX_SIMPLE compresses horizontal, vertical, and diagonal
segments and leaves only their end points. For example, an up-right
rectangular contour is encoded with 4 points.
<li> CV_CHAIN_APPROX_TC89_L1,CV_CHAIN_APPROX_TC89_KCOS applies one of the
flavors of the Teh-Chin chain approximation algorithm. See [TehChin89] for
details.
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#findcontours">org.opencv.imgproc.Imgproc.findContours</a></DL>
</DD>
</DL>
<HR>
<A NAME="findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int, org.opencv.core.Point)"><!-- --></A><H3>
findContours</H3>
<PRE>
public static void <B>findContours</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
java.util.List<<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A>> contours,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hierarchy,
int mode,
int method,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> offset)</PRE>
<DL>
<DD><p>Finds contours in a binary image.</p>
<p>The function retrieves contours from the binary image using the algorithm
[Suzuki85]. The contours are a useful tool for shape analysis and object
detection and recognition. See <code>squares.c</code> in the OpenCV sample
directory.</p>
<p>Note: Source <code>image</code> is modified by this function. Also, the
function does not take into account 1-pixel border of the image (it's filled
with 0's and used for neighbor analysis in the algorithm), therefore the
contours touching the image border will be clipped.</p>
<p>Note: If you use the new Python interface then the <code>CV_</code> prefix
has to be omitted in contour retrieval mode and contour approximation method
parameters (for example, use <code>cv2.RETR_LIST</code> and <code>cv2.CHAIN_APPROX_NONE</code>
parameters). If you use the old Python interface then these parameters have
the <code>CV_</code> prefix (for example, use <code>cv.CV_RETR_LIST</code>
and <code>cv.CV_CHAIN_APPROX_NONE</code>).</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Source, an 8-bit single-channel image. Non-zero pixels are
treated as 1's. Zero pixels remain 0's, so the image is treated as
<code>binary</code>. You can use "compare", "inRange", "threshold",
"adaptiveThreshold", "Canny", and others to create a binary image out of a
grayscale or color one. The function modifies the <code>image</code> while
extracting the contours.<DD><CODE>contours</CODE> - Detected contours. Each contour is stored as a vector of
points.<DD><CODE>hierarchy</CODE> - Optional output vector, containing information about the
image topology. It has as many elements as the number of contours. For each
i-th contour <code>contours[i]</code>, the elements <code>hierarchy[i][0]</code>,
<code>hiearchy[i][1]</code>, <code>hiearchy[i][2]</code>, and
<code>hiearchy[i][3]</code> are set to 0-based indices in <code>contours</code>
of the next and previous contours at the same hierarchical level, the first
child contour and the parent contour, respectively. If for the contour
<code>i</code> there are no next, previous, parent, or nested contours, the
corresponding elements of <code>hierarchy[i]</code> will be negative.<DD><CODE>mode</CODE> - Contour retrieval mode (if you use Python see also a note below).
<ul>
<li> CV_RETR_EXTERNAL retrieves only the extreme outer contours. It sets
<code>hierarchy[i][2]=hierarchy[i][3]=-1</code> for all the contours.
<li> CV_RETR_LIST retrieves all of the contours without establishing any
hierarchical relationships.
<li> CV_RETR_CCOMP retrieves all of the contours and organizes them into a
two-level hierarchy. At the top level, there are external boundaries of the
components. At the second level, there are boundaries of the holes. If there
is another contour inside a hole of a connected component, it is still put at
the top level.
<li> CV_RETR_TREE retrieves all of the contours and reconstructs a full
hierarchy of nested contours. This full hierarchy is built and shown in the
OpenCV <code>contours.c</code> demo.
</ul><DD><CODE>method</CODE> - Contour approximation method (if you use Python see also a note
below).
<ul>
<li> CV_CHAIN_APPROX_NONE stores absolutely all the contour points. That
is, any 2 subsequent points <code>(x1,y1)</code> and <code>(x2,y2)</code> of
the contour will be either horizontal, vertical or diagonal neighbors, that
is, <code>max(abs(x1-x2),abs(y2-y1))==1</code>.
<li> CV_CHAIN_APPROX_SIMPLE compresses horizontal, vertical, and diagonal
segments and leaves only their end points. For example, an up-right
rectangular contour is encoded with 4 points.
<li> CV_CHAIN_APPROX_TC89_L1,CV_CHAIN_APPROX_TC89_KCOS applies one of the
flavors of the Teh-Chin chain approximation algorithm. See [TehChin89] for
details.
</ul><DD><CODE>offset</CODE> - Optional offset by which every contour point is shifted. This
is useful if the contours are extracted from the image ROI and then they
should be analyzed in the whole image context.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#findcontours">org.opencv.imgproc.Imgproc.findContours</a></DL>
</DD>
</DL>
<HR>
<A NAME="fitEllipse(org.opencv.core.MatOfPoint2f)"><!-- --></A><H3>
fitEllipse</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/RotatedRect.html" title="class in org.opencv.core">RotatedRect</A> <B>fitEllipse</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> points)</PRE>
<DL>
<DD><p>Fits an ellipse around a set of 2D points.</p>
<p>The function calculates the ellipse that fits (in a least-squares sense) a
set of 2D points best of all. It returns the rotated rectangle in which the
ellipse is inscribed. The algorithm [Fitzgibbon95] is used.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input 2D point set, stored in:
<ul>
<li> <code>std.vector<></code> or <code>Mat</code> (C++ interface)
<li> <code>CvSeq*</code> or <code>CvMat*</code> (C interface)
<li> Nx2 numpy array (Python interface)
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#fitellipse">org.opencv.imgproc.Imgproc.fitEllipse</a></DL>
</DD>
</DL>
<HR>
<A NAME="fitLine(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, double)"><!-- --></A><H3>
fitLine</H3>
<PRE>
public static void <B>fitLine</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> points,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> line,
int distType,
double param,
double reps,
double aeps)</PRE>
<DL>
<DD><p>Fits a line to a 2D or 3D point set.</p>
<p>The function <code>fitLine</code> fits a line to a 2D or 3D point set by
minimizing <em>sum_i rho(r_i)</em> where <em>r_i</em> is a distance between
the <em>i^(th)</em> point, the line and <em>rho(r)</em> is a distance
function, one of the following:</p>
<ul>
<li> distType=CV_DIST_L2
</ul>
<p><em>rho(r) = r^2/2(the simplest and the fastest least-squares method)</em></p>
<ul>
<li> distType=CV_DIST_L1
</ul>
<p><em>rho(r) = r</em></p>
<ul>
<li> distType=CV_DIST_L12
</ul>
<p><em>rho(r) = 2 * (sqrt(1 + frac(r^2)2) - 1)</em></p>
<ul>
<li> distType=CV_DIST_FAIR
</ul>
<p><em>rho(r) = C^2 * ((r)/(C) - log((1 + (r)/(C)))) where C=1.3998</em></p>
<ul>
<li> distType=CV_DIST_WELSCH
</ul>
<p><em>rho(r) = (C^2)/2 * (1 - exp((-((r)/(C))^2))) where C=2.9846</em></p>
<ul>
<li> distType=CV_DIST_HUBER
</ul>
<p><em>rho(r) = r^2/2 if r < C; C * (r-C/2) otherwise where C=1.345</em></p>
<p>The algorithm is based on the M-estimator (http://en.wikipedia.org/wiki/M-estimator)
technique that iteratively fits the line using the weighted least-squares
algorithm. After each iteration the weights <em>w_i</em> are adjusted to be
inversely proportional to <em>rho(r_i)</em>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input vector of 2D or 3D points, stored in <code>std.vector<></code>
or <code>Mat</code>.<DD><CODE>line</CODE> - Output line parameters. In case of 2D fitting, it should be a
vector of 4 elements (like <code>Vec4f</code>) - <code>(vx, vy, x0,
y0)</code>, where <code>(vx, vy)</code> is a normalized vector collinear to
the line and <code>(x0, y0)</code> is a point on the line. In case of 3D
fitting, it should be a vector of 6 elements (like <code>Vec6f</code>) -
<code>(vx, vy, vz, x0, y0, z0)</code>, where <code>(vx, vy, vz)</code> is a
normalized vector collinear to the line and <code>(x0, y0, z0)</code> is a
point on the line.<DD><CODE>distType</CODE> - Distance used by the M-estimator (see the discussion below).<DD><CODE>param</CODE> - Numerical parameter (<code>C</code>) for some types of
distances. If it is 0, an optimal value is chosen.<DD><CODE>reps</CODE> - Sufficient accuracy for the radius (distance between the
coordinate origin and the line).<DD><CODE>aeps</CODE> - Sufficient accuracy for the angle. 0.01 would be a good default
value for <code>reps</code> and <code>aeps</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#fitline">org.opencv.imgproc.Imgproc.fitLine</a></DL>
</DD>
</DL>
<HR>
<A NAME="floodFill(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, org.opencv.core.Scalar)"><!-- --></A><H3>
floodFill</H3>
<PRE>
public static int <B>floodFill</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> seedPoint,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> newVal)</PRE>
<DL>
<DD><p>Fills a connected component with the given color.</p>
<p>The functions <code>floodFill</code> fill a connected component starting from
the seed point with the specified color. The connectivity is determined by
the color/brightness closeness of the neighbor pixels. The pixel at
<em>(x,y)</em> is considered to belong to the repainted domain if:</p>
<ul>
<li> <em>src(x',y')- loDiff <= src(x,y) <= src(x',y')+ upDiff</em>
</ul>
<p>in case of a grayscale image and floating range</p>
<ul>
<li> <em>src(seedPoint.x, seedPoint.y)- loDiff <= src(x,y) <=
src(seedPoint.x, seedPoint.y)+ upDiff</em>
</ul>
<p>in case of a grayscale image and fixed range</p>
<ul>
<li> <em>src(x',y')_r- loDiff _r <= src(x,y)_r <= src(x',y')_r+ upDiff
_r,</em>
</ul>
<p><em>src(x',y')_g- loDiff _g <= src(x,y)_g <= src(x',y')_g+ upDiff _g</em></p>
<p>and</p>
<p><em>src(x',y')_b- loDiff _b <= src(x,y)_b <= src(x',y')_b+ upDiff _b</em></p>
<p>in case of a color image and floating range</p>
<ul>
<li> <em>src(seedPoint.x, seedPoint.y)_r- loDiff _r <= src(x,y)_r <=
src(seedPoint.x, seedPoint.y)_r+ upDiff _r,</em>
</ul>
<p><em>src(seedPoint.x, seedPoint.y)_g- loDiff _g <= src(x,y)_g <=
src(seedPoint.x, seedPoint.y)_g+ upDiff _g</em></p>
<p>and</p>
<p><em>src(seedPoint.x, seedPoint.y)_b- loDiff _b <= src(x,y)_b <=
src(seedPoint.x, seedPoint.y)_b+ upDiff _b</em></p>
<p>in case of a color image and fixed range</p>
<p>where <em>src(x',y')</em> is the value of one of pixel neighbors that is
already known to belong to the component. That is, to be added to the
connected component, a color/brightness of the pixel should be close enough
to:</p>
<ul>
<li> Color/brightness of one of its neighbors that already belong to the
connected component in case of a floating range.
<li> Color/brightness of the seed point in case of a fixed range.
</ul>
<p>Use these functions to either mark a connected component with the specified
color in-place, or build a mask and then extract the contour, or copy the
region to another image, and so on. Various modes of the function are
demonstrated in the <code>floodfill.cpp</code> sample.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Input/output 1- or 3-channel, 8-bit, or floating-point image. It
is modified by the function unless the <code>FLOODFILL_MASK_ONLY</code> flag
is set in the second variant of the function. See the details below.<DD><CODE>mask</CODE> - (For the second function only) Operation mask that should be a
single-channel 8-bit image, 2 pixels wider and 2 pixels taller. The function
uses and updates the mask, so you take responsibility of initializing the
<code>mask</code> content. Flood-filling cannot go across non-zero pixels in
the mask. For example, an edge detector output can be used as a mask to stop
filling at edges. It is possible to use the same mask in multiple calls to
the function to make sure the filled area does not overlap.
<p>Note: Since the mask is larger than the filled image, a pixel <em>(x, y)</em>
in <code>image</code> corresponds to the pixel <em>(x+1, y+1)</em> in the
<code>mask</code>.</p><DD><CODE>seedPoint</CODE> - Starting point.<DD><CODE>newVal</CODE> - New value of the repainted domain pixels.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#floodfill">org.opencv.imgproc.Imgproc.floodFill</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int, org.opencv.core.Point)"><CODE>findContours(org.opencv.core.Mat, java.util.List<org.opencv.core.MatOfPoint>, org.opencv.core.Mat, int, int, org.opencv.core.Point)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="floodFill(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, org.opencv.core.Scalar, org.opencv.core.Rect, org.opencv.core.Scalar, org.opencv.core.Scalar, int)"><!-- --></A><H3>
floodFill</H3>
<PRE>
public static int <B>floodFill</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> seedPoint,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> newVal,
<A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> rect,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> loDiff,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> upDiff,
int flags)</PRE>
<DL>
<DD><p>Fills a connected component with the given color.</p>
<p>The functions <code>floodFill</code> fill a connected component starting from
the seed point with the specified color. The connectivity is determined by
the color/brightness closeness of the neighbor pixels. The pixel at
<em>(x,y)</em> is considered to belong to the repainted domain if:</p>
<ul>
<li> <em>src(x',y')- loDiff <= src(x,y) <= src(x',y')+ upDiff</em>
</ul>
<p>in case of a grayscale image and floating range</p>
<ul>
<li> <em>src(seedPoint.x, seedPoint.y)- loDiff <= src(x,y) <=
src(seedPoint.x, seedPoint.y)+ upDiff</em>
</ul>
<p>in case of a grayscale image and fixed range</p>
<ul>
<li> <em>src(x',y')_r- loDiff _r <= src(x,y)_r <= src(x',y')_r+ upDiff
_r,</em>
</ul>
<p><em>src(x',y')_g- loDiff _g <= src(x,y)_g <= src(x',y')_g+ upDiff _g</em></p>
<p>and</p>
<p><em>src(x',y')_b- loDiff _b <= src(x,y)_b <= src(x',y')_b+ upDiff _b</em></p>
<p>in case of a color image and floating range</p>
<ul>
<li> <em>src(seedPoint.x, seedPoint.y)_r- loDiff _r <= src(x,y)_r <=
src(seedPoint.x, seedPoint.y)_r+ upDiff _r,</em>
</ul>
<p><em>src(seedPoint.x, seedPoint.y)_g- loDiff _g <= src(x,y)_g <=
src(seedPoint.x, seedPoint.y)_g+ upDiff _g</em></p>
<p>and</p>
<p><em>src(seedPoint.x, seedPoint.y)_b- loDiff _b <= src(x,y)_b <=
src(seedPoint.x, seedPoint.y)_b+ upDiff _b</em></p>
<p>in case of a color image and fixed range</p>
<p>where <em>src(x',y')</em> is the value of one of pixel neighbors that is
already known to belong to the component. That is, to be added to the
connected component, a color/brightness of the pixel should be close enough
to:</p>
<ul>
<li> Color/brightness of one of its neighbors that already belong to the
connected component in case of a floating range.
<li> Color/brightness of the seed point in case of a fixed range.
</ul>
<p>Use these functions to either mark a connected component with the specified
color in-place, or build a mask and then extract the contour, or copy the
region to another image, and so on. Various modes of the function are
demonstrated in the <code>floodfill.cpp</code> sample.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Input/output 1- or 3-channel, 8-bit, or floating-point image. It
is modified by the function unless the <code>FLOODFILL_MASK_ONLY</code> flag
is set in the second variant of the function. See the details below.<DD><CODE>mask</CODE> - (For the second function only) Operation mask that should be a
single-channel 8-bit image, 2 pixels wider and 2 pixels taller. The function
uses and updates the mask, so you take responsibility of initializing the
<code>mask</code> content. Flood-filling cannot go across non-zero pixels in
the mask. For example, an edge detector output can be used as a mask to stop
filling at edges. It is possible to use the same mask in multiple calls to
the function to make sure the filled area does not overlap.
<p>Note: Since the mask is larger than the filled image, a pixel <em>(x, y)</em>
in <code>image</code> corresponds to the pixel <em>(x+1, y+1)</em> in the
<code>mask</code>.</p><DD><CODE>seedPoint</CODE> - Starting point.<DD><CODE>newVal</CODE> - New value of the repainted domain pixels.<DD><CODE>rect</CODE> - Optional output parameter set by the function to the minimum
bounding rectangle of the repainted domain.<DD><CODE>loDiff</CODE> - Maximal lower brightness/color difference between the currently
observed pixel and one of its neighbors belonging to the component, or a seed
pixel being added to the component.<DD><CODE>upDiff</CODE> - Maximal upper brightness/color difference between the currently
observed pixel and one of its neighbors belonging to the component, or a seed
pixel being added to the component.<DD><CODE>flags</CODE> - Operation flags. Lower bits contain a connectivity value, 4
(default) or 8, used within the function. Connectivity determines which
neighbors of a pixel are considered. Upper bits can be 0 or a combination of
the following flags:
<ul>
<li> FLOODFILL_FIXED_RANGE If set, the difference between the current pixel
and seed pixel is considered. Otherwise, the difference between neighbor
pixels is considered (that is, the range is floating).
<li> FLOODFILL_MASK_ONLY If set, the function does not change the image
(<code>newVal</code> is ignored), but fills the mask. The flag can be used
for the second variant only.
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#floodfill">org.opencv.imgproc.Imgproc.floodFill</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int, org.opencv.core.Point)"><CODE>findContours(org.opencv.core.Mat, java.util.List<org.opencv.core.MatOfPoint>, org.opencv.core.Mat, int, int, org.opencv.core.Point)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double)"><!-- --></A><H3>
GaussianBlur</H3>
<PRE>
public static void <B>GaussianBlur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigmaX)</PRE>
<DL>
<DD><p>Blurs an image using a Gaussian filter.</p>
<p>The function convolves the source image with the specified Gaussian kernel.
In-place filtering is supported.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the image can have any number of channels, which are
processed independently, but the depth should be <code>CV_8U</code>,
<code>CV_16U</code>, <code>CV_16S</code>, <code>CV_32F</code> or
<code>CV_64F</code>.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - Gaussian kernel size. <code>ksize.width</code> and
<code>ksize.height</code> can differ but they both must be positive and odd.
Or, they can be zero's and then they are computed from <code>sigma*</code>.<DD><CODE>sigmaX</CODE> - Gaussian kernel standard deviation in X direction.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#gaussianblur">org.opencv.imgproc.Imgproc.GaussianBlur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double)"><!-- --></A><H3>
GaussianBlur</H3>
<PRE>
public static void <B>GaussianBlur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigmaX,
double sigmaY)</PRE>
<DL>
<DD><p>Blurs an image using a Gaussian filter.</p>
<p>The function convolves the source image with the specified Gaussian kernel.
In-place filtering is supported.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the image can have any number of channels, which are
processed independently, but the depth should be <code>CV_8U</code>,
<code>CV_16U</code>, <code>CV_16S</code>, <code>CV_32F</code> or
<code>CV_64F</code>.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - Gaussian kernel size. <code>ksize.width</code> and
<code>ksize.height</code> can differ but they both must be positive and odd.
Or, they can be zero's and then they are computed from <code>sigma*</code>.<DD><CODE>sigmaX</CODE> - Gaussian kernel standard deviation in X direction.<DD><CODE>sigmaY</CODE> - Gaussian kernel standard deviation in Y direction; if
<code>sigmaY</code> is zero, it is set to be equal to <code>sigmaX</code>, if
both sigmas are zeros, they are computed from <code>ksize.width</code> and
<code>ksize.height</code>, respectively (see "getGaussianKernel" for
details); to fully control the result regardless of possible future
modifications of all this semantics, it is recommended to specify all of
<code>ksize</code>, <code>sigmaX</code>, and <code>sigmaY</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#gaussianblur">org.opencv.imgproc.Imgproc.GaussianBlur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><!-- --></A><H3>
GaussianBlur</H3>
<PRE>
public static void <B>GaussianBlur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigmaX,
double sigmaY,
int borderType)</PRE>
<DL>
<DD><p>Blurs an image using a Gaussian filter.</p>
<p>The function convolves the source image with the specified Gaussian kernel.
In-place filtering is supported.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image; the image can have any number of channels, which are
processed independently, but the depth should be <code>CV_8U</code>,
<code>CV_16U</code>, <code>CV_16S</code>, <code>CV_32F</code> or
<code>CV_64F</code>.<DD><CODE>dst</CODE> - output image of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - Gaussian kernel size. <code>ksize.width</code> and
<code>ksize.height</code> can differ but they both must be positive and odd.
Or, they can be zero's and then they are computed from <code>sigma*</code>.<DD><CODE>sigmaX</CODE> - Gaussian kernel standard deviation in X direction.<DD><CODE>sigmaY</CODE> - Gaussian kernel standard deviation in Y direction; if
<code>sigmaY</code> is zero, it is set to be equal to <code>sigmaX</code>, if
both sigmas are zeros, they are computed from <code>ksize.width</code> and
<code>ksize.height</code>, respectively (see "getGaussianKernel" for
details); to fully control the result regardless of possible future
modifications of all this semantics, it is recommended to specify all of
<code>ksize</code>, <code>sigmaX</code>, and <code>sigmaY</code>.<DD><CODE>borderType</CODE> - pixel extrapolation method (see "borderInterpolate" for
details).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#gaussianblur">org.opencv.imgproc.Imgproc.GaussianBlur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getAffineTransform(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f)"><!-- --></A><H3>
getAffineTransform</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getAffineTransform</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> src,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> dst)</PRE>
<DL>
<DD><p>Calculates an affine transform from three pairs of the corresponding points.</p>
<p>The function calculates the <em>2 x 3</em> matrix of an affine transform so
that:</p>
<p><em>x'_i
y'_i = map_matrix * x_i
y_i
1 </em></p>
<p>where</p>
<p><em>dst(i)=(x'_i,y'_i),<BR>src(i)=(x_i, y_i),<BR>i=0,1,2</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Coordinates of triangle vertices in the source image.<DD><CODE>dst</CODE> - Coordinates of the corresponding triangle vertices in the
destination image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getaffinetransform">org.opencv.imgproc.Imgproc.getAffineTransform</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getDefaultNewCameraMatrix(org.opencv.core.Mat)"><!-- --></A><H3>
getDefaultNewCameraMatrix</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getDefaultNewCameraMatrix</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix)</PRE>
<DL>
<DD><p>Returns the default new camera matrix.</p>
<p>The function returns the camera matrix that is either an exact copy of the
input <code>cameraMatrix</code> (when <code>centerPrinicipalPoint=false</code>),
or the modified one (when <code>centerPrincipalPoint=true</code>).</p>
<p>In the latter case, the new camera matrix will be:</p>
<p><em>f_x 0(imgSize.width -1)*0.5
0 f_y(imgSize.height -1)*0.5
0 0 1,</em></p>
<p>where <em>f_x</em> and <em>f_y</em> are <em>(0,0)</em> and <em>(1,1)</em>
elements of <code>cameraMatrix</code>, respectively.</p>
<p>By default, the undistortion functions in OpenCV (see "initUndistortRectifyMap",
"undistort") do not move the principal point. However, when you work with
stereo, it is important to move the principal points in both views to the
same y-coordinate (which is required by most of stereo correspondence
algorithms), and may be to the same x-coordinate too. So, you can form the
new camera matrix for each view where the principal points are located at the
center.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>cameraMatrix</CODE> - Input camera matrix.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getdefaultnewcameramatrix">org.opencv.imgproc.Imgproc.getDefaultNewCameraMatrix</a></DL>
</DD>
</DL>
<HR>
<A NAME="getDefaultNewCameraMatrix(org.opencv.core.Mat, org.opencv.core.Size, boolean)"><!-- --></A><H3>
getDefaultNewCameraMatrix</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getDefaultNewCameraMatrix</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> imgsize,
boolean centerPrincipalPoint)</PRE>
<DL>
<DD><p>Returns the default new camera matrix.</p>
<p>The function returns the camera matrix that is either an exact copy of the
input <code>cameraMatrix</code> (when <code>centerPrinicipalPoint=false</code>),
or the modified one (when <code>centerPrincipalPoint=true</code>).</p>
<p>In the latter case, the new camera matrix will be:</p>
<p><em>f_x 0(imgSize.width -1)*0.5
0 f_y(imgSize.height -1)*0.5
0 0 1,</em></p>
<p>where <em>f_x</em> and <em>f_y</em> are <em>(0,0)</em> and <em>(1,1)</em>
elements of <code>cameraMatrix</code>, respectively.</p>
<p>By default, the undistortion functions in OpenCV (see "initUndistortRectifyMap",
"undistort") do not move the principal point. However, when you work with
stereo, it is important to move the principal points in both views to the
same y-coordinate (which is required by most of stereo correspondence
algorithms), and may be to the same x-coordinate too. So, you can form the
new camera matrix for each view where the principal points are located at the
center.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>cameraMatrix</CODE> - Input camera matrix.<DD><CODE>imgsize</CODE> - Camera view image size in pixels.<DD><CODE>centerPrincipalPoint</CODE> - Location of the principal point in the new camera
matrix. The parameter indicates whether this location should be at the image
center or not.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getdefaultnewcameramatrix">org.opencv.imgproc.Imgproc.getDefaultNewCameraMatrix</a></DL>
</DD>
</DL>
<HR>
<A NAME="getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><!-- --></A><H3>
getDerivKernels</H3>
<PRE>
public static void <B>getDerivKernels</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kx,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> ky,
int dx,
int dy,
int ksize)</PRE>
<DL>
<DD><p>Returns filter coefficients for computing spatial image derivatives.</p>
<p>The function computes and returns the filter coefficients for spatial image
derivatives. When <code>ksize=CV_SCHARR</code>, the Scharr <em>3 x 3</em>
kernels are generated (see "Scharr"). Otherwise, Sobel kernels are generated
(see "Sobel"). The filters are normally passed to "sepFilter2D" or to
"createSeparableLinearFilter".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>kx</CODE> - Output matrix of row filter coefficients. It has the type
<code>ktype</code>.<DD><CODE>ky</CODE> - Output matrix of column filter coefficients. It has the type
<code>ktype</code>.<DD><CODE>dx</CODE> - Derivative order in respect of x.<DD><CODE>dy</CODE> - Derivative order in respect of y.<DD><CODE>ksize</CODE> - Aperture size. It can be <code>CV_SCHARR</code>, 1, 3, 5, or 7.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#getderivkernels">org.opencv.imgproc.Imgproc.getDerivKernels</a></DL>
</DD>
</DL>
<HR>
<A NAME="getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, boolean, int)"><!-- --></A><H3>
getDerivKernels</H3>
<PRE>
public static void <B>getDerivKernels</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kx,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> ky,
int dx,
int dy,
int ksize,
boolean normalize,
int ktype)</PRE>
<DL>
<DD><p>Returns filter coefficients for computing spatial image derivatives.</p>
<p>The function computes and returns the filter coefficients for spatial image
derivatives. When <code>ksize=CV_SCHARR</code>, the Scharr <em>3 x 3</em>
kernels are generated (see "Scharr"). Otherwise, Sobel kernels are generated
(see "Sobel"). The filters are normally passed to "sepFilter2D" or to
"createSeparableLinearFilter".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>kx</CODE> - Output matrix of row filter coefficients. It has the type
<code>ktype</code>.<DD><CODE>ky</CODE> - Output matrix of column filter coefficients. It has the type
<code>ktype</code>.<DD><CODE>dx</CODE> - Derivative order in respect of x.<DD><CODE>dy</CODE> - Derivative order in respect of y.<DD><CODE>ksize</CODE> - Aperture size. It can be <code>CV_SCHARR</code>, 1, 3, 5, or 7.<DD><CODE>normalize</CODE> - Flag indicating whether to normalize (scale down) the filter
coefficients or not. Theoretically, the coefficients should have the
denominator <em>=2^(ksize*2-dx-dy-2)</em>. If you are going to filter
floating-point images, you are likely to use the normalized kernels. But if
you compute derivatives of an 8-bit image, store the results in a 16-bit
image, and wish to preserve all the fractional bits, you may want to set
<code>normalize=false</code>.<DD><CODE>ktype</CODE> - Type of filter coefficients. It can be <code>CV_32f</code> or
<code>CV_64F</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#getderivkernels">org.opencv.imgproc.Imgproc.getDerivKernels</a></DL>
</DD>
</DL>
<HR>
<A NAME="getGaborKernel(org.opencv.core.Size, double, double, double, double)"><!-- --></A><H3>
getGaborKernel</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getGaborKernel</B>(<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigma,
double theta,
double lambd,
double gamma)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="getGaborKernel(org.opencv.core.Size, double, double, double, double, double, int)"><!-- --></A><H3>
getGaborKernel</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getGaborKernel</B>(<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
double sigma,
double theta,
double lambd,
double gamma,
double psi,
int ktype)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="getGaussianKernel(int, double)"><!-- --></A><H3>
getGaussianKernel</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getGaussianKernel</B>(int ksize,
double sigma)</PRE>
<DL>
<DD><p>Returns Gaussian filter coefficients.</p>
<p>The function computes and returns the <em>ksize x 1</em> matrix of Gaussian
filter coefficients:</p>
<p><em>G_i= alpha *e^(-(i-(ksize -1)/2)^2/(2* sigma)^2),</em></p>
<p>where <em>i=0..ksize-1</em> and <em>alpha</em> is the scale factor chosen so
that <em>sum_i G_i=1</em>.</p>
<p>Two of such generated kernels can be passed to "sepFilter2D" or to
"createSeparableLinearFilter". Those functions automatically recognize
smoothing kernels (a symmetrical kernel with sum of weights equal to 1) and
handle them accordingly. You may also use the higher-level "GaussianBlur".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>ksize</CODE> - Aperture size. It should be odd (<em>ksize mod 2 = 1</em>) and
positive.<DD><CODE>sigma</CODE> - Gaussian standard deviation. If it is non-positive, it is
computed from <code>ksize</code> as <code>sigma = 0.3*((ksize-1)*0.5 - 1) +
0.8</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#getgaussiankernel">org.opencv.imgproc.Imgproc.getGaussianKernel</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getStructuringElement(int, org.opencv.core.Size, org.opencv.core.Point)"><CODE>getStructuringElement(int, org.opencv.core.Size, org.opencv.core.Point)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, boolean, int)"><CODE>getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, boolean, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getGaussianKernel(int, double, int)"><!-- --></A><H3>
getGaussianKernel</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getGaussianKernel</B>(int ksize,
double sigma,
int ktype)</PRE>
<DL>
<DD><p>Returns Gaussian filter coefficients.</p>
<p>The function computes and returns the <em>ksize x 1</em> matrix of Gaussian
filter coefficients:</p>
<p><em>G_i= alpha *e^(-(i-(ksize -1)/2)^2/(2* sigma)^2),</em></p>
<p>where <em>i=0..ksize-1</em> and <em>alpha</em> is the scale factor chosen so
that <em>sum_i G_i=1</em>.</p>
<p>Two of such generated kernels can be passed to "sepFilter2D" or to
"createSeparableLinearFilter". Those functions automatically recognize
smoothing kernels (a symmetrical kernel with sum of weights equal to 1) and
handle them accordingly. You may also use the higher-level "GaussianBlur".</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>ksize</CODE> - Aperture size. It should be odd (<em>ksize mod 2 = 1</em>) and
positive.<DD><CODE>sigma</CODE> - Gaussian standard deviation. If it is non-positive, it is
computed from <code>ksize</code> as <code>sigma = 0.3*((ksize-1)*0.5 - 1) +
0.8</code>.<DD><CODE>ktype</CODE> - Type of filter coefficients. It can be <code>CV_32f</code> or
<code>CV_64F</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#getgaussiankernel">org.opencv.imgproc.Imgproc.getGaussianKernel</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getStructuringElement(int, org.opencv.core.Size, org.opencv.core.Point)"><CODE>getStructuringElement(int, org.opencv.core.Size, org.opencv.core.Point)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, boolean, int)"><CODE>getDerivKernels(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, boolean, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getPerspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
getPerspectiveTransform</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getPerspectiveTransform</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Calculates a perspective transform from four pairs of the corresponding
points.</p>
<p>The function calculates the <em>3 x 3</em> matrix of a perspective transform
so that:</p>
<p><em>t_i x'_i
t_i y'_i
t_i = map_matrix * x_i
y_i
1 </em></p>
<p>where</p>
<p><em>dst(i)=(x'_i,y'_i),<BR>src(i)=(x_i, y_i),<BR>i=0,1,2,3</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Coordinates of quadrangle vertices in the source image.<DD><CODE>dst</CODE> - Coordinates of the corresponding quadrangle vertices in the
destination image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getperspectivetransform">org.opencv.imgproc.Imgproc.getPerspectiveTransform</a>,
<A HREF="../../../org/opencv/calib3d/Calib3d.html#findHomography(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, int, double, org.opencv.core.Mat)"><CODE>Calib3d.findHomography(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, int, double, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat)"><!-- --></A><H3>
getRectSubPix</H3>
<PRE>
public static void <B>getRectSubPix</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> patchSize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> patch)</PRE>
<DL>
<DD><p>Retrieves a pixel rectangle from an image with sub-pixel accuracy.</p>
<p>The function <code>getRectSubPix</code> extracts pixels from <code>src</code></p>
<p><em>dst(x, y) = src(x + center.x - (dst.cols -1)*0.5, y + center.y -
(dst.rows -1)*0.5)</em></p>
<p>where the values of the pixels at non-integer coordinates are retrieved using
bilinear interpolation. Every channel of multi-channel images is processed
independently. While the center of the rectangle must be inside the image,
parts of the rectangle may be outside. In this case, the replication border
mode (see "borderInterpolate") is used to extrapolate the pixel values
outside of the image.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - a image<DD><CODE>patchSize</CODE> - Size of the extracted patch.<DD><CODE>center</CODE> - Floating point coordinates of the center of the extracted
rectangle within the source image. The center must be inside the image.<DD><CODE>patch</CODE> - a patch<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getrectsubpix">org.opencv.imgproc.Imgproc.getRectSubPix</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><!-- --></A><H3>
getRectSubPix</H3>
<PRE>
public static void <B>getRectSubPix</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> patchSize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> patch,
int patchType)</PRE>
<DL>
<DD><p>Retrieves a pixel rectangle from an image with sub-pixel accuracy.</p>
<p>The function <code>getRectSubPix</code> extracts pixels from <code>src</code></p>
<p><em>dst(x, y) = src(x + center.x - (dst.cols -1)*0.5, y + center.y -
(dst.rows -1)*0.5)</em></p>
<p>where the values of the pixels at non-integer coordinates are retrieved using
bilinear interpolation. Every channel of multi-channel images is processed
independently. While the center of the rectangle must be inside the image,
parts of the rectangle may be outside. In this case, the replication border
mode (see "borderInterpolate") is used to extrapolate the pixel values
outside of the image.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - a image<DD><CODE>patchSize</CODE> - Size of the extracted patch.<DD><CODE>center</CODE> - Floating point coordinates of the center of the extracted
rectangle within the source image. The center must be inside the image.<DD><CODE>patch</CODE> - a patch<DD><CODE>patchType</CODE> - Depth of the extracted pixels. By default, they have the
same depth as <code>src</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getrectsubpix">org.opencv.imgproc.Imgproc.getRectSubPix</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getRotationMatrix2D(org.opencv.core.Point, double, double)"><!-- --></A><H3>
getRotationMatrix2D</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getRotationMatrix2D</B>(<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
double angle,
double scale)</PRE>
<DL>
<DD><p>Calculates an affine matrix of 2D rotation.</p>
<p>The function calculates the following matrix:</p>
<p><em>alpha beta(1- alpha) * center.x - beta * center.y
- beta alpha beta * center.x + (1- alpha) * center.y </em></p>
<p>where</p>
<p><em>alpha = scale * cos angle,
beta = scale * sin angle </em></p>
<p>The transformation maps the rotation center to itself. If this is not the
target, adjust the shift.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>center</CODE> - Center of the rotation in the source image.<DD><CODE>angle</CODE> - Rotation angle in degrees. Positive values mean
counter-clockwise rotation (the coordinate origin is assumed to be the
top-left corner).<DD><CODE>scale</CODE> - Isotropic scale factor.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#getrotationmatrix2d">org.opencv.imgproc.Imgproc.getRotationMatrix2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getAffineTransform(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f)"><CODE>getAffineTransform(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="getStructuringElement(int, org.opencv.core.Size)"><!-- --></A><H3>
getStructuringElement</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getStructuringElement</B>(int shape,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize)</PRE>
<DL>
<DD><p>Returns a structuring element of the specified size and shape for
morphological operations.</p>
<p>The function constructs and returns the structuring element that can be
further passed to "createMorphologyFilter", "erode", "dilate" or
"morphologyEx". But you can also construct an arbitrary binary mask yourself
and use it as the structuring element.</p>
<p>Note: When using OpenCV 1.x C API, the created structuring element
<code>IplConvKernel* element</code> must be released in the end using
<code>cvReleaseStructuringElement(&element)</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>shape</CODE> - Element shape that could be one of the following:
<ul>
<li> MORPH_RECT - a rectangular structuring element:
</ul>
<p><em>E_(ij)=1</em></p>
<ul>
<li> MORPH_ELLIPSE - an elliptic structuring element, that is, a filled
ellipse inscribed into the rectangle <code>Rect(0, 0, esize.width,
0.esize.height)</code>
<li> MORPH_CROSS - a cross-shaped structuring element:
</ul>
<p><em>E_(ij) = 1 if i=anchor.y or j=anchor.x; 0 otherwise</em></p>
<ul>
<li> CV_SHAPE_CUSTOM - custom structuring element (OpenCV 1.x API)
</ul><DD><CODE>ksize</CODE> - Size of the structuring element.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#getstructuringelement">org.opencv.imgproc.Imgproc.getStructuringElement</a></DL>
</DD>
</DL>
<HR>
<A NAME="getStructuringElement(int, org.opencv.core.Size, org.opencv.core.Point)"><!-- --></A><H3>
getStructuringElement</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> <B>getStructuringElement</B>(int shape,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> ksize,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor)</PRE>
<DL>
<DD><p>Returns a structuring element of the specified size and shape for
morphological operations.</p>
<p>The function constructs and returns the structuring element that can be
further passed to "createMorphologyFilter", "erode", "dilate" or
"morphologyEx". But you can also construct an arbitrary binary mask yourself
and use it as the structuring element.</p>
<p>Note: When using OpenCV 1.x C API, the created structuring element
<code>IplConvKernel* element</code> must be released in the end using
<code>cvReleaseStructuringElement(&element)</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>shape</CODE> - Element shape that could be one of the following:
<ul>
<li> MORPH_RECT - a rectangular structuring element:
</ul>
<p><em>E_(ij)=1</em></p>
<ul>
<li> MORPH_ELLIPSE - an elliptic structuring element, that is, a filled
ellipse inscribed into the rectangle <code>Rect(0, 0, esize.width,
0.esize.height)</code>
<li> MORPH_CROSS - a cross-shaped structuring element:
</ul>
<p><em>E_(ij) = 1 if i=anchor.y or j=anchor.x; 0 otherwise</em></p>
<ul>
<li> CV_SHAPE_CUSTOM - custom structuring element (OpenCV 1.x API)
</ul><DD><CODE>ksize</CODE> - Size of the structuring element.<DD><CODE>anchor</CODE> - Anchor position within the element. The default value <em>(-1,
-1)</em> means that the anchor is at the center. Note that only the shape of
a cross-shaped element depends on the anchor position. In other cases the
anchor just regulates how much the result of the morphological operation is
shifted.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#getstructuringelement">org.opencv.imgproc.Imgproc.getStructuringElement</a></DL>
</DD>
</DL>
<HR>
<A NAME="goodFeaturesToTrack(org.opencv.core.Mat, org.opencv.core.MatOfPoint, int, double, double)"><!-- --></A><H3>
goodFeaturesToTrack</H3>
<PRE>
public static void <B>goodFeaturesToTrack</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> corners,
int maxCorners,
double qualityLevel,
double minDistance)</PRE>
<DL>
<DD><p>Determines strong corners on an image.</p>
<p>The function finds the most prominent corners in the image or in the
specified image region, as described in [Shi94]:</p>
<ul>
<li> Function calculates the corner quality measure at every source image
pixel using the "cornerMinEigenVal" or "cornerHarris".
<li> Function performs a non-maximum suppression (the local maximums in *3
x 3* neighborhood are retained).
<li> The corners with the minimal eigenvalue less than <em>qualityLevel *
max_(x,y) qualityMeasureMap(x,y)</em> are rejected.
<li> The remaining corners are sorted by the quality measure in the
descending order.
<li> Function throws away each corner for which there is a stronger corner
at a distance less than <code>maxDistance</code>.
</ul>
<p>The function can be used to initialize a point-based tracker of an object.</p>
<p>Note: If the function is called with different values <code>A</code> and
<code>B</code> of the parameter <code>qualityLevel</code>, and <code>A</code>
> {B}, the vector of returned corners with <code>qualityLevel=A</code> will
be the prefix of the output vector with <code>qualityLevel=B</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Input 8-bit or floating-point 32-bit, single-channel image.<DD><CODE>corners</CODE> - Output vector of detected corners.<DD><CODE>maxCorners</CODE> - Maximum number of corners to return. If there are more
corners than are found, the strongest of them is returned.<DD><CODE>qualityLevel</CODE> - Parameter characterizing the minimal accepted quality of
image corners. The parameter value is multiplied by the best corner quality
measure, which is the minimal eigenvalue (see "cornerMinEigenVal") or the
Harris function response (see "cornerHarris"). The corners with the quality
measure less than the product are rejected. For example, if the best corner
has the quality measure = 1500, and the <code>qualityLevel=0.01</code>, then
all the corners with the quality measure less than 15 are rejected.<DD><CODE>minDistance</CODE> - Minimum possible Euclidean distance between the returned
corners.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#goodfeaturestotrack">org.opencv.imgproc.Imgproc.goodFeaturesToTrack</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)"><CODE>cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)</CODE></A>,
<A HREF="../../../org/opencv/video/Video.html#estimateRigidTransform(org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Video.estimateRigidTransform(org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><CODE>cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)</CODE></A>,
<A HREF="../../../org/opencv/video/Video.html#calcOpticalFlowPyrLK(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfByte, org.opencv.core.MatOfFloat, org.opencv.core.Size, int, org.opencv.core.TermCriteria, int, double)"><CODE>Video.calcOpticalFlowPyrLK(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfByte, org.opencv.core.MatOfFloat, org.opencv.core.Size, int, org.opencv.core.TermCriteria, int, double)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="goodFeaturesToTrack(org.opencv.core.Mat, org.opencv.core.MatOfPoint, int, double, double, org.opencv.core.Mat, int, boolean, double)"><!-- --></A><H3>
goodFeaturesToTrack</H3>
<PRE>
public static void <B>goodFeaturesToTrack</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> corners,
int maxCorners,
double qualityLevel,
double minDistance,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
int blockSize,
boolean useHarrisDetector,
double k)</PRE>
<DL>
<DD><p>Determines strong corners on an image.</p>
<p>The function finds the most prominent corners in the image or in the
specified image region, as described in [Shi94]:</p>
<ul>
<li> Function calculates the corner quality measure at every source image
pixel using the "cornerMinEigenVal" or "cornerHarris".
<li> Function performs a non-maximum suppression (the local maximums in *3
x 3* neighborhood are retained).
<li> The corners with the minimal eigenvalue less than <em>qualityLevel *
max_(x,y) qualityMeasureMap(x,y)</em> are rejected.
<li> The remaining corners are sorted by the quality measure in the
descending order.
<li> Function throws away each corner for which there is a stronger corner
at a distance less than <code>maxDistance</code>.
</ul>
<p>The function can be used to initialize a point-based tracker of an object.</p>
<p>Note: If the function is called with different values <code>A</code> and
<code>B</code> of the parameter <code>qualityLevel</code>, and <code>A</code>
> {B}, the vector of returned corners with <code>qualityLevel=A</code> will
be the prefix of the output vector with <code>qualityLevel=B</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Input 8-bit or floating-point 32-bit, single-channel image.<DD><CODE>corners</CODE> - Output vector of detected corners.<DD><CODE>maxCorners</CODE> - Maximum number of corners to return. If there are more
corners than are found, the strongest of them is returned.<DD><CODE>qualityLevel</CODE> - Parameter characterizing the minimal accepted quality of
image corners. The parameter value is multiplied by the best corner quality
measure, which is the minimal eigenvalue (see "cornerMinEigenVal") or the
Harris function response (see "cornerHarris"). The corners with the quality
measure less than the product are rejected. For example, if the best corner
has the quality measure = 1500, and the <code>qualityLevel=0.01</code>, then
all the corners with the quality measure less than 15 are rejected.<DD><CODE>minDistance</CODE> - Minimum possible Euclidean distance between the returned
corners.<DD><CODE>mask</CODE> - Optional region of interest. If the image is not empty (it needs
to have the type <code>CV_8UC1</code> and the same size as <code>image</code>),
it specifies the region in which the corners are detected.<DD><CODE>blockSize</CODE> - Size of an average block for computing a derivative
covariation matrix over each pixel neighborhood. See "cornerEigenValsAndVecs".<DD><CODE>useHarrisDetector</CODE> - Parameter indicating whether to use a Harris
detector (see "cornerHarris") or "cornerMinEigenVal".<DD><CODE>k</CODE> - Free parameter of the Harris detector.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#goodfeaturestotrack">org.opencv.imgproc.Imgproc.goodFeaturesToTrack</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)"><CODE>cornerHarris(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, int)</CODE></A>,
<A HREF="../../../org/opencv/video/Video.html#estimateRigidTransform(org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Video.estimateRigidTransform(org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><CODE>cornerMinEigenVal(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)</CODE></A>,
<A HREF="../../../org/opencv/video/Video.html#calcOpticalFlowPyrLK(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfByte, org.opencv.core.MatOfFloat, org.opencv.core.Size, int, org.opencv.core.TermCriteria, int, double)"><CODE>Video.calcOpticalFlowPyrLK(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfByte, org.opencv.core.MatOfFloat, org.opencv.core.Size, int, org.opencv.core.TermCriteria, int, double)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="grabCut(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Rect, org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
grabCut</H3>
<PRE>
public static void <B>grabCut</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> img,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> rect,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> bgdModel,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> fgdModel,
int iterCount)</PRE>
<DL>
<DD><p>Runs the GrabCut algorithm.</p>
<p>The function implements the GrabCut image segmentation algorithm
(http://en.wikipedia.org/wiki/GrabCut).
See the sample <code>grabcut.cpp</code> to learn how to use the function.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>img</CODE> - Input 8-bit 3-channel image.<DD><CODE>mask</CODE> - Input/output 8-bit single-channel mask. The mask is initialized
by the function when <code>mode</code> is set to <code>GC_INIT_WITH_RECT</code>.
Its elements may have one of following values:
<ul>
<li> GC_BGD defines an obvious background pixels.
<li> GC_FGD defines an obvious foreground (object) pixel.
<li> GC_PR_BGD defines a possible background pixel.
<li> GC_PR_BGD defines a possible foreground pixel.
</ul><DD><CODE>rect</CODE> - ROI containing a segmented object. The pixels outside of the ROI
are marked as "obvious background". The parameter is only used when
<code>mode==GC_INIT_WITH_RECT</code>.<DD><CODE>bgdModel</CODE> - Temporary array for the background model. Do not modify it
while you are processing the same image.<DD><CODE>fgdModel</CODE> - Temporary arrays for the foreground model. Do not modify it
while you are processing the same image.<DD><CODE>iterCount</CODE> - Number of iterations the algorithm should make before
returning the result. Note that the result can be refined with further calls
with <code>mode==GC_INIT_WITH_MASK</code> or <code>mode==GC_EVAL</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#grabcut">org.opencv.imgproc.Imgproc.grabCut</a></DL>
</DD>
</DL>
<HR>
<A NAME="grabCut(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Rect, org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
grabCut</H3>
<PRE>
public static void <B>grabCut</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> img,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> mask,
<A HREF="../../../org/opencv/core/Rect.html" title="class in org.opencv.core">Rect</A> rect,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> bgdModel,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> fgdModel,
int iterCount,
int mode)</PRE>
<DL>
<DD><p>Runs the GrabCut algorithm.</p>
<p>The function implements the GrabCut image segmentation algorithm
(http://en.wikipedia.org/wiki/GrabCut).
See the sample <code>grabcut.cpp</code> to learn how to use the function.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>img</CODE> - Input 8-bit 3-channel image.<DD><CODE>mask</CODE> - Input/output 8-bit single-channel mask. The mask is initialized
by the function when <code>mode</code> is set to <code>GC_INIT_WITH_RECT</code>.
Its elements may have one of following values:
<ul>
<li> GC_BGD defines an obvious background pixels.
<li> GC_FGD defines an obvious foreground (object) pixel.
<li> GC_PR_BGD defines a possible background pixel.
<li> GC_PR_BGD defines a possible foreground pixel.
</ul><DD><CODE>rect</CODE> - ROI containing a segmented object. The pixels outside of the ROI
are marked as "obvious background". The parameter is only used when
<code>mode==GC_INIT_WITH_RECT</code>.<DD><CODE>bgdModel</CODE> - Temporary array for the background model. Do not modify it
while you are processing the same image.<DD><CODE>fgdModel</CODE> - Temporary arrays for the foreground model. Do not modify it
while you are processing the same image.<DD><CODE>iterCount</CODE> - Number of iterations the algorithm should make before
returning the result. Note that the result can be refined with further calls
with <code>mode==GC_INIT_WITH_MASK</code> or <code>mode==GC_EVAL</code>.<DD><CODE>mode</CODE> - Operation mode that could be one of the following:
<ul>
<li> GC_INIT_WITH_RECT The function initializes the state and the mask
using the provided rectangle. After that it runs <code>iterCount</code>
iterations of the algorithm.
<li> GC_INIT_WITH_MASK The function initializes the state using the
provided mask. Note that <code>GC_INIT_WITH_RECT</code> and <code>GC_INIT_WITH_MASK</code>
can be combined. Then, all the pixels outside of the ROI are automatically
initialized with <code>GC_BGD</code>.
<li> GC_EVAL The value means that the algorithm should just resume.
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#grabcut">org.opencv.imgproc.Imgproc.grabCut</a></DL>
</DD>
</DL>
<HR>
<A NAME="HoughCircles(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double)"><!-- --></A><H3>
HoughCircles</H3>
<PRE>
public static void <B>HoughCircles</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> circles,
int method,
double dp,
double minDist)</PRE>
<DL>
<DD><p>Finds circles in a grayscale image using the Hough transform.</p>
<p>The function finds circles in a grayscale image using a modification of the
Hough transform.
Example: <code></p>
<p>// C++ code:</p>
<p>#include <cv.h></p>
<p>#include <highgui.h></p>
<p>#include <math.h></p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat img, gray;</p>
<p>if(argc != 2 && !(img=imread(argv[1], 1)).data)</p>
<p>return -1;</p>
<p>cvtColor(img, gray, CV_BGR2GRAY);</p>
<p>// smooth it, otherwise a lot of false circles may be detected</p>
<p>GaussianBlur(gray, gray, Size(9, 9), 2, 2);</p>
<p>vector<Vec3f> circles;</p>
<p>HoughCircles(gray, circles, CV_HOUGH_GRADIENT,</p>
<p>2, gray->rows/4, 200, 100);</p>
<p>for(size_t i = 0; i < circles.size(); i++)</p>
<p>Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));</p>
<p>int radius = cvRound(circles[i][2]);</p>
<p>// draw the circle center</p>
<p>circle(img, center, 3, Scalar(0,255,0), -1, 8, 0);</p>
<p>// draw the circle outline</p>
<p>circle(img, center, radius, Scalar(0,0,255), 3, 8, 0);</p>
<p>namedWindow("circles", 1);</p>
<p>imshow("circles", img);</p>
<p>return 0;</p>
<p>Note: Usually the function detects the centers of circles well. However, it
may fail to find correct radii. You can assist to the function by specifying
the radius range (<code>minRadius</code> and <code>maxRadius</code>) if you
know it. Or, you may ignore the returned radius, use only the center, and
find the correct radius using an additional procedure.
</code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - 8-bit, single-channel, grayscale input image.<DD><CODE>circles</CODE> - Output vector of found circles. Each vector is encoded as a
3-element floating-point vector <em>(x, y, radius)</em>.<DD><CODE>method</CODE> - Detection method to use. Currently, the only implemented method
is <code>CV_HOUGH_GRADIENT</code>, which is basically *21HT*, described in
[Yuen90].<DD><CODE>dp</CODE> - Inverse ratio of the accumulator resolution to the image
resolution. For example, if <code>dp=1</code>, the accumulator has the same
resolution as the input image. If <code>dp=2</code>, the accumulator has half
as big width and height.<DD><CODE>minDist</CODE> - Minimum distance between the centers of the detected circles.
If the parameter is too small, multiple neighbor circles may be falsely
detected in addition to a true one. If it is too large, some circles may be
missed.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#houghcircles">org.opencv.imgproc.Imgproc.HoughCircles</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#minEnclosingCircle(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, float[])"><CODE>minEnclosingCircle(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, float[])</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#fitEllipse(org.opencv.core.MatOfPoint2f)"><CODE>fitEllipse(org.opencv.core.MatOfPoint2f)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="HoughCircles(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, double, double, int, int)"><!-- --></A><H3>
HoughCircles</H3>
<PRE>
public static void <B>HoughCircles</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> circles,
int method,
double dp,
double minDist,
double param1,
double param2,
int minRadius,
int maxRadius)</PRE>
<DL>
<DD><p>Finds circles in a grayscale image using the Hough transform.</p>
<p>The function finds circles in a grayscale image using a modification of the
Hough transform.
Example: <code></p>
<p>// C++ code:</p>
<p>#include <cv.h></p>
<p>#include <highgui.h></p>
<p>#include <math.h></p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat img, gray;</p>
<p>if(argc != 2 && !(img=imread(argv[1], 1)).data)</p>
<p>return -1;</p>
<p>cvtColor(img, gray, CV_BGR2GRAY);</p>
<p>// smooth it, otherwise a lot of false circles may be detected</p>
<p>GaussianBlur(gray, gray, Size(9, 9), 2, 2);</p>
<p>vector<Vec3f> circles;</p>
<p>HoughCircles(gray, circles, CV_HOUGH_GRADIENT,</p>
<p>2, gray->rows/4, 200, 100);</p>
<p>for(size_t i = 0; i < circles.size(); i++)</p>
<p>Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));</p>
<p>int radius = cvRound(circles[i][2]);</p>
<p>// draw the circle center</p>
<p>circle(img, center, 3, Scalar(0,255,0), -1, 8, 0);</p>
<p>// draw the circle outline</p>
<p>circle(img, center, radius, Scalar(0,0,255), 3, 8, 0);</p>
<p>namedWindow("circles", 1);</p>
<p>imshow("circles", img);</p>
<p>return 0;</p>
<p>Note: Usually the function detects the centers of circles well. However, it
may fail to find correct radii. You can assist to the function by specifying
the radius range (<code>minRadius</code> and <code>maxRadius</code>) if you
know it. Or, you may ignore the returned radius, use only the center, and
find the correct radius using an additional procedure.
</code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - 8-bit, single-channel, grayscale input image.<DD><CODE>circles</CODE> - Output vector of found circles. Each vector is encoded as a
3-element floating-point vector <em>(x, y, radius)</em>.<DD><CODE>method</CODE> - Detection method to use. Currently, the only implemented method
is <code>CV_HOUGH_GRADIENT</code>, which is basically *21HT*, described in
[Yuen90].<DD><CODE>dp</CODE> - Inverse ratio of the accumulator resolution to the image
resolution. For example, if <code>dp=1</code>, the accumulator has the same
resolution as the input image. If <code>dp=2</code>, the accumulator has half
as big width and height.<DD><CODE>minDist</CODE> - Minimum distance between the centers of the detected circles.
If the parameter is too small, multiple neighbor circles may be falsely
detected in addition to a true one. If it is too large, some circles may be
missed.<DD><CODE>param1</CODE> - First method-specific parameter. In case of <code>CV_HOUGH_GRADIENT</code>,
it is the higher threshold of the two passed to the "Canny" edge detector
(the lower one is twice smaller).<DD><CODE>param2</CODE> - Second method-specific parameter. In case of <code>CV_HOUGH_GRADIENT</code>,
it is the accumulator threshold for the circle centers at the detection
stage. The smaller it is, the more false circles may be detected. Circles,
corresponding to the larger accumulator values, will be returned first.<DD><CODE>minRadius</CODE> - Minimum circle radius.<DD><CODE>maxRadius</CODE> - Maximum circle radius.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#houghcircles">org.opencv.imgproc.Imgproc.HoughCircles</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#minEnclosingCircle(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, float[])"><CODE>minEnclosingCircle(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, float[])</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#fitEllipse(org.opencv.core.MatOfPoint2f)"><CODE>fitEllipse(org.opencv.core.MatOfPoint2f)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="HoughLines(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)"><!-- --></A><H3>
HoughLines</H3>
<PRE>
public static void <B>HoughLines</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold)</PRE>
<DL>
<DD><p>Finds lines in a binary image using the standard Hough transform.</p>
<p>The function implements the standard or standard multi-scale Hough transform
algorithm for line detection. See http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm
for a good explanation of Hough transform.
See also the example in "HoughLinesP" description.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - 8-bit, single-channel binary source image. The image may be
modified by the function.<DD><CODE>lines</CODE> - Output vector of lines. Each line is represented by a
two-element vector <em>(rho, theta)</em>. <em>rho</em> is the distance from
the coordinate origin <em>(0,0)</em> (top-left corner of the image).
<em>theta</em> is the line rotation angle in radians (<em>0 ~ vertical line,
pi/2 ~ horizontal line</em>).<DD><CODE>rho</CODE> - Distance resolution of the accumulator in pixels.<DD><CODE>theta</CODE> - Angle resolution of the accumulator in radians.<DD><CODE>threshold</CODE> - Accumulator threshold parameter. Only those lines are
returned that get enough votes (<em>>threshold</em>).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#houghlines">org.opencv.imgproc.Imgproc.HoughLines</a></DL>
</DD>
</DL>
<HR>
<A NAME="HoughLines(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, double, double)"><!-- --></A><H3>
HoughLines</H3>
<PRE>
public static void <B>HoughLines</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold,
double srn,
double stn)</PRE>
<DL>
<DD><p>Finds lines in a binary image using the standard Hough transform.</p>
<p>The function implements the standard or standard multi-scale Hough transform
algorithm for line detection. See http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm
for a good explanation of Hough transform.
See also the example in "HoughLinesP" description.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - 8-bit, single-channel binary source image. The image may be
modified by the function.<DD><CODE>lines</CODE> - Output vector of lines. Each line is represented by a
two-element vector <em>(rho, theta)</em>. <em>rho</em> is the distance from
the coordinate origin <em>(0,0)</em> (top-left corner of the image).
<em>theta</em> is the line rotation angle in radians (<em>0 ~ vertical line,
pi/2 ~ horizontal line</em>).<DD><CODE>rho</CODE> - Distance resolution of the accumulator in pixels.<DD><CODE>theta</CODE> - Angle resolution of the accumulator in radians.<DD><CODE>threshold</CODE> - Accumulator threshold parameter. Only those lines are
returned that get enough votes (<em>>threshold</em>).<DD><CODE>srn</CODE> - For the multi-scale Hough transform, it is a divisor for the
distance resolution <code>rho</code>. The coarse accumulator distance
resolution is <code>rho</code> and the accurate accumulator resolution is
<code>rho/srn</code>. If both <code>srn=0</code> and <code>stn=0</code>, the
classical Hough transform is used. Otherwise, both these parameters should be
positive.<DD><CODE>stn</CODE> - For the multi-scale Hough transform, it is a divisor for the
distance resolution <code>theta</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#houghlines">org.opencv.imgproc.Imgproc.HoughLines</a></DL>
</DD>
</DL>
<HR>
<A NAME="HoughLinesP(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)"><!-- --></A><H3>
HoughLinesP</H3>
<PRE>
public static void <B>HoughLinesP</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold)</PRE>
<DL>
<DD><p>Finds line segments in a binary image using the probabilistic Hough
transform.</p>
<p>The function implements the probabilistic Hough transform algorithm for line
detection, described in[Matas00]. See the line detection example below:
<code></p>
<p>// C++ code:</p>
<p>/ * This is a standalone program. Pass an image name as the first parameter</p>
<p>of the program. Switch between standard and probabilistic Hough transform</p>
<p>by changing "#if 1" to "#if 0" and back * /</p>
<p>#include <cv.h></p>
<p>#include <highgui.h></p>
<p>#include <math.h></p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src, dst, color_dst;</p>
<p>if(argc != 2 || !(src=imread(argv[1], 0)).data)</p>
<p>return -1;</p>
<p>Canny(src, dst, 50, 200, 3);</p>
<p>cvtColor(dst, color_dst, CV_GRAY2BGR);</p>
<p>#if 0</p>
<p>vector<Vec2f> lines;</p>
<p>HoughLines(dst, lines, 1, CV_PI/180, 100);</p>
<p>for(size_t i = 0; i < lines.size(); i++)</p>
<p>float rho = lines[i][0];</p>
<p>float theta = lines[i][1];</p>
<p>double a = cos(theta), b = sin(theta);</p>
<p>double x0 = a*rho, y0 = b*rho;</p>
<p>Point pt1(cvRound(x0 + 1000*(-b)),</p>
<p>cvRound(y0 + 1000*(a)));</p>
<p>Point pt2(cvRound(x0 - 1000*(-b)),</p>
<p>cvRound(y0 - 1000*(a)));</p>
<p>line(color_dst, pt1, pt2, Scalar(0,0,255), 3, 8);</p>
<p>#else</p>
<p>vector<Vec4i> lines;</p>
<p>HoughLinesP(dst, lines, 1, CV_PI/180, 80, 30, 10);</p>
<p>for(size_t i = 0; i < lines.size(); i++)</p>
<p>line(color_dst, Point(lines[i][0], lines[i][1]),</p>
<p>Point(lines[i][2], lines[i][3]), Scalar(0,0,255), 3, 8);</p>
<p>#endif</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>namedWindow("Detected Lines", 1);</p>
<p>imshow("Detected Lines", color_dst);</p>
<p>waitKey(0);</p>
<p>return 0;</p>
<p>This is a sample picture the function parameters have been tuned for: </code></p>
<p>And this is the output of the above program in case of the probabilistic
Hough transform:</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - 8-bit, single-channel binary source image. The image may be
modified by the function.<DD><CODE>lines</CODE> - Output vector of lines. Each line is represented by a 4-element
vector <em>(x_1, y_1, x_2, y_2)</em>, where <em>(x_1,y_1)</em> and <em>(x_2,
y_2)</em> are the ending points of each detected line segment.<DD><CODE>rho</CODE> - Distance resolution of the accumulator in pixels.<DD><CODE>theta</CODE> - Angle resolution of the accumulator in radians.<DD><CODE>threshold</CODE> - Accumulator threshold parameter. Only those lines are
returned that get enough votes (<em>>threshold</em>).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#houghlinesp">org.opencv.imgproc.Imgproc.HoughLinesP</a></DL>
</DD>
</DL>
<HR>
<A NAME="HoughLinesP(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, double, double)"><!-- --></A><H3>
HoughLinesP</H3>
<PRE>
public static void <B>HoughLinesP</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> lines,
double rho,
double theta,
int threshold,
double minLineLength,
double maxLineGap)</PRE>
<DL>
<DD><p>Finds line segments in a binary image using the probabilistic Hough
transform.</p>
<p>The function implements the probabilistic Hough transform algorithm for line
detection, described in[Matas00]. See the line detection example below:
<code></p>
<p>// C++ code:</p>
<p>/ * This is a standalone program. Pass an image name as the first parameter</p>
<p>of the program. Switch between standard and probabilistic Hough transform</p>
<p>by changing "#if 1" to "#if 0" and back * /</p>
<p>#include <cv.h></p>
<p>#include <highgui.h></p>
<p>#include <math.h></p>
<p>using namespace cv;</p>
<p>int main(int argc, char argv)</p>
<p>Mat src, dst, color_dst;</p>
<p>if(argc != 2 || !(src=imread(argv[1], 0)).data)</p>
<p>return -1;</p>
<p>Canny(src, dst, 50, 200, 3);</p>
<p>cvtColor(dst, color_dst, CV_GRAY2BGR);</p>
<p>#if 0</p>
<p>vector<Vec2f> lines;</p>
<p>HoughLines(dst, lines, 1, CV_PI/180, 100);</p>
<p>for(size_t i = 0; i < lines.size(); i++)</p>
<p>float rho = lines[i][0];</p>
<p>float theta = lines[i][1];</p>
<p>double a = cos(theta), b = sin(theta);</p>
<p>double x0 = a*rho, y0 = b*rho;</p>
<p>Point pt1(cvRound(x0 + 1000*(-b)),</p>
<p>cvRound(y0 + 1000*(a)));</p>
<p>Point pt2(cvRound(x0 - 1000*(-b)),</p>
<p>cvRound(y0 - 1000*(a)));</p>
<p>line(color_dst, pt1, pt2, Scalar(0,0,255), 3, 8);</p>
<p>#else</p>
<p>vector<Vec4i> lines;</p>
<p>HoughLinesP(dst, lines, 1, CV_PI/180, 80, 30, 10);</p>
<p>for(size_t i = 0; i < lines.size(); i++)</p>
<p>line(color_dst, Point(lines[i][0], lines[i][1]),</p>
<p>Point(lines[i][2], lines[i][3]), Scalar(0,0,255), 3, 8);</p>
<p>#endif</p>
<p>namedWindow("Source", 1);</p>
<p>imshow("Source", src);</p>
<p>namedWindow("Detected Lines", 1);</p>
<p>imshow("Detected Lines", color_dst);</p>
<p>waitKey(0);</p>
<p>return 0;</p>
<p>This is a sample picture the function parameters have been tuned for: </code></p>
<p>And this is the output of the above program in case of the probabilistic
Hough transform:</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - 8-bit, single-channel binary source image. The image may be
modified by the function.<DD><CODE>lines</CODE> - Output vector of lines. Each line is represented by a 4-element
vector <em>(x_1, y_1, x_2, y_2)</em>, where <em>(x_1,y_1)</em> and <em>(x_2,
y_2)</em> are the ending points of each detected line segment.<DD><CODE>rho</CODE> - Distance resolution of the accumulator in pixels.<DD><CODE>theta</CODE> - Angle resolution of the accumulator in radians.<DD><CODE>threshold</CODE> - Accumulator threshold parameter. Only those lines are
returned that get enough votes (<em>>threshold</em>).<DD><CODE>minLineLength</CODE> - Minimum line length. Line segments shorter than that are
rejected.<DD><CODE>maxLineGap</CODE> - Maximum allowed gap between points on the same line to link
them.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#houghlinesp">org.opencv.imgproc.Imgproc.HoughLinesP</a></DL>
</DD>
</DL>
<HR>
<A NAME="HuMoments(org.opencv.imgproc.Moments, org.opencv.core.Mat)"><!-- --></A><H3>
HuMoments</H3>
<PRE>
public static void <B>HuMoments</B>(<A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc">Moments</A> m,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> hu)</PRE>
<DL>
<DD><p>Calculates seven Hu invariants.</p>
<p>The function calculates seven Hu invariants (introduced in [Hu62]; see also
http://en.wikipedia.org/wiki/Image_moment) defined as:</p>
<p><em>hu[0]= eta _20+ eta _02
hu[1]=(eta _20- eta _02)^2+4 eta _11^2
hu[2]=(eta _30-3 eta _12)^2+ (3 eta _21- eta _03)^2
hu[3]=(eta _30+ eta _12)^2+ (eta _21+ eta _03)^2
hu[4]=(eta _30-3 eta _12)(eta _30+ eta _12)[(eta _30+ eta _12)^2-3(eta _21+
eta _03)^2]+(3 eta _21- eta _03)(eta _21+ eta _03)[3(eta _30+ eta _12)^2-(eta
_21+ eta _03)^2]
hu[5]=(eta _20- eta _02)[(eta _30+ eta _12)^2- (eta _21+ eta _03)^2]+4 eta
_11(eta _30+ eta _12)(eta _21+ eta _03)
hu[6]=(3 eta _21- eta _03)(eta _21+ eta _03)[3(eta _30+ eta _12)^2-(eta _21+
eta _03)^2]-(eta _30-3 eta _12)(eta _21+ eta _03)[3(eta _30+ eta _12)^2-(eta
_21+ eta _03)^2]
</em></p>
<p>where <em>eta_(ji)</em> stands for <em>Moments.nu_(ji)</em>.</p>
<p>These values are proved to be invariants to the image scale, rotation, and
reflection except the seventh one, whose sign is changed by reflection. This
invariance is proved with the assumption of infinite image resolution. In
case of raster images, the computed Hu invariants for the original and
transformed images are a bit different.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>m</CODE> - a m<DD><CODE>hu</CODE> - Output Hu invariants.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#humoments">org.opencv.imgproc.Imgproc.HuMoments</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#matchShapes(org.opencv.core.Mat, org.opencv.core.Mat, int, double)"><CODE>matchShapes(org.opencv.core.Mat, org.opencv.core.Mat, int, double)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="initUndistortRectifyMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
initUndistortRectifyMap</H3>
<PRE>
public static void <B>initUndistortRectifyMap</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> R,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> newCameraMatrix,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> size,
int m1type,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2)</PRE>
<DL>
<DD><p>Computes the undistortion and rectification transformation map.</p>
<p>The function computes the joint undistortion and rectification transformation
and represents the result in the form of maps for "remap". The undistorted
image looks like original, as if it is captured with a camera using the
camera matrix <code>=newCameraMatrix</code> and zero distortion. In case of a
monocular camera, <code>newCameraMatrix</code> is usually equal to
<code>cameraMatrix</code>, or it can be computed by "getOptimalNewCameraMatrix"
for a better control over scaling. In case of a stereo camera,
<code>newCameraMatrix</code> is normally set to <code>P1</code> or
<code>P2</code> computed by "stereoRectify".</p>
<p>Also, this new camera is oriented differently in the coordinate space,
according to <code>R</code>. That, for example, helps to align two heads of a
stereo camera so that the epipolar lines on both images become horizontal and
have the same y- coordinate (in case of a horizontally aligned stereo
camera).</p>
<p>The function actually builds the maps for the inverse mapping algorithm that
is used by "remap". That is, for each pixel <em>(u, v)</em> in the
destination (corrected and rectified) image, the function computes the
corresponding coordinates in the source image (that is, in the original image
from camera). The following process is applied:</p>
<p><em>x <- (u - (c')_x)/(f')_x
y <- (v - (c')_y)/(f')_y
([X Y W]) ^T <- R^(-1)*[x y 1]^T
x' <- X/W
y' <- Y/W
x" <- x' (1 + k_1 r^2 + k_2 r^4 + k_3 r^6) + 2p_1 x' y' + p_2(r^2 + 2 x'^2)
y" <- y' (1 + k_1 r^2 + k_2 r^4 + k_3 r^6) + p_1(r^2 + 2 y'^2) + 2 p_2 x' y'
map_x(u,v) <- x" f_x + c_x
map_y(u,v) <- y" f_y + c_y </em></p>
<p>where <em>(k_1, k_2, p_1, p_2[, k_3])</em> are the distortion coefficients.</p>
<p>In case of a stereo camera, this function is called twice: once for each
camera head, after "stereoRectify", which in its turn is called after
"stereoCalibrate". But if the stereo camera was not calibrated, it is still
possible to compute the rectification transformations directly from the
fundamental matrix using "stereoRectifyUncalibrated". For each camera, the
function computes homography <code>H</code> as the rectification
transformation in a pixel domain, not a rotation matrix <code>R</code> in 3D
space. <code>R</code> can be computed from <code>H</code> as</p>
<p><em>R = cameraMatrix ^(-1) * H * cameraMatrix</em></p>
<p>where <code>cameraMatrix</code> can be chosen arbitrarily.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>cameraMatrix</CODE> - Input camera matrix <em>A=
<p>|f_x 0 c_x|
|0 f_y c_y|
|0 0 1|
</em>.</p><DD><CODE>distCoeffs</CODE> - Input vector of distortion coefficients <em>(k_1, k_2, p_1,
p_2[, k_3[, k_4, k_5, k_6]])</em> of 4, 5, or 8 elements. If the vector is
NULL/empty, the zero distortion coefficients are assumed.<DD><CODE>R</CODE> - Optional rectification transformation in the object space (3x3
matrix). <code>R1</code> or <code>R2</code>, computed by "stereoRectify" can
be passed here. If the matrix is empty, the identity transformation is
assumed. In <code>cvInitUndistortMap</code> R assumed to be an identity
matrix.<DD><CODE>newCameraMatrix</CODE> - New camera matrix <em>A'=
<p>|f_x' 0 c_x'|
|0 f_y' c_y'|
|0 0 1|
</em>.</p><DD><CODE>size</CODE> - Undistorted image size.<DD><CODE>m1type</CODE> - Type of the first output map that can be <code>CV_32FC1</code>
or <code>CV_16SC2</code>. See "convertMaps" for details.<DD><CODE>map1</CODE> - The first output map.<DD><CODE>map2</CODE> - The second output map.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#initundistortrectifymap">org.opencv.imgproc.Imgproc.initUndistortRectifyMap</a></DL>
</DD>
</DL>
<HR>
<A NAME="initWideAngleProjMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
initWideAngleProjMap</H3>
<PRE>
public static float <B>initWideAngleProjMap</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> imageSize,
int destImageWidth,
int m1type,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="initWideAngleProjMap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Mat, org.opencv.core.Mat, int, double)"><!-- --></A><H3>
initWideAngleProjMap</H3>
<PRE>
public static float <B>initWideAngleProjMap</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> imageSize,
int destImageWidth,
int m1type,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
int projType,
double alpha)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="integral(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
integral</H3>
<PRE>
public static void <B>integral</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum)</PRE>
<DL>
<DD><p>Calculates the integral of an image.</p>
<p>The functions calculate one or more integral images for the source image as
follows:</p>
<p><em>sum(X,Y) = sum(by: x<X,y<Y) image(x,y)</em></p>
<p><em>sqsum(X,Y) = sum(by: x<X,y<Y) image(x,y)^2</em></p>
<p><em>tilted(X,Y) = sum(by: y<Y,abs(x-X+1) <= Y-y-1) image(x,y)</em></p>
<p>Using these integral images, you can calculate sa um, mean, and standard
deviation over a specific up-right or rotated rectangular region of the image
in a constant time, for example:</p>
<p><em>sum(by: x_1 <= x < x_2, y_1 <= y < y_2) image(x,y) = sum(x_2,y_2)-
sum(x_1,y_2)- sum(x_2,y_1)+ sum(x_1,y_1)</em></p>
<p>It makes possible to do a fast blurring or fast block correlation with a
variable window size, for example. In case of multi-channel images, sums for
each channel are accumulated independently.</p>
<p>As a practical example, the next figure shows the calculation of the integral
of a straight rectangle <code>Rect(3,3,3,2)</code> and of a tilted rectangle
<code>Rect(5,1,2,3)</code>. The selected pixels in the original
<code>image</code> are shown, as well as the relative pixels in the integral
images <code>sum</code> and <code>tilted</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - a src<DD><CODE>sum</CODE> - integral image as <em>(W+1)x(H+1)</em>, 32-bit integer or
floating-point (32f or 64f).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral">org.opencv.imgproc.Imgproc.integral</a></DL>
</DD>
</DL>
<HR>
<A NAME="integral(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
integral</H3>
<PRE>
public static void <B>integral</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
int sdepth)</PRE>
<DL>
<DD><p>Calculates the integral of an image.</p>
<p>The functions calculate one or more integral images for the source image as
follows:</p>
<p><em>sum(X,Y) = sum(by: x<X,y<Y) image(x,y)</em></p>
<p><em>sqsum(X,Y) = sum(by: x<X,y<Y) image(x,y)^2</em></p>
<p><em>tilted(X,Y) = sum(by: y<Y,abs(x-X+1) <= Y-y-1) image(x,y)</em></p>
<p>Using these integral images, you can calculate sa um, mean, and standard
deviation over a specific up-right or rotated rectangular region of the image
in a constant time, for example:</p>
<p><em>sum(by: x_1 <= x < x_2, y_1 <= y < y_2) image(x,y) = sum(x_2,y_2)-
sum(x_1,y_2)- sum(x_2,y_1)+ sum(x_1,y_1)</em></p>
<p>It makes possible to do a fast blurring or fast block correlation with a
variable window size, for example. In case of multi-channel images, sums for
each channel are accumulated independently.</p>
<p>As a practical example, the next figure shows the calculation of the integral
of a straight rectangle <code>Rect(3,3,3,2)</code> and of a tilted rectangle
<code>Rect(5,1,2,3)</code>. The selected pixels in the original
<code>image</code> are shown, as well as the relative pixels in the integral
images <code>sum</code> and <code>tilted</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - a src<DD><CODE>sum</CODE> - integral image as <em>(W+1)x(H+1)</em>, 32-bit integer or
floating-point (32f or 64f).<DD><CODE>sdepth</CODE> - desired depth of the integral and the tilted integral images,
<code>CV_32S</code>, <code>CV_32F</code>, or <code>CV_64F</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral">org.opencv.imgproc.Imgproc.integral</a></DL>
</DD>
</DL>
<HR>
<A NAME="integral2(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
integral2</H3>
<PRE>
public static void <B>integral2</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum)</PRE>
<DL>
<DD><p>Calculates the integral of an image.</p>
<p>The functions calculate one or more integral images for the source image as
follows:</p>
<p><em>sum(X,Y) = sum(by: x<X,y<Y) image(x,y)</em></p>
<p><em>sqsum(X,Y) = sum(by: x<X,y<Y) image(x,y)^2</em></p>
<p><em>tilted(X,Y) = sum(by: y<Y,abs(x-X+1) <= Y-y-1) image(x,y)</em></p>
<p>Using these integral images, you can calculate sa um, mean, and standard
deviation over a specific up-right or rotated rectangular region of the image
in a constant time, for example:</p>
<p><em>sum(by: x_1 <= x < x_2, y_1 <= y < y_2) image(x,y) = sum(x_2,y_2)-
sum(x_1,y_2)- sum(x_2,y_1)+ sum(x_1,y_1)</em></p>
<p>It makes possible to do a fast blurring or fast block correlation with a
variable window size, for example. In case of multi-channel images, sums for
each channel are accumulated independently.</p>
<p>As a practical example, the next figure shows the calculation of the integral
of a straight rectangle <code>Rect(3,3,3,2)</code> and of a tilted rectangle
<code>Rect(5,1,2,3)</code>. The selected pixels in the original
<code>image</code> are shown, as well as the relative pixels in the integral
images <code>sum</code> and <code>tilted</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - a src<DD><CODE>sum</CODE> - integral image as <em>(W+1)x(H+1)</em>, 32-bit integer or
floating-point (32f or 64f).<DD><CODE>sqsum</CODE> - integral image for squared pixel values; it is <em>(W+1)x(H+1)</em>,
double-precision floating-point (64f) array.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral">org.opencv.imgproc.Imgproc.integral</a></DL>
</DD>
</DL>
<HR>
<A NAME="integral2(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
integral2</H3>
<PRE>
public static void <B>integral2</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum,
int sdepth)</PRE>
<DL>
<DD><p>Calculates the integral of an image.</p>
<p>The functions calculate one or more integral images for the source image as
follows:</p>
<p><em>sum(X,Y) = sum(by: x<X,y<Y) image(x,y)</em></p>
<p><em>sqsum(X,Y) = sum(by: x<X,y<Y) image(x,y)^2</em></p>
<p><em>tilted(X,Y) = sum(by: y<Y,abs(x-X+1) <= Y-y-1) image(x,y)</em></p>
<p>Using these integral images, you can calculate sa um, mean, and standard
deviation over a specific up-right or rotated rectangular region of the image
in a constant time, for example:</p>
<p><em>sum(by: x_1 <= x < x_2, y_1 <= y < y_2) image(x,y) = sum(x_2,y_2)-
sum(x_1,y_2)- sum(x_2,y_1)+ sum(x_1,y_1)</em></p>
<p>It makes possible to do a fast blurring or fast block correlation with a
variable window size, for example. In case of multi-channel images, sums for
each channel are accumulated independently.</p>
<p>As a practical example, the next figure shows the calculation of the integral
of a straight rectangle <code>Rect(3,3,3,2)</code> and of a tilted rectangle
<code>Rect(5,1,2,3)</code>. The selected pixels in the original
<code>image</code> are shown, as well as the relative pixels in the integral
images <code>sum</code> and <code>tilted</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - a src<DD><CODE>sum</CODE> - integral image as <em>(W+1)x(H+1)</em>, 32-bit integer or
floating-point (32f or 64f).<DD><CODE>sqsum</CODE> - integral image for squared pixel values; it is <em>(W+1)x(H+1)</em>,
double-precision floating-point (64f) array.<DD><CODE>sdepth</CODE> - desired depth of the integral and the tilted integral images,
<code>CV_32S</code>, <code>CV_32F</code>, or <code>CV_64F</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral">org.opencv.imgproc.Imgproc.integral</a></DL>
</DD>
</DL>
<HR>
<A NAME="integral3(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
integral3</H3>
<PRE>
public static void <B>integral3</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> tilted)</PRE>
<DL>
<DD><p>Calculates the integral of an image.</p>
<p>The functions calculate one or more integral images for the source image as
follows:</p>
<p><em>sum(X,Y) = sum(by: x<X,y<Y) image(x,y)</em></p>
<p><em>sqsum(X,Y) = sum(by: x<X,y<Y) image(x,y)^2</em></p>
<p><em>tilted(X,Y) = sum(by: y<Y,abs(x-X+1) <= Y-y-1) image(x,y)</em></p>
<p>Using these integral images, you can calculate sa um, mean, and standard
deviation over a specific up-right or rotated rectangular region of the image
in a constant time, for example:</p>
<p><em>sum(by: x_1 <= x < x_2, y_1 <= y < y_2) image(x,y) = sum(x_2,y_2)-
sum(x_1,y_2)- sum(x_2,y_1)+ sum(x_1,y_1)</em></p>
<p>It makes possible to do a fast blurring or fast block correlation with a
variable window size, for example. In case of multi-channel images, sums for
each channel are accumulated independently.</p>
<p>As a practical example, the next figure shows the calculation of the integral
of a straight rectangle <code>Rect(3,3,3,2)</code> and of a tilted rectangle
<code>Rect(5,1,2,3)</code>. The selected pixels in the original
<code>image</code> are shown, as well as the relative pixels in the integral
images <code>sum</code> and <code>tilted</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - a src<DD><CODE>sum</CODE> - integral image as <em>(W+1)x(H+1)</em>, 32-bit integer or
floating-point (32f or 64f).<DD><CODE>sqsum</CODE> - integral image for squared pixel values; it is <em>(W+1)x(H+1)</em>,
double-precision floating-point (64f) array.<DD><CODE>tilted</CODE> - integral for the image rotated by 45 degrees; it is
<em>(W+1)x(H+1)</em> array with the same data type as <code>sum</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral">org.opencv.imgproc.Imgproc.integral</a></DL>
</DD>
</DL>
<HR>
<A NAME="integral3(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
integral3</H3>
<PRE>
public static void <B>integral3</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> sqsum,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> tilted,
int sdepth)</PRE>
<DL>
<DD><p>Calculates the integral of an image.</p>
<p>The functions calculate one or more integral images for the source image as
follows:</p>
<p><em>sum(X,Y) = sum(by: x<X,y<Y) image(x,y)</em></p>
<p><em>sqsum(X,Y) = sum(by: x<X,y<Y) image(x,y)^2</em></p>
<p><em>tilted(X,Y) = sum(by: y<Y,abs(x-X+1) <= Y-y-1) image(x,y)</em></p>
<p>Using these integral images, you can calculate sa um, mean, and standard
deviation over a specific up-right or rotated rectangular region of the image
in a constant time, for example:</p>
<p><em>sum(by: x_1 <= x < x_2, y_1 <= y < y_2) image(x,y) = sum(x_2,y_2)-
sum(x_1,y_2)- sum(x_2,y_1)+ sum(x_1,y_1)</em></p>
<p>It makes possible to do a fast blurring or fast block correlation with a
variable window size, for example. In case of multi-channel images, sums for
each channel are accumulated independently.</p>
<p>As a practical example, the next figure shows the calculation of the integral
of a straight rectangle <code>Rect(3,3,3,2)</code> and of a tilted rectangle
<code>Rect(5,1,2,3)</code>. The selected pixels in the original
<code>image</code> are shown, as well as the relative pixels in the integral
images <code>sum</code> and <code>tilted</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - a src<DD><CODE>sum</CODE> - integral image as <em>(W+1)x(H+1)</em>, 32-bit integer or
floating-point (32f or 64f).<DD><CODE>sqsum</CODE> - integral image for squared pixel values; it is <em>(W+1)x(H+1)</em>,
double-precision floating-point (64f) array.<DD><CODE>tilted</CODE> - integral for the image rotated by 45 degrees; it is
<em>(W+1)x(H+1)</em> array with the same data type as <code>sum</code>.<DD><CODE>sdepth</CODE> - desired depth of the integral and the tilted integral images,
<code>CV_32S</code>, <code>CV_32F</code>, or <code>CV_64F</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#integral">org.opencv.imgproc.Imgproc.integral</a></DL>
</DD>
</DL>
<HR>
<A NAME="intersectConvexConvex(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
intersectConvexConvex</H3>
<PRE>
public static float <B>intersectConvexConvex</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p12)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="intersectConvexConvex(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><!-- --></A><H3>
intersectConvexConvex</H3>
<PRE>
public static float <B>intersectConvexConvex</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> _p12,
boolean handleNested)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="invertAffineTransform(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
invertAffineTransform</H3>
<PRE>
public static void <B>invertAffineTransform</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> iM)</PRE>
<DL>
<DD><p>Inverts an affine transformation.</p>
<p>The function computes an inverse affine transformation represented by <em>2 x
3</em> matrix <code>M</code> :</p>
<p><em>a_11 a_12 b_1
a_21 a_22 b_2 </em></p>
<p>The result is also a <em>2 x 3</em> matrix of the same type as
<code>M</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>M</CODE> - Original affine transformation.<DD><CODE>iM</CODE> - Output reverse affine transformation.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#invertaffinetransform">org.opencv.imgproc.Imgproc.invertAffineTransform</a></DL>
</DD>
</DL>
<HR>
<A NAME="isContourConvex(org.opencv.core.MatOfPoint)"><!-- --></A><H3>
isContourConvex</H3>
<PRE>
public static boolean <B>isContourConvex</B>(<A HREF="../../../org/opencv/core/MatOfPoint.html" title="class in org.opencv.core">MatOfPoint</A> contour)</PRE>
<DL>
<DD><p>Tests a contour convexity.</p>
<p>The function tests whether the input contour is convex or not. The contour
must be simple, that is, without self-intersections. Otherwise, the function
output is undefined.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>contour</CODE> - Input vector of 2D points, stored in:
<ul>
<li> <code>std.vector<></code> or <code>Mat</code> (C++ interface)
<li> <code>CvSeq*</code> or <code>CvMat*</code> (C interface)
<li> Nx2 numpy array (Python interface)
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#iscontourconvex">org.opencv.imgproc.Imgproc.isContourConvex</a></DL>
</DD>
</DL>
<HR>
<A NAME="Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
Laplacian</H3>
<PRE>
public static void <B>Laplacian</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth)</PRE>
<DL>
<DD><p>Calculates the Laplacian of an image.</p>
<p>The function calculates the Laplacian of the source image by adding up the
second x and y derivatives calculated using the Sobel operator:</p>
<p><em>dst = Delta src = (d^2 src)/(dx^2) + (d^2 src)/(dy^2)</em></p>
<p>This is done when <code>ksize > 1</code>. When <code>ksize == 1</code>, the
Laplacian is computed by filtering the image with the following <em>3 x
3</em> aperture:</p>
<p><em>vecthreethree 0101(-4)1010</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same size and the same number of channels
as <code>src</code>.<DD><CODE>ddepth</CODE> - Desired depth of the destination image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#laplacian">org.opencv.imgproc.Imgproc.Laplacian</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><CODE>Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><CODE>Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double)"><!-- --></A><H3>
Laplacian</H3>
<PRE>
public static void <B>Laplacian</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int ksize,
double scale,
double delta)</PRE>
<DL>
<DD><p>Calculates the Laplacian of an image.</p>
<p>The function calculates the Laplacian of the source image by adding up the
second x and y derivatives calculated using the Sobel operator:</p>
<p><em>dst = Delta src = (d^2 src)/(dx^2) + (d^2 src)/(dy^2)</em></p>
<p>This is done when <code>ksize > 1</code>. When <code>ksize == 1</code>, the
Laplacian is computed by filtering the image with the following <em>3 x
3</em> aperture:</p>
<p><em>vecthreethree 0101(-4)1010</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same size and the same number of channels
as <code>src</code>.<DD><CODE>ddepth</CODE> - Desired depth of the destination image.<DD><CODE>ksize</CODE> - Aperture size used to compute the second-derivative filters. See
"getDerivKernels" for details. The size must be positive and odd.<DD><CODE>scale</CODE> - Optional scale factor for the computed Laplacian values. By
default, no scaling is applied. See "getDerivKernels" for details.<DD><CODE>delta</CODE> - Optional delta value that is added to the results prior to
storing them in <code>dst</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#laplacian">org.opencv.imgproc.Imgproc.Laplacian</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><CODE>Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><CODE>Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)"><!-- --></A><H3>
Laplacian</H3>
<PRE>
public static void <B>Laplacian</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int ksize,
double scale,
double delta,
int borderType)</PRE>
<DL>
<DD><p>Calculates the Laplacian of an image.</p>
<p>The function calculates the Laplacian of the source image by adding up the
second x and y derivatives calculated using the Sobel operator:</p>
<p><em>dst = Delta src = (d^2 src)/(dx^2) + (d^2 src)/(dy^2)</em></p>
<p>This is done when <code>ksize > 1</code>. When <code>ksize == 1</code>, the
Laplacian is computed by filtering the image with the following <em>3 x
3</em> aperture:</p>
<p><em>vecthreethree 0101(-4)1010</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same size and the same number of channels
as <code>src</code>.<DD><CODE>ddepth</CODE> - Desired depth of the destination image.<DD><CODE>ksize</CODE> - Aperture size used to compute the second-derivative filters. See
"getDerivKernels" for details. The size must be positive and odd.<DD><CODE>scale</CODE> - Optional scale factor for the computed Laplacian values. By
default, no scaling is applied. See "getDerivKernels" for details.<DD><CODE>delta</CODE> - Optional delta value that is added to the results prior to
storing them in <code>dst</code>.<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate" for
details.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#laplacian">org.opencv.imgproc.Imgproc.Laplacian</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><CODE>Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><CODE>Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="matchShapes(org.opencv.core.Mat, org.opencv.core.Mat, int, double)"><!-- --></A><H3>
matchShapes</H3>
<PRE>
public static double <B>matchShapes</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> contour2,
int method,
double parameter)</PRE>
<DL>
<DD><p>Compares two shapes.</p>
<p>The function compares two shapes. All three implemented methods use the Hu
invariants (see "HuMoments") as follows (<em>A</em> denotes <code>object1</code>,<em>B</em>
denotes <code>object2</code>):</p>
<ul>
<li> method=CV_CONTOURS_MATCH_I1
</ul>
<p><em>I_1(A,B) = sum(by: i=1...7) <= ft|1/(m^A_i) - 1/(m^B_i) right|</em></p>
<ul>
<li> method=CV_CONTOURS_MATCH_I2
</ul>
<p><em>I_2(A,B) = sum(by: i=1...7) <= ft|m^A_i - m^B_i right|</em></p>
<ul>
<li> method=CV_CONTOURS_MATCH_I3
</ul>
<p><em>I_3(A,B) = max _(i=1...7)(<= ft| m^A_i - m^B_i right|)/(<= ft| m^A_i
right|)</em></p>
<p>where</p>
<p><em>m^A_i = sign(h^A_i) * log(h^A_i)
m^B_i = sign(h^B_i) * log(h^B_i) </em></p>
<p>and <em>h^A_i, h^B_i</em> are the Hu moments of <em>A</em> and <em>B</em>,
respectively.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>contour1</CODE> - a contour1<DD><CODE>contour2</CODE> - a contour2<DD><CODE>method</CODE> - Comparison method: <code>CV_CONTOURS_MATCH_I1</code>,
<code>CV_CONTOURS_MATCH_I2</code> \
<p>or <code>CV_CONTOURS_MATCH_I3</code> (see the details below).</p><DD><CODE>parameter</CODE> - Method-specific parameter (not supported now).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#matchshapes">org.opencv.imgproc.Imgproc.matchShapes</a></DL>
</DD>
</DL>
<HR>
<A NAME="matchTemplate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
matchTemplate</H3>
<PRE>
public static void <B>matchTemplate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> templ,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> result,
int method)</PRE>
<DL>
<DD><p>Compares a template against overlapped image regions.</p>
<p>The function slides through <code>image</code>, compares the overlapped
patches of size <em>w x h</em> against <code>templ</code> using the specified
method and stores the comparison results in <code>result</code>. Here are the
formulae for the available comparison methods (<em>I</em> denotes
<code>image</code>, <em>T</em> <code>template</code>, <em>R</em>
<code>result</code>). The summation is done over template and/or the image
patch: <em>x' = 0...w-1, y' = 0...h-1</em></p>
<ul>
<li> method=CV_TM_SQDIFF
</ul>
<p><em>R(x,y)= sum(by: x',y')(T(x',y')-I(x+x',y+y'))^2</em></p>
<ul>
<li> method=CV_TM_SQDIFF_NORMED
</ul>
<p><em>R(x,y)= (sum_(x',y')(T(x',y')-I(x+x',y+y'))^2)/(sqrt(sum_(x',y')T(x',y')^2
* sum_(x',y') I(x+x',y+y')^2))</em></p>
<ul>
<li> method=CV_TM_CCORR
</ul>
<p><em>R(x,y)= sum(by: x',y')(T(x',y') * I(x+x',y+y'))</em></p>
<ul>
<li> method=CV_TM_CCORR_NORMED
</ul>
<p><em>R(x,y)= (sum_(x',y')(T(x',y') * I(x+x',y+y')))/(sqrt(sum_(x',y')T(x',y')^2
* sum_(x',y') I(x+x',y+y')^2))</em></p>
<ul>
<li> method=CV_TM_CCOEFF
</ul>
<p><em>R(x,y)= sum(by: x',y')(T'(x',y') * I'(x+x',y+y'))</em></p>
<p>where</p>
<p><em>T'(x',y')=T(x',y') - 1/(w * h) * sum(by: x'',y'') T(x'',y'')
I'(x+x',y+y')=I(x+x',y+y') - 1/(w * h) * sum(by: x'',y'') I(x+x'',y+y'')
</em></p>
<ul>
<li> method=CV_TM_CCOEFF_NORMED
</ul>
<p><em>R(x,y)= (sum_(x',y')(T'(x',y') * I'(x+x',y+y')))/(sqrt(sum_(x',y')T'(x',y')^2
* sum_(x',y') I'(x+x',y+y')^2))</em></p>
<p>After the function finishes the comparison, the best matches can be found as
global minimums (when <code>CV_TM_SQDIFF</code> was used) or maximums (when
<code>CV_TM_CCORR</code> or <code>CV_TM_CCOEFF</code> was used) using the
"minMaxLoc" function. In case of a color image, template summation in the
numerator and each sum in the denominator is done over all of the channels
and separate mean values are used for each channel. That is, the function can
take a color template and a color image. The result will still be a
single-channel image, which is easier to analyze.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Image where the search is running. It must be 8-bit or 32-bit
floating-point.<DD><CODE>templ</CODE> - Searched template. It must be not greater than the source image
and have the same data type.<DD><CODE>result</CODE> - Map of comparison results. It must be single-channel 32-bit
floating-point. If <code>image</code> is <em>W x H</em> and <code>templ</code>
is <em>w x h</em>, then <code>result</code> is <em>(W-w+1) x(H-h+1)</em>.<DD><CODE>method</CODE> - Parameter specifying the comparison method (see below).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/object_detection.html#matchtemplate">org.opencv.imgproc.Imgproc.matchTemplate</a></DL>
</DD>
</DL>
<HR>
<A NAME="medianBlur(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
medianBlur</H3>
<PRE>
public static void <B>medianBlur</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ksize)</PRE>
<DL>
<DD><p>Blurs an image using the median filter.</p>
<p>The function smoothes an image using the median filter with the <em>ksize x
ksize</em> aperture. Each channel of a multi-channel image is processed
independently. In-place operation is supported.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input 1-, 3-, or 4-channel image; when <code>ksize</code> is 3 or
5, the image depth should be <code>CV_8U</code>, <code>CV_16U</code>, or
<code>CV_32F</code>, for larger aperture sizes, it can only be
<code>CV_8U</code>.<DD><CODE>dst</CODE> - destination array of the same size and type as <code>src</code>.<DD><CODE>ksize</CODE> - aperture linear size; it must be odd and greater than 1, for
example: 3, 5, 7...<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#medianblur">org.opencv.imgproc.Imgproc.medianBlur</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)"><CODE>bilateralFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="minAreaRect(org.opencv.core.MatOfPoint2f)"><!-- --></A><H3>
minAreaRect</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/RotatedRect.html" title="class in org.opencv.core">RotatedRect</A> <B>minAreaRect</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> points)</PRE>
<DL>
<DD><p>Finds a rotated rectangle of the minimum area enclosing the input 2D point
set.</p>
<p>The function calculates and returns the minimum-area bounding rectangle
(possibly rotated) for a specified point set. See the OpenCV sample
<code>minarea.cpp</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input vector of 2D points, stored in:
<ul>
<li> <code>std.vector<></code> or <code>Mat</code> (C++ interface)
<li> <code>CvSeq*</code> or <code>CvMat*</code> (C interface)
<li> Nx2 numpy array (Python interface)
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#minarearect">org.opencv.imgproc.Imgproc.minAreaRect</a></DL>
</DD>
</DL>
<HR>
<A NAME="minEnclosingCircle(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, float[])"><!-- --></A><H3>
minEnclosingCircle</H3>
<PRE>
public static void <B>minEnclosingCircle</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> points,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> center,
float[] radius)</PRE>
<DL>
<DD><p>Finds a circle of the minimum area enclosing a 2D point set.</p>
<p>The function finds the minimal enclosing circle of a 2D point set using an
iterative algorithm. See the OpenCV sample <code>minarea.cpp</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>points</CODE> - Input vector of 2D points, stored in:
<ul>
<li> <code>std.vector<></code> or <code>Mat</code> (C++ interface)
<li> <code>CvSeq*</code> or <code>CvMat*</code> (C interface)
<li> Nx2 numpy array (Python interface)
</ul><DD><CODE>center</CODE> - Output center of the circle.<DD><CODE>radius</CODE> - Output radius of the circle.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#minenclosingcircle">org.opencv.imgproc.Imgproc.minEnclosingCircle</a></DL>
</DD>
</DL>
<HR>
<A NAME="moments(org.opencv.core.Mat)"><!-- --></A><H3>
moments</H3>
<PRE>
public static <A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc">Moments</A> <B>moments</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> array)</PRE>
<DL>
<DD><p>Calculates all of the moments up to the third order of a polygon or
rasterized shape.</p>
<p>The function computes moments, up to the 3rd order, of a vector shape or a
rasterized shape. The results are returned in the structure <code>Moments</code>
defined as: <code></p>
<p>// C++ code:</p>
<p>class Moments</p>
<p>public:</p>
<p>Moments();</p>
<p>Moments(double m00, double m10, double m01, double m20, double m11,</p>
<p>double m02, double m30, double m21, double m12, double m03);</p>
<p>Moments(const CvMoments& moments);</p>
<p>operator CvMoments() const;</p>
<p>// spatial moments</p>
<p>double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;</p>
<p>// central moments</p>
<p>double mu20, mu11, mu02, mu30, mu21, mu12, mu03;</p>
<p>// central normalized moments</p>
<p>double nu20, nu11, nu02, nu30, nu21, nu12, nu03;</p>
<p>In case of a raster image, the spatial moments <em>Moments.m_(ji)</em> are
computed as: </code></p>
<p><em>m _(ji)= sum(by: x,y)(array(x,y) * x^j * y^i)</em></p>
<p>The central moments <em>Moments.mu_(ji)</em> are computed as:</p>
<p><em>mu _(ji)= sum(by: x,y)(array(x,y) * (x - x")^j * (y - y")^i)</em></p>
<p>where <em>(x", y")</em> is the mass center:</p>
<p><em>x" = (m_10)/(m_(00)), y" = (m_01)/(m_(00))</em></p>
<p>The normalized central moments <em>Moments.nu_(ij)</em> are computed as:</p>
<p><em>nu _(ji)= (mu_(ji))/(m_(00)^((i+j)/2+1)).</em></p>
<p>Note:</p>
<p><em>mu_00=m_00</em>, <em>nu_00=1</em> <em>nu_10=mu_10=mu_01=mu_10=0</em>,
hence the values are not stored.</p>
<p>The moments of a contour are defined in the same way but computed using the
Green's formula (see http://en.wikipedia.org/wiki/Green_theorem). So, due to
a limited raster resolution, the moments computed for a contour are slightly
different from the moments computed for the same rasterized contour.</p>
<p>Note:</p>
<p>Since the contour moments are computed using Green formula, you may get
seemingly odd results for contours with self-intersections, e.g. a zero area
(<code>m00</code>) for butterfly-shaped contours.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>array</CODE> - Raster image (single-channel, 8-bit or floating-point 2D array)
or an array (<em>1 x N</em> or <em>N x 1</em>) of 2D points (<code>Point</code>
or <code>Point2f</code>).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#moments">org.opencv.imgproc.Imgproc.moments</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#contourArea(org.opencv.core.Mat, boolean)"><CODE>contourArea(org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#arcLength(org.opencv.core.MatOfPoint2f, boolean)"><CODE>arcLength(org.opencv.core.MatOfPoint2f, boolean)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="moments(org.opencv.core.Mat, boolean)"><!-- --></A><H3>
moments</H3>
<PRE>
public static <A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc">Moments</A> <B>moments</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> array,
boolean binaryImage)</PRE>
<DL>
<DD><p>Calculates all of the moments up to the third order of a polygon or
rasterized shape.</p>
<p>The function computes moments, up to the 3rd order, of a vector shape or a
rasterized shape. The results are returned in the structure <code>Moments</code>
defined as: <code></p>
<p>// C++ code:</p>
<p>class Moments</p>
<p>public:</p>
<p>Moments();</p>
<p>Moments(double m00, double m10, double m01, double m20, double m11,</p>
<p>double m02, double m30, double m21, double m12, double m03);</p>
<p>Moments(const CvMoments& moments);</p>
<p>operator CvMoments() const;</p>
<p>// spatial moments</p>
<p>double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;</p>
<p>// central moments</p>
<p>double mu20, mu11, mu02, mu30, mu21, mu12, mu03;</p>
<p>// central normalized moments</p>
<p>double nu20, nu11, nu02, nu30, nu21, nu12, nu03;</p>
<p>In case of a raster image, the spatial moments <em>Moments.m_(ji)</em> are
computed as: </code></p>
<p><em>m _(ji)= sum(by: x,y)(array(x,y) * x^j * y^i)</em></p>
<p>The central moments <em>Moments.mu_(ji)</em> are computed as:</p>
<p><em>mu _(ji)= sum(by: x,y)(array(x,y) * (x - x")^j * (y - y")^i)</em></p>
<p>where <em>(x", y")</em> is the mass center:</p>
<p><em>x" = (m_10)/(m_(00)), y" = (m_01)/(m_(00))</em></p>
<p>The normalized central moments <em>Moments.nu_(ij)</em> are computed as:</p>
<p><em>nu _(ji)= (mu_(ji))/(m_(00)^((i+j)/2+1)).</em></p>
<p>Note:</p>
<p><em>mu_00=m_00</em>, <em>nu_00=1</em> <em>nu_10=mu_10=mu_01=mu_10=0</em>,
hence the values are not stored.</p>
<p>The moments of a contour are defined in the same way but computed using the
Green's formula (see http://en.wikipedia.org/wiki/Green_theorem). So, due to
a limited raster resolution, the moments computed for a contour are slightly
different from the moments computed for the same rasterized contour.</p>
<p>Note:</p>
<p>Since the contour moments are computed using Green formula, you may get
seemingly odd results for contours with self-intersections, e.g. a zero area
(<code>m00</code>) for butterfly-shaped contours.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>array</CODE> - Raster image (single-channel, 8-bit or floating-point 2D array)
or an array (<em>1 x N</em> or <em>N x 1</em>) of 2D points (<code>Point</code>
or <code>Point2f</code>).<DD><CODE>binaryImage</CODE> - If it is true, all non-zero image pixels are treated as
1's. The parameter is used for images only.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#moments">org.opencv.imgproc.Imgproc.moments</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#contourArea(org.opencv.core.Mat, boolean)"><CODE>contourArea(org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#arcLength(org.opencv.core.MatOfPoint2f, boolean)"><CODE>arcLength(org.opencv.core.MatOfPoint2f, boolean)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat)"><!-- --></A><H3>
morphologyEx</H3>
<PRE>
public static void <B>morphologyEx</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int op,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel)</PRE>
<DL>
<DD><p>Performs advanced morphological transformations.</p>
<p>The function can perform advanced morphological transformations using an
erosion and dilation as basic operations.</p>
<p>Opening operation:</p>
<p><em>dst = open(src, element)= dilate(erode(src, element))</em></p>
<p>Closing operation:</p>
<p><em>dst = close(src, element)= erode(dilate(src, element))</em></p>
<p>Morphological gradient:</p>
<p><em>dst = morph_grad(src, element)= dilate(src, element)- erode(src,
element)</em></p>
<p>"Top hat":</p>
<p><em>dst = tophat(src, element)= src - open(src, element)</em></p>
<p>"Black hat":</p>
<p><em>dst = blackhat(src, element)= close(src, element)- src</em></p>
<p>Any of the operations can be done in-place. In case of multi-channel images,
each channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image. The number of channels can be arbitrary. The depth
should be one of <code>CV_8U</code>, <code>CV_16U</code>, <code>CV_16S</code>,
<code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - Destination image of the same size and type as <code>src</code>.<DD><CODE>op</CODE> - Type of a morphological operation that can be one of the following:
<ul>
<li> MORPH_OPEN - an opening operation
<li> MORPH_CLOSE - a closing operation
<li> MORPH_GRADIENT - a morphological gradient
<li> MORPH_TOPHAT - "top hat"
<li> MORPH_BLACKHAT - "black hat"
</ul><DD><CODE>kernel</CODE> - a kernel<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#morphologyex">org.opencv.imgproc.Imgproc.morphologyEx</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int)"><!-- --></A><H3>
morphologyEx</H3>
<PRE>
public static void <B>morphologyEx</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int op,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations)</PRE>
<DL>
<DD><p>Performs advanced morphological transformations.</p>
<p>The function can perform advanced morphological transformations using an
erosion and dilation as basic operations.</p>
<p>Opening operation:</p>
<p><em>dst = open(src, element)= dilate(erode(src, element))</em></p>
<p>Closing operation:</p>
<p><em>dst = close(src, element)= erode(dilate(src, element))</em></p>
<p>Morphological gradient:</p>
<p><em>dst = morph_grad(src, element)= dilate(src, element)- erode(src,
element)</em></p>
<p>"Top hat":</p>
<p><em>dst = tophat(src, element)= src - open(src, element)</em></p>
<p>"Black hat":</p>
<p><em>dst = blackhat(src, element)= close(src, element)- src</em></p>
<p>Any of the operations can be done in-place. In case of multi-channel images,
each channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image. The number of channels can be arbitrary. The depth
should be one of <code>CV_8U</code>, <code>CV_16U</code>, <code>CV_16S</code>,
<code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - Destination image of the same size and type as <code>src</code>.<DD><CODE>op</CODE> - Type of a morphological operation that can be one of the following:
<ul>
<li> MORPH_OPEN - an opening operation
<li> MORPH_CLOSE - a closing operation
<li> MORPH_GRADIENT - a morphological gradient
<li> MORPH_TOPHAT - "top hat"
<li> MORPH_BLACKHAT - "black hat"
</ul><DD><CODE>kernel</CODE> - a kernel<DD><CODE>anchor</CODE> - a anchor<DD><CODE>iterations</CODE> - Number of times erosion and dilation are applied.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#morphologyex">org.opencv.imgproc.Imgproc.morphologyEx</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="morphologyEx(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
morphologyEx</H3>
<PRE>
public static void <B>morphologyEx</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int op,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernel,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
int iterations,
int borderType,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</PRE>
<DL>
<DD><p>Performs advanced morphological transformations.</p>
<p>The function can perform advanced morphological transformations using an
erosion and dilation as basic operations.</p>
<p>Opening operation:</p>
<p><em>dst = open(src, element)= dilate(erode(src, element))</em></p>
<p>Closing operation:</p>
<p><em>dst = close(src, element)= erode(dilate(src, element))</em></p>
<p>Morphological gradient:</p>
<p><em>dst = morph_grad(src, element)= dilate(src, element)- erode(src,
element)</em></p>
<p>"Top hat":</p>
<p><em>dst = tophat(src, element)= src - open(src, element)</em></p>
<p>"Black hat":</p>
<p><em>dst = blackhat(src, element)= close(src, element)- src</em></p>
<p>Any of the operations can be done in-place. In case of multi-channel images,
each channel is processed independently.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image. The number of channels can be arbitrary. The depth
should be one of <code>CV_8U</code>, <code>CV_16U</code>, <code>CV_16S</code>,
<code>CV_32F" or </code>CV_64F".<DD><CODE>dst</CODE> - Destination image of the same size and type as <code>src</code>.<DD><CODE>op</CODE> - Type of a morphological operation that can be one of the following:
<ul>
<li> MORPH_OPEN - an opening operation
<li> MORPH_CLOSE - a closing operation
<li> MORPH_GRADIENT - a morphological gradient
<li> MORPH_TOPHAT - "top hat"
<li> MORPH_BLACKHAT - "black hat"
</ul><DD><CODE>kernel</CODE> - a kernel<DD><CODE>anchor</CODE> - a anchor<DD><CODE>iterations</CODE> - Number of times erosion and dilation are applied.<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate" for
details.<DD><CODE>borderValue</CODE> - Border value in case of a constant border. The default
value has a special meaning. See "createMorphologyFilter" for details.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#morphologyex">org.opencv.imgproc.Imgproc.morphologyEx</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>erode(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)"><CODE>dilate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="phaseCorrelate(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
phaseCorrelate</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> <B>phaseCorrelate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2)</PRE>
<DL>
<DD><p>The function is used to detect translational shifts that occur between two
images. The operation takes advantage of the Fourier shift theorem for
detecting the translational shift in the frequency domain. It can be used for
fast image registration as well as motion estimation. For more information
please see http://en.wikipedia.org/wiki/Phase_correlation.</p>
<p>Calculates the cross-power spectrum of two supplied source arrays. The arrays
are padded if needed with "getOptimalDFTSize".</p>
<p>Return value: detected phase shift (sub-pixel) between the two arrays.</p>
<p>The function performs the following equations</p>
<ul>
<li> First it applies a Hanning window (see http://en.wikipedia.org/wiki/Hann_function)
to each image to remove possible edge effects. This window is cached until
the array size changes to speed up processing time.
<li> Next it computes the forward DFTs of each source array:
</ul>
<p><em>mathbf(G)_a = mathcal(F)(src_1), mathbf(G)_b = mathcal(F)(src_2)</em></p>
<p>where <em>mathcal(F)</em> is the forward DFT.</p>
<ul>
<li> It then computes the cross-power spectrum of each frequency domain
array:
</ul>
<p><em>R = (mathbf(G)_a mathbf(G)_b^*)/(|mathbf(G)_a mathbf(G)_b^*|)</em></p>
<ul>
<li> Next the cross-correlation is converted back into the time domain via
the inverse DFT:
</ul>
<p><em>r = mathcal(F)^(-1)(R)</em></p>
<ul>
<li> Finally, it computes the peak location and computes a 5x5 weighted
centroid around the peak to achieve sub-pixel accuracy.
</ul>
<p><em>(Delta x, Delta y) = weightedCentroid (arg max_((x, y))(r))</em></p>
<ul>
<li> If non-zero, the response parameter is computed as the sum of the
elements of r within the 5x5 centroid around the peak location. It is
normalized to a maximum of 1 (meaning there is a single peak) and will be
smaller when there are multiple peaks.
</ul>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src1</CODE> - Source floating point array (CV_32FC1 or CV_64FC1)<DD><CODE>src2</CODE> - Source floating point array (CV_32FC1 or CV_64FC1)<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#phasecorrelate">org.opencv.imgproc.Imgproc.phaseCorrelate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#createHanningWindow(org.opencv.core.Mat, org.opencv.core.Size, int)"><CODE>createHanningWindow(org.opencv.core.Mat, org.opencv.core.Size, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#mulSpectrums(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, boolean)"><CODE>Core.mulSpectrums(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, boolean)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#getOptimalDFTSize(int)"><CODE>Core.getOptimalDFTSize(int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#idft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.idft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="phaseCorrelate(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
phaseCorrelate</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> <B>phaseCorrelate</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> window)</PRE>
<DL>
<DD><p>The function is used to detect translational shifts that occur between two
images. The operation takes advantage of the Fourier shift theorem for
detecting the translational shift in the frequency domain. It can be used for
fast image registration as well as motion estimation. For more information
please see http://en.wikipedia.org/wiki/Phase_correlation.</p>
<p>Calculates the cross-power spectrum of two supplied source arrays. The arrays
are padded if needed with "getOptimalDFTSize".</p>
<p>Return value: detected phase shift (sub-pixel) between the two arrays.</p>
<p>The function performs the following equations</p>
<ul>
<li> First it applies a Hanning window (see http://en.wikipedia.org/wiki/Hann_function)
to each image to remove possible edge effects. This window is cached until
the array size changes to speed up processing time.
<li> Next it computes the forward DFTs of each source array:
</ul>
<p><em>mathbf(G)_a = mathcal(F)(src_1), mathbf(G)_b = mathcal(F)(src_2)</em></p>
<p>where <em>mathcal(F)</em> is the forward DFT.</p>
<ul>
<li> It then computes the cross-power spectrum of each frequency domain
array:
</ul>
<p><em>R = (mathbf(G)_a mathbf(G)_b^*)/(|mathbf(G)_a mathbf(G)_b^*|)</em></p>
<ul>
<li> Next the cross-correlation is converted back into the time domain via
the inverse DFT:
</ul>
<p><em>r = mathcal(F)^(-1)(R)</em></p>
<ul>
<li> Finally, it computes the peak location and computes a 5x5 weighted
centroid around the peak to achieve sub-pixel accuracy.
</ul>
<p><em>(Delta x, Delta y) = weightedCentroid (arg max_((x, y))(r))</em></p>
<ul>
<li> If non-zero, the response parameter is computed as the sum of the
elements of r within the 5x5 centroid around the peak location. It is
normalized to a maximum of 1 (meaning there is a single peak) and will be
smaller when there are multiple peaks.
</ul>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src1</CODE> - Source floating point array (CV_32FC1 or CV_64FC1)<DD><CODE>src2</CODE> - Source floating point array (CV_32FC1 or CV_64FC1)<DD><CODE>window</CODE> - Floating point array with windowing coefficients to reduce edge
effects (optional).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/motion_analysis_and_object_tracking.html#phasecorrelate">org.opencv.imgproc.Imgproc.phaseCorrelate</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#createHanningWindow(org.opencv.core.Mat, org.opencv.core.Size, int)"><CODE>createHanningWindow(org.opencv.core.Mat, org.opencv.core.Size, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.dft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#mulSpectrums(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, boolean)"><CODE>Core.mulSpectrums(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, boolean)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#getOptimalDFTSize(int)"><CODE>Core.getOptimalDFTSize(int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#idft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><CODE>Core.idft(org.opencv.core.Mat, org.opencv.core.Mat, int, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="phaseCorrelateRes(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
phaseCorrelateRes</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> <B>phaseCorrelateRes</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> window)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="phaseCorrelateRes(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, double[])"><!-- --></A><H3>
phaseCorrelateRes</H3>
<PRE>
public static <A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> <B>phaseCorrelateRes</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> window,
double[] response)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="pointPolygonTest(org.opencv.core.MatOfPoint2f, org.opencv.core.Point, boolean)"><!-- --></A><H3>
pointPolygonTest</H3>
<PRE>
public static double <B>pointPolygonTest</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> contour,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> pt,
boolean measureDist)</PRE>
<DL>
<DD><p>Performs a point-in-contour test.</p>
<p>The function determines whether the point is inside a contour, outside, or
lies on an edge (or coincides with a vertex). It returns positive (inside),
negative (outside), or zero (on an edge) value, correspondingly. When
<code>measureDist=false</code>, the return value is +1, -1, and 0,
respectively. Otherwise, the return value is a signed distance between the
point and the nearest contour edge.</p>
<p>See below a sample output of the function where each image pixel is tested
against the contour.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>contour</CODE> - Input contour.<DD><CODE>pt</CODE> - Point tested against the contour.<DD><CODE>measureDist</CODE> - If true, the function estimates the signed distance from
the point to the nearest contour edge. Otherwise, the function only checks if
the point is inside a contour or not.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/structural_analysis_and_shape_descriptors.html#pointpolygontest">org.opencv.imgproc.Imgproc.pointPolygonTest</a></DL>
</DD>
</DL>
<HR>
<A NAME="preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
preCornerDetect</H3>
<PRE>
public static void <B>preCornerDetect</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ksize)</PRE>
<DL>
<DD><p>Calculates a feature map for corner detection.</p>
<p>The function calculates the complex spatial derivative-based function of the
source image</p>
<p><em>dst = (D_x src)^2 * D_(yy) src + (D_y src)^2 * D_(xx) src - 2 D_x src *
D_y src * D_(xy) src</em></p>
<p>where <em>D_x</em>,<em>D_y</em> are the first image derivatives,
<em>D_(xx)</em>,<em>D_(yy)</em> are the second image derivatives, and
<em>D_(xy)</em> is the mixed derivative.
The corners can be found as local maximums of the functions, as shown below:
<code></p>
<p>// C++ code:</p>
<p>Mat corners, dilated_corners;</p>
<p>preCornerDetect(image, corners, 3);</p>
<p>// dilation with 3x3 rectangular structuring element</p>
<p>dilate(corners, dilated_corners, Mat(), 1);</p>
<p>Mat corner_mask = corners == dilated_corners;</p>
<p></code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source single-channel 8-bit of floating-point image.<DD><CODE>dst</CODE> - Output image that has the type <code>CV_32F</code> and the same
size as <code>src</code>.<DD><CODE>ksize</CODE> - Aperture size of the "Sobel".<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#precornerdetect">org.opencv.imgproc.Imgproc.preCornerDetect</a></DL>
</DD>
</DL>
<HR>
<A NAME="preCornerDetect(org.opencv.core.Mat, org.opencv.core.Mat, int, int)"><!-- --></A><H3>
preCornerDetect</H3>
<PRE>
public static void <B>preCornerDetect</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ksize,
int borderType)</PRE>
<DL>
<DD><p>Calculates a feature map for corner detection.</p>
<p>The function calculates the complex spatial derivative-based function of the
source image</p>
<p><em>dst = (D_x src)^2 * D_(yy) src + (D_y src)^2 * D_(xx) src - 2 D_x src *
D_y src * D_(xy) src</em></p>
<p>where <em>D_x</em>,<em>D_y</em> are the first image derivatives,
<em>D_(xx)</em>,<em>D_(yy)</em> are the second image derivatives, and
<em>D_(xy)</em> is the mixed derivative.
The corners can be found as local maximums of the functions, as shown below:
<code></p>
<p>// C++ code:</p>
<p>Mat corners, dilated_corners;</p>
<p>preCornerDetect(image, corners, 3);</p>
<p>// dilation with 3x3 rectangular structuring element</p>
<p>dilate(corners, dilated_corners, Mat(), 1);</p>
<p>Mat corner_mask = corners == dilated_corners;</p>
<p></code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source single-channel 8-bit of floating-point image.<DD><CODE>dst</CODE> - Output image that has the type <code>CV_32F</code> and the same
size as <code>src</code>.<DD><CODE>ksize</CODE> - Aperture size of the "Sobel".<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate".<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/feature_detection.html#precornerdetect">org.opencv.imgproc.Imgproc.preCornerDetect</a></DL>
</DD>
</DL>
<HR>
<A NAME="PSNR(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
PSNR</H3>
<PRE>
public static double <B>PSNR</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src2)</PRE>
<DL>
<DD><DL>
</DL>
</DD>
</DL>
<HR>
<A NAME="pyrDown(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
pyrDown</H3>
<PRE>
public static void <B>pyrDown</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Blurs an image and downsamples it.</p>
<p>The function performs the downsampling step of the Gaussian pyramid
construction. First, it convolves the source image with the kernel:</p>
<p><em>1/256 1 4 6 4 1
4 16 24 16 4
6 24 36 24 6
4 16 24 16 4
1 4 6 4 1 </em></p>
<p>Then, it downsamples the image by rejecting even rows and columns.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image; it has the specified size and the same type as
<code>src</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrdown">org.opencv.imgproc.Imgproc.pyrDown</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrDown(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)"><!-- --></A><H3>
pyrDown</H3>
<PRE>
public static void <B>pyrDown</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize)</PRE>
<DL>
<DD><p>Blurs an image and downsamples it.</p>
<p>The function performs the downsampling step of the Gaussian pyramid
construction. First, it convolves the source image with the kernel:</p>
<p><em>1/256 1 4 6 4 1
4 16 24 16 4
6 24 36 24 6
4 16 24 16 4
1 4 6 4 1 </em></p>
<p>Then, it downsamples the image by rejecting even rows and columns.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image; it has the specified size and the same type as
<code>src</code>.<DD><CODE>dstsize</CODE> - size of the output image; by default, it is computed as
<code>Size((src.cols+1)/2, (src.rows+1)/2)</code>, but in any case, the
following conditions should be satisfied:
<p><em> ltBR gt| dstsize.width *2-src.cols| <= 2
|dstsize.height *2-src.rows| <= 2 </em></p><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrdown">org.opencv.imgproc.Imgproc.pyrDown</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrDown(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)"><!-- --></A><H3>
pyrDown</H3>
<PRE>
public static void <B>pyrDown</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize,
int borderType)</PRE>
<DL>
<DD><p>Blurs an image and downsamples it.</p>
<p>The function performs the downsampling step of the Gaussian pyramid
construction. First, it convolves the source image with the kernel:</p>
<p><em>1/256 1 4 6 4 1
4 16 24 16 4
6 24 36 24 6
4 16 24 16 4
1 4 6 4 1 </em></p>
<p>Then, it downsamples the image by rejecting even rows and columns.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image; it has the specified size and the same type as
<code>src</code>.<DD><CODE>dstsize</CODE> - size of the output image; by default, it is computed as
<code>Size((src.cols+1)/2, (src.rows+1)/2)</code>, but in any case, the
following conditions should be satisfied:
<p><em> ltBR gt| dstsize.width *2-src.cols| <= 2
|dstsize.height *2-src.rows| <= 2 </em></p><DD><CODE>borderType</CODE> - a borderType<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrdown">org.opencv.imgproc.Imgproc.pyrDown</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrMeanShiftFiltering(org.opencv.core.Mat, org.opencv.core.Mat, double, double)"><!-- --></A><H3>
pyrMeanShiftFiltering</H3>
<PRE>
public static void <B>pyrMeanShiftFiltering</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double sp,
double sr)</PRE>
<DL>
<DD><p>Performs initial step of meanshift segmentation of an image.</p>
<p>The function implements the filtering stage of meanshift segmentation, that
is, the output of the function is the filtered "posterized" image with color
gradients and fine-grain texture flattened. At every pixel <code>(X,Y)</code>
of the input image (or down-sized input image, see below) the function
executes meanshift iterations, that is, the pixel <code>(X,Y)</code>
neighborhood in the joint space-color hyperspace is considered:</p>
<p><em>(x,y): X- sp <= x <= X+ sp, Y- sp <= y <= Y+ sp, ||(R,G,B)-(r,g,b)|| <=
sr</em></p>
<p>where <code>(R,G,B)</code> and <code>(r,g,b)</code> are the vectors of color
components at <code>(X,Y)</code> and <code>(x,y)</code>, respectively
(though, the algorithm does not depend on the color space used, so any
3-component color space can be used instead). Over the neighborhood the
average spatial value <code>(X',Y')</code> and average color vector
<code>(R',G',B')</code> are found and they act as the neighborhood center on
the next iteration:</p>
<p><em>(X,Y)~(X',Y'), (R,G,B)~(R',G',B').</em></p>
<p>After the iterations over, the color components of the initial pixel (that
is, the pixel from where the iterations started) are set to the final value
(average color at the last iteration):</p>
<p><em>I(X,Y) <- (R*,G*,B*)</em></p>
<p>When <code>maxLevel > 0</code>, the gaussian pyramid of <code>maxLevel+1</code>
levels is built, and the above procedure is run on the smallest layer first.
After that, the results are propagated to the larger layer and the iterations
are run again only on those pixels where the layer colors differ by more than
<code>sr</code> from the lower-resolution layer of the pyramid. That makes
boundaries of color regions sharper. Note that the results will be actually
different from the ones obtained by running the meanshift procedure on the
whole original image (i.e. when <code>maxLevel==0</code>).</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - The source 8-bit, 3-channel image.<DD><CODE>dst</CODE> - The destination image of the same format and the same size as the
source.<DD><CODE>sp</CODE> - The spatial window radius.<DD><CODE>sr</CODE> - The color window radius.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrmeanshiftfiltering">org.opencv.imgproc.Imgproc.pyrMeanShiftFiltering</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrMeanShiftFiltering(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int, org.opencv.core.TermCriteria)"><!-- --></A><H3>
pyrMeanShiftFiltering</H3>
<PRE>
public static void <B>pyrMeanShiftFiltering</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double sp,
double sr,
int maxLevel,
<A HREF="../../../org/opencv/core/TermCriteria.html" title="class in org.opencv.core">TermCriteria</A> termcrit)</PRE>
<DL>
<DD><p>Performs initial step of meanshift segmentation of an image.</p>
<p>The function implements the filtering stage of meanshift segmentation, that
is, the output of the function is the filtered "posterized" image with color
gradients and fine-grain texture flattened. At every pixel <code>(X,Y)</code>
of the input image (or down-sized input image, see below) the function
executes meanshift iterations, that is, the pixel <code>(X,Y)</code>
neighborhood in the joint space-color hyperspace is considered:</p>
<p><em>(x,y): X- sp <= x <= X+ sp, Y- sp <= y <= Y+ sp, ||(R,G,B)-(r,g,b)|| <=
sr</em></p>
<p>where <code>(R,G,B)</code> and <code>(r,g,b)</code> are the vectors of color
components at <code>(X,Y)</code> and <code>(x,y)</code>, respectively
(though, the algorithm does not depend on the color space used, so any
3-component color space can be used instead). Over the neighborhood the
average spatial value <code>(X',Y')</code> and average color vector
<code>(R',G',B')</code> are found and they act as the neighborhood center on
the next iteration:</p>
<p><em>(X,Y)~(X',Y'), (R,G,B)~(R',G',B').</em></p>
<p>After the iterations over, the color components of the initial pixel (that
is, the pixel from where the iterations started) are set to the final value
(average color at the last iteration):</p>
<p><em>I(X,Y) <- (R*,G*,B*)</em></p>
<p>When <code>maxLevel > 0</code>, the gaussian pyramid of <code>maxLevel+1</code>
levels is built, and the above procedure is run on the smallest layer first.
After that, the results are propagated to the larger layer and the iterations
are run again only on those pixels where the layer colors differ by more than
<code>sr</code> from the lower-resolution layer of the pyramid. That makes
boundaries of color regions sharper. Note that the results will be actually
different from the ones obtained by running the meanshift procedure on the
whole original image (i.e. when <code>maxLevel==0</code>).</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - The source 8-bit, 3-channel image.<DD><CODE>dst</CODE> - The destination image of the same format and the same size as the
source.<DD><CODE>sp</CODE> - The spatial window radius.<DD><CODE>sr</CODE> - The color window radius.<DD><CODE>maxLevel</CODE> - Maximum level of the pyramid for the segmentation.<DD><CODE>termcrit</CODE> - Termination criteria: when to stop meanshift iterations.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrmeanshiftfiltering">org.opencv.imgproc.Imgproc.pyrMeanShiftFiltering</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrUp(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
pyrUp</H3>
<PRE>
public static void <B>pyrUp</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst)</PRE>
<DL>
<DD><p>Upsamples an image and then blurs it.</p>
<p>The function performs the upsampling step of the Gaussian pyramid
construction, though it can actually be used to construct the Laplacian
pyramid. First, it upsamples the source image by injecting even zero rows and
columns and then convolves the result with the same kernel as in "pyrDown"
multiplied by 4.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image. It has the specified size and the same type as
<code>src</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrup">org.opencv.imgproc.Imgproc.pyrUp</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrUp(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)"><!-- --></A><H3>
pyrUp</H3>
<PRE>
public static void <B>pyrUp</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize)</PRE>
<DL>
<DD><p>Upsamples an image and then blurs it.</p>
<p>The function performs the upsampling step of the Gaussian pyramid
construction, though it can actually be used to construct the Laplacian
pyramid. First, it upsamples the source image by injecting even zero rows and
columns and then convolves the result with the same kernel as in "pyrDown"
multiplied by 4.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image. It has the specified size and the same type as
<code>src</code>.<DD><CODE>dstsize</CODE> - size of the output image; by default, it is computed as
<code>Size(src.cols*2, (src.rows*2)</code>, but in any case, the following
conditions should be satisfied:
<p><em> ltBR gt| dstsize.width -src.cols*2| <= (dstsize.width mod 2)
|dstsize.height -src.rows*2| <= (dstsize.height mod 2) </em></p><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrup">org.opencv.imgproc.Imgproc.pyrUp</a></DL>
</DD>
</DL>
<HR>
<A NAME="pyrUp(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)"><!-- --></A><H3>
pyrUp</H3>
<PRE>
public static void <B>pyrUp</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dstsize,
int borderType)</PRE>
<DL>
<DD><p>Upsamples an image and then blurs it.</p>
<p>The function performs the upsampling step of the Gaussian pyramid
construction, though it can actually be used to construct the Laplacian
pyramid. First, it upsamples the source image by injecting even zero rows and
columns and then convolves the result with the same kernel as in "pyrDown"
multiplied by 4.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image. It has the specified size and the same type as
<code>src</code>.<DD><CODE>dstsize</CODE> - size of the output image; by default, it is computed as
<code>Size(src.cols*2, (src.rows*2)</code>, but in any case, the following
conditions should be satisfied:
<p><em> ltBR gt| dstsize.width -src.cols*2| <= (dstsize.width mod 2)
|dstsize.height -src.rows*2| <= (dstsize.height mod 2) </em></p><DD><CODE>borderType</CODE> - a borderType<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#pyrup">org.opencv.imgproc.Imgproc.pyrUp</a></DL>
</DD>
</DL>
<HR>
<A NAME="remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><!-- --></A><H3>
remap</H3>
<PRE>
public static void <B>remap</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
int interpolation)</PRE>
<DL>
<DD><p>Applies a generic geometrical transformation to an image.</p>
<p>The function <code>remap</code> transforms the source image using the
specified map:</p>
<p><em>dst(x,y) = src(map_x(x,y),map_y(x,y))</em></p>
<p>where values of pixels with non-integer coordinates are computed using one of
available interpolation methods.
<em>map_x</em> and <em>map_y</em> can be encoded as separate floating-point
maps in <em>map_1</em> and <em>map_2</em> respectively, or interleaved
floating-point maps of <em>(x,y)</em> in <em>map_1</em>, or fixed-point maps
created by using "convertMaps". The reason you might want to convert from
floating to fixed-point representations of a map is that they can yield much
faster (~2x) remapping operations. In the converted case, <em>map_1</em>
contains pairs <code>(cvFloor(x), cvFloor(y))</code> and <em>map_2</em>
contains indices in a table of interpolation coefficients.</p>
<p>This function cannot operate in-place.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image. It has the same size as <code>map1</code> and
the same type as <code>src</code>.<DD><CODE>map1</CODE> - The first map of either <code>(x,y)</code> points or just
<code>x</code> values having the type <code>CV_16SC2</code>,
<code>CV_32FC1</code>, or <code>CV_32FC2</code>. See "convertMaps" for
details on converting a floating point representation to fixed-point for
speed.<DD><CODE>map2</CODE> - The second map of <code>y</code> values having the type
<code>CV_16UC1</code>, <code>CV_32FC1</code>, or none (empty map if
<code>map1</code> is <code>(x,y)</code> points), respectively.<DD><CODE>interpolation</CODE> - Interpolation method (see "resize"). The method
<code>INTER_AREA</code> is not supported by this function.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#remap">org.opencv.imgproc.Imgproc.remap</a></DL>
</DD>
</DL>
<HR>
<A NAME="remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
remap</H3>
<PRE>
public static void <B>remap</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map1,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> map2,
int interpolation,
int borderMode,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</PRE>
<DL>
<DD><p>Applies a generic geometrical transformation to an image.</p>
<p>The function <code>remap</code> transforms the source image using the
specified map:</p>
<p><em>dst(x,y) = src(map_x(x,y),map_y(x,y))</em></p>
<p>where values of pixels with non-integer coordinates are computed using one of
available interpolation methods.
<em>map_x</em> and <em>map_y</em> can be encoded as separate floating-point
maps in <em>map_1</em> and <em>map_2</em> respectively, or interleaved
floating-point maps of <em>(x,y)</em> in <em>map_1</em>, or fixed-point maps
created by using "convertMaps". The reason you might want to convert from
floating to fixed-point representations of a map is that they can yield much
faster (~2x) remapping operations. In the converted case, <em>map_1</em>
contains pairs <code>(cvFloor(x), cvFloor(y))</code> and <em>map_2</em>
contains indices in a table of interpolation coefficients.</p>
<p>This function cannot operate in-place.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image. It has the same size as <code>map1</code> and
the same type as <code>src</code>.<DD><CODE>map1</CODE> - The first map of either <code>(x,y)</code> points or just
<code>x</code> values having the type <code>CV_16SC2</code>,
<code>CV_32FC1</code>, or <code>CV_32FC2</code>. See "convertMaps" for
details on converting a floating point representation to fixed-point for
speed.<DD><CODE>map2</CODE> - The second map of <code>y</code> values having the type
<code>CV_16UC1</code>, <code>CV_32FC1</code>, or none (empty map if
<code>map1</code> is <code>(x,y)</code> points), respectively.<DD><CODE>interpolation</CODE> - Interpolation method (see "resize"). The method
<code>INTER_AREA</code> is not supported by this function.<DD><CODE>borderMode</CODE> - Pixel extrapolation method (see "borderInterpolate"). When
<code>borderMode=BORDER_TRANSPARENT</code>, it means that the pixels in the
destination image that corresponds to the "outliers" in the source image are
not modified by the function.<DD><CODE>borderValue</CODE> - Value used in case of a constant border. By default, it is
0.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#remap">org.opencv.imgproc.Imgproc.remap</a></DL>
</DD>
</DL>
<HR>
<A NAME="resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)"><!-- --></A><H3>
resize</H3>
<PRE>
public static void <B>resize</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize)</PRE>
<DL>
<DD><p>Resizes an image.</p>
<p>The function <code>resize</code> resizes the image <code>src</code> down to
or up to the specified size.Note that the initial <code>dst</code> type or
size are not taken into account. Instead, the size and type are derived from
the <code>src</code>,<code>dsize</code>,<code>fx</code>, and <code>fy</code>.
If you want to resize <code>src</code> so that it fits the pre-created
<code>dst</code>, you may call the function as follows: <code></p>
<p>// C++ code:</p>
<p>// explicitly specify dsize=dst.size(); fx and fy will be computed from that.</p>
<p>resize(src, dst, dst.size(), 0, 0, interpolation);</p>
<p>If you want to decimate the image by factor of 2 in each direction, you can
call the function this way:</p>
<p>// specify fx and fy and let the function compute the destination image size.</p>
<p>resize(src, dst, Size(), 0.5, 0.5, interpolation);</p>
<p>To shrink an image, it will generally look best with CV_INTER_AREA
interpolation, whereas to enlarge an image, it will generally look best with
CV_INTER_CUBIC (slow) or CV_INTER_LINEAR (faster but still looks OK).
</code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image; it has the size <code>dsize</code> (when it is
non-zero) or the size computed from <code>src.size()</code>, <code>fx</code>,
and <code>fy</code>; the type of <code>dst</code> is the same as of
<code>src</code>.<DD><CODE>dsize</CODE> - output image size; if it equals zero, it is computed as:
<p><em>dsize = Size(round(fx*src.cols), round(fy*src.rows))</em></p>
<p>Either <code>dsize</code> or both <code>fx</code> and <code>fy</code> must be
non-zero.</p><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#resize">org.opencv.imgproc.Imgproc.resize</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><!-- --></A><H3>
resize</H3>
<PRE>
public static void <B>resize</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
double fx,
double fy,
int interpolation)</PRE>
<DL>
<DD><p>Resizes an image.</p>
<p>The function <code>resize</code> resizes the image <code>src</code> down to
or up to the specified size.Note that the initial <code>dst</code> type or
size are not taken into account. Instead, the size and type are derived from
the <code>src</code>,<code>dsize</code>,<code>fx</code>, and <code>fy</code>.
If you want to resize <code>src</code> so that it fits the pre-created
<code>dst</code>, you may call the function as follows: <code></p>
<p>// C++ code:</p>
<p>// explicitly specify dsize=dst.size(); fx and fy will be computed from that.</p>
<p>resize(src, dst, dst.size(), 0, 0, interpolation);</p>
<p>If you want to decimate the image by factor of 2 in each direction, you can
call the function this way:</p>
<p>// specify fx and fy and let the function compute the destination image size.</p>
<p>resize(src, dst, Size(), 0.5, 0.5, interpolation);</p>
<p>To shrink an image, it will generally look best with CV_INTER_AREA
interpolation, whereas to enlarge an image, it will generally look best with
CV_INTER_CUBIC (slow) or CV_INTER_LINEAR (faster but still looks OK).
</code></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image; it has the size <code>dsize</code> (when it is
non-zero) or the size computed from <code>src.size()</code>, <code>fx</code>,
and <code>fy</code>; the type of <code>dst</code> is the same as of
<code>src</code>.<DD><CODE>dsize</CODE> - output image size; if it equals zero, it is computed as:
<p><em>dsize = Size(round(fx*src.cols), round(fy*src.rows))</em></p>
<p>Either <code>dsize</code> or both <code>fx</code> and <code>fy</code> must be
non-zero.</p><DD><CODE>fx</CODE> - scale factor along the horizontal axis; when it equals 0, it is
computed as
<p><em>(double)dsize.width/src.cols</em></p><DD><CODE>fy</CODE> - scale factor along the vertical axis; when it equals 0, it is
computed as
<p><em>(double)dsize.height/src.rows</em></p><DD><CODE>interpolation</CODE> - interpolation method:
<ul>
<li> INTER_NEAREST - a nearest-neighbor interpolation
<li> INTER_LINEAR - a bilinear interpolation (used by default)
<li> INTER_AREA - resampling using pixel area relation. It may be a
preferred method for image decimation, as it gives moire'-free results. But
when the image is zoomed, it is similar to the <code>INTER_NEAREST</code>
method.
<li> INTER_CUBIC - a bicubic interpolation over 4x4 pixel neighborhood
<li> INTER_LANCZOS4 - a Lanczos interpolation over 8x8 pixel neighborhood
</ul><DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#resize">org.opencv.imgproc.Imgproc.resize</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><!-- --></A><H3>
Scharr</H3>
<PRE>
public static void <B>Scharr</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy)</PRE>
<DL>
<DD><p>Calculates the first x- or y- image derivative using Scharr operator.</p>
<p>The function computes the first x- or y- spatial image derivative using the
Scharr operator. The call</p>
<p><em>Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)</em></p>
<p>is equivalent to</p>
<p><em>Sobel(src, dst, ddepth, dx, dy, CV_SCHARR, scale, delta,
borderType).</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - output image depth (see "Sobel" for the list of supported
combination of <code>src.depth()</code> and <code>ddepth</code>).<DD><CODE>dx</CODE> - order of the derivative x.<DD><CODE>dy</CODE> - order of the derivative y.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#scharr">org.opencv.imgproc.Imgproc.Scharr</a>,
<A HREF="../../../org/opencv/core/Core.html#cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Core.cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double)"><!-- --></A><H3>
Scharr</H3>
<PRE>
public static void <B>Scharr</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
double scale,
double delta)</PRE>
<DL>
<DD><p>Calculates the first x- or y- image derivative using Scharr operator.</p>
<p>The function computes the first x- or y- spatial image derivative using the
Scharr operator. The call</p>
<p><em>Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)</em></p>
<p>is equivalent to</p>
<p><em>Sobel(src, dst, ddepth, dx, dy, CV_SCHARR, scale, delta,
borderType).</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - output image depth (see "Sobel" for the list of supported
combination of <code>src.depth()</code> and <code>ddepth</code>).<DD><CODE>dx</CODE> - order of the derivative x.<DD><CODE>dy</CODE> - order of the derivative y.<DD><CODE>scale</CODE> - optional scale factor for the computed derivative values; by
default, no scaling is applied (see "getDerivKernels" for details).<DD><CODE>delta</CODE> - optional delta value that is added to the results prior to
storing them in <code>dst</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#scharr">org.opencv.imgproc.Imgproc.Scharr</a>,
<A HREF="../../../org/opencv/core/Core.html#cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Core.cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><!-- --></A><H3>
Scharr</H3>
<PRE>
public static void <B>Scharr</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
double scale,
double delta,
int borderType)</PRE>
<DL>
<DD><p>Calculates the first x- or y- image derivative using Scharr operator.</p>
<p>The function computes the first x- or y- spatial image derivative using the
Scharr operator. The call</p>
<p><em>Scharr(src, dst, ddepth, dx, dy, scale, delta, borderType)</em></p>
<p>is equivalent to</p>
<p><em>Sobel(src, dst, ddepth, dx, dy, CV_SCHARR, scale, delta,
borderType).</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - output image depth (see "Sobel" for the list of supported
combination of <code>src.depth()</code> and <code>ddepth</code>).<DD><CODE>dx</CODE> - order of the derivative x.<DD><CODE>dy</CODE> - order of the derivative y.<DD><CODE>scale</CODE> - optional scale factor for the computed derivative values; by
default, no scaling is applied (see "getDerivKernels" for details).<DD><CODE>delta</CODE> - optional delta value that is added to the results prior to
storing them in <code>dst</code>.<DD><CODE>borderType</CODE> - pixel extrapolation method (see "borderInterpolate" for
details).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#scharr">org.opencv.imgproc.Imgproc.Scharr</a>,
<A HREF="../../../org/opencv/core/Core.html#cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Core.cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
sepFilter2D</H3>
<PRE>
public static void <B>sepFilter2D</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelX,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelY)</PRE>
<DL>
<DD><p>Applies a separable linear filter to an image.</p>
<p>The function applies a separable linear filter to the image. That is, first,
every row of <code>src</code> is filtered with the 1D kernel
<code>kernelX</code>. Then, every column of the result is filtered with the
1D kernel <code>kernelY</code>. The final result shifted by <code>delta</code>
is stored in <code>dst</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same size and the same number of channels
as <code>src</code>.<DD><CODE>ddepth</CODE> - Destination image depth. The following combination of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the destination image will have the same depth
as the source.</p><DD><CODE>kernelX</CODE> - Coefficients for filtering each row.<DD><CODE>kernelY</CODE> - Coefficients for filtering each column.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#sepfilter2d">org.opencv.imgproc.Imgproc.sepFilter2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><CODE>Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double)"><!-- --></A><H3>
sepFilter2D</H3>
<PRE>
public static void <B>sepFilter2D</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelX,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelY,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta)</PRE>
<DL>
<DD><p>Applies a separable linear filter to an image.</p>
<p>The function applies a separable linear filter to the image. That is, first,
every row of <code>src</code> is filtered with the 1D kernel
<code>kernelX</code>. Then, every column of the result is filtered with the
1D kernel <code>kernelY</code>. The final result shifted by <code>delta</code>
is stored in <code>dst</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same size and the same number of channels
as <code>src</code>.<DD><CODE>ddepth</CODE> - Destination image depth. The following combination of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the destination image will have the same depth
as the source.</p><DD><CODE>kernelX</CODE> - Coefficients for filtering each row.<DD><CODE>kernelY</CODE> - Coefficients for filtering each column.<DD><CODE>anchor</CODE> - Anchor position within the kernel. The default value <em>(-1,
1)</em> means that the anchor is at the kernel center.<DD><CODE>delta</CODE> - Value added to the filtered results before storing them.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#sepfilter2d">org.opencv.imgproc.Imgproc.sepFilter2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><CODE>Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><!-- --></A><H3>
sepFilter2D</H3>
<PRE>
public static void <B>sepFilter2D</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelX,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> kernelY,
<A HREF="../../../org/opencv/core/Point.html" title="class in org.opencv.core">Point</A> anchor,
double delta,
int borderType)</PRE>
<DL>
<DD><p>Applies a separable linear filter to an image.</p>
<p>The function applies a separable linear filter to the image. That is, first,
every row of <code>src</code> is filtered with the 1D kernel
<code>kernelX</code>. Then, every column of the result is filtered with the
1D kernel <code>kernelY</code>. The final result shifted by <code>delta</code>
is stored in <code>dst</code>.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Source image.<DD><CODE>dst</CODE> - Destination image of the same size and the same number of channels
as <code>src</code>.<DD><CODE>ddepth</CODE> - Destination image depth. The following combination of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the destination image will have the same depth
as the source.</p><DD><CODE>kernelX</CODE> - Coefficients for filtering each row.<DD><CODE>kernelY</CODE> - Coefficients for filtering each column.<DD><CODE>anchor</CODE> - Anchor position within the kernel. The default value <em>(-1,
1)</em> means that the anchor is at the kernel center.<DD><CODE>delta</CODE> - Value added to the filtered results before storing them.<DD><CODE>borderType</CODE> - Pixel extrapolation method. See "borderInterpolate" for
details.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#sepfilter2d">org.opencv.imgproc.Imgproc.sepFilter2D</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><CODE>Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)"><CODE>boxFilter(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Size, org.opencv.core.Point, boolean, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)"><CODE>blur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int)"><!-- --></A><H3>
Sobel</H3>
<PRE>
public static void <B>Sobel</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy)</PRE>
<DL>
<DD><p>Calculates the first, second, third, or mixed image derivatives using an
extended Sobel operator.</p>
<p>In all cases except one, the <em>ksize x<BR>ksize</em> separable kernel
is used to calculate the derivative. When <em>ksize = 1</em>, the <em>3 x
1</em> or <em>1 x 3</em> kernel is used (that is, no Gaussian smoothing is
done). <code>ksize = 1</code> can only be used for the first or the second x-
or y- derivatives.</p>
<p>There is also the special value <code>ksize = CV_SCHARR</code> (-1) that
corresponds to the <em>3x3</em> Scharr filter that may give more accurate
results than the <em>3x3</em> Sobel. The Scharr aperture is</p>
<p><em>
|-3 0 3|
|-10 0 10|
|-3 0 3|
</em></p>
<p>for the x-derivative, or transposed for the y-derivative.</p>
<p>The function calculates an image derivative by convolving the image with the
appropriate kernel:</p>
<p><em>dst = (d^(xorder+yorder) src)/(dx^(xorder) dy^(yorder))</em></p>
<p>The Sobel operators combine Gaussian smoothing and differentiation, so the
result is more or less resistant to the noise. Most often, the function is
called with (<code>xorder</code> = 1, <code>yorder</code> = 0,
<code>ksize</code> = 3) or (<code>xorder</code> = 0, <code>yorder</code> = 1,
<code>ksize</code> = 3) to calculate the first x- or y- image derivative. The
first case corresponds to a kernel of:</p>
<p><em>
|-1 0 1|
|-2 0 2|
|-1 0 1|
</em></p>
<p>The second case corresponds to a kernel of:</p>
<p><em>
|-1 -2 -1|
|0 0 0|
|1 2 1|
</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - output image depth; the following combinations of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the destination image will have the same depth
as the source; in the case of 8-bit input images it will result in truncated
derivatives.</p><DD><CODE>dx</CODE> - a dx<DD><CODE>dy</CODE> - a dy<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#sobel">org.opencv.imgproc.Imgproc.Sobel</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Core.cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)"><CODE>Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><CODE>Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double)"><!-- --></A><H3>
Sobel</H3>
<PRE>
public static void <B>Sobel</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
int ksize,
double scale,
double delta)</PRE>
<DL>
<DD><p>Calculates the first, second, third, or mixed image derivatives using an
extended Sobel operator.</p>
<p>In all cases except one, the <em>ksize x<BR>ksize</em> separable kernel
is used to calculate the derivative. When <em>ksize = 1</em>, the <em>3 x
1</em> or <em>1 x 3</em> kernel is used (that is, no Gaussian smoothing is
done). <code>ksize = 1</code> can only be used for the first or the second x-
or y- derivatives.</p>
<p>There is also the special value <code>ksize = CV_SCHARR</code> (-1) that
corresponds to the <em>3x3</em> Scharr filter that may give more accurate
results than the <em>3x3</em> Sobel. The Scharr aperture is</p>
<p><em>
|-3 0 3|
|-10 0 10|
|-3 0 3|
</em></p>
<p>for the x-derivative, or transposed for the y-derivative.</p>
<p>The function calculates an image derivative by convolving the image with the
appropriate kernel:</p>
<p><em>dst = (d^(xorder+yorder) src)/(dx^(xorder) dy^(yorder))</em></p>
<p>The Sobel operators combine Gaussian smoothing and differentiation, so the
result is more or less resistant to the noise. Most often, the function is
called with (<code>xorder</code> = 1, <code>yorder</code> = 0,
<code>ksize</code> = 3) or (<code>xorder</code> = 0, <code>yorder</code> = 1,
<code>ksize</code> = 3) to calculate the first x- or y- image derivative. The
first case corresponds to a kernel of:</p>
<p><em>
|-1 0 1|
|-2 0 2|
|-1 0 1|
</em></p>
<p>The second case corresponds to a kernel of:</p>
<p><em>
|-1 -2 -1|
|0 0 0|
|1 2 1|
</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - output image depth; the following combinations of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the destination image will have the same depth
as the source; in the case of 8-bit input images it will result in truncated
derivatives.</p><DD><CODE>dx</CODE> - a dx<DD><CODE>dy</CODE> - a dy<DD><CODE>ksize</CODE> - size of the extended Sobel kernel; it must be 1, 3, 5, or 7.<DD><CODE>scale</CODE> - optional scale factor for the computed derivative values; by
default, no scaling is applied (see "getDerivKernels" for details).<DD><CODE>delta</CODE> - optional delta value that is added to the results prior to
storing them in <code>dst</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#sobel">org.opencv.imgproc.Imgproc.Sobel</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Core.cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)"><CODE>Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><CODE>Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="Sobel(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, int, double, double, int)"><!-- --></A><H3>
Sobel</H3>
<PRE>
public static void <B>Sobel</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
int ddepth,
int dx,
int dy,
int ksize,
double scale,
double delta,
int borderType)</PRE>
<DL>
<DD><p>Calculates the first, second, third, or mixed image derivatives using an
extended Sobel operator.</p>
<p>In all cases except one, the <em>ksize x<BR>ksize</em> separable kernel
is used to calculate the derivative. When <em>ksize = 1</em>, the <em>3 x
1</em> or <em>1 x 3</em> kernel is used (that is, no Gaussian smoothing is
done). <code>ksize = 1</code> can only be used for the first or the second x-
or y- derivatives.</p>
<p>There is also the special value <code>ksize = CV_SCHARR</code> (-1) that
corresponds to the <em>3x3</em> Scharr filter that may give more accurate
results than the <em>3x3</em> Sobel. The Scharr aperture is</p>
<p><em>
|-3 0 3|
|-10 0 10|
|-3 0 3|
</em></p>
<p>for the x-derivative, or transposed for the y-derivative.</p>
<p>The function calculates an image derivative by convolving the image with the
appropriate kernel:</p>
<p><em>dst = (d^(xorder+yorder) src)/(dx^(xorder) dy^(yorder))</em></p>
<p>The Sobel operators combine Gaussian smoothing and differentiation, so the
result is more or less resistant to the noise. Most often, the function is
called with (<code>xorder</code> = 1, <code>yorder</code> = 0,
<code>ksize</code> = 3) or (<code>xorder</code> = 0, <code>yorder</code> = 1,
<code>ksize</code> = 3) to calculate the first x- or y- image derivative. The
first case corresponds to a kernel of:</p>
<p><em>
|-1 0 1|
|-2 0 2|
|-1 0 1|
</em></p>
<p>The second case corresponds to a kernel of:</p>
<p><em>
|-1 -2 -1|
|0 0 0|
|1 2 1|
</em></p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image of the same size and the same number of channels as
<code>src</code>.<DD><CODE>ddepth</CODE> - output image depth; the following combinations of
<code>src.depth()</code> and <code>ddepth</code> are supported:
<ul>
<li> <code>src.depth()</code> = <code>CV_8U</code>, <code>ddepth</code> =
-1/<code>CV_16S</code>/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_16U</code>/<code>CV_16S</code>,
<code>ddepth</code> = -1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_32F</code>, <code>ddepth</code> =
-1/<code>CV_32F</code>/<code>CV_64F</code>
<li> <code>src.depth()</code> = <code>CV_64F</code>, <code>ddepth</code> =
-1/<code>CV_64F</code>
</ul>
<p>when <code>ddepth=-1</code>, the destination image will have the same depth
as the source; in the case of 8-bit input images it will result in truncated
derivatives.</p><DD><CODE>dx</CODE> - a dx<DD><CODE>dy</CODE> - a dy<DD><CODE>ksize</CODE> - size of the extended Sobel kernel; it must be 1, 3, 5, or 7.<DD><CODE>scale</CODE> - optional scale factor for the computed derivative values; by
default, no scaling is applied (see "getDerivKernels" for details).<DD><CODE>delta</CODE> - optional delta value that is added to the results prior to
storing them in <code>dst</code>.<DD><CODE>borderType</CODE> - pixel extrapolation method (see "borderInterpolate" for
details).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/filtering.html#sobel">org.opencv.imgproc.Imgproc.Sobel</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>GaussianBlur(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)"><CODE>Core.cartToPolar(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, boolean)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>sepFilter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)"><CODE>Laplacian(org.opencv.core.Mat, org.opencv.core.Mat, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)"><CODE>Scharr(org.opencv.core.Mat, org.opencv.core.Mat, int, int, int, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)"><CODE>filter2D(org.opencv.core.Mat, org.opencv.core.Mat, int, org.opencv.core.Mat, org.opencv.core.Point, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="threshold(org.opencv.core.Mat, org.opencv.core.Mat, double, double, int)"><!-- --></A><H3>
threshold</H3>
<PRE>
public static double <B>threshold</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
double thresh,
double maxval,
int type)</PRE>
<DL>
<DD><p>Applies a fixed-level threshold to each array element.</p>
<p>The function applies fixed-level thresholding to a single-channel array. The
function is typically used to get a bi-level (binary) image out of a
grayscale image ("compare" could be also used for this purpose) or for
removing a noise, that is, filtering out pixels with too small or too large
values. There are several types of thresholding supported by the function.
They are determined by <code>type</code> :</p>
<ul>
<li> THRESH_BINARY
</ul>
<p><em>dst(x,y) = maxval if src(x,y) > thresh; 0 otherwise</em></p>
<ul>
<li> THRESH_BINARY_INV
</ul>
<p><em>dst(x,y) = 0 if src(x,y) > thresh; maxval otherwise</em></p>
<ul>
<li> THRESH_TRUNC
</ul>
<p><em>dst(x,y) = threshold if src(x,y) > thresh; src(x,y) otherwise</em></p>
<ul>
<li> THRESH_TOZERO
</ul>
<p><em>dst(x,y) = src(x,y) if src(x,y) > thresh; 0 otherwise</em></p>
<ul>
<li> THRESH_TOZERO_INV
</ul>
<p><em>dst(x,y) = 0 if src(x,y) > thresh; src(x,y) otherwise</em></p>
<p>Also, the special value <code>THRESH_OTSU</code> may be combined with one of
the above values. In this case, the function determines the optimal threshold
value using the Otsu's algorithm and uses it instead of the specified
<code>thresh</code>.
The function returns the computed threshold value.
Currently, the Otsu's method is implemented only for 8-bit images.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input array (single-channel, 8-bit or 32-bit floating point).<DD><CODE>dst</CODE> - output array of the same size and type as <code>src</code>.<DD><CODE>thresh</CODE> - threshold value.<DD><CODE>maxval</CODE> - maximum value to use with the <code>THRESH_BINARY</code> and
<code>THRESH_BINARY_INV</code> thresholding types.<DD><CODE>type</CODE> - thresholding type (see the details below).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#threshold">org.opencv.imgproc.Imgproc.threshold</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int, org.opencv.core.Point)"><CODE>findContours(org.opencv.core.Mat, java.util.List<org.opencv.core.MatOfPoint>, org.opencv.core.Mat, int, int, org.opencv.core.Point)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#max(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.max(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#adaptiveThreshold(org.opencv.core.Mat, org.opencv.core.Mat, double, int, int, int, double)"><CODE>adaptiveThreshold(org.opencv.core.Mat, org.opencv.core.Mat, double, int, int, int, double)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#compare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)"><CODE>Core.compare(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#min(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.min(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
undistort</H3>
<PRE>
public static void <B>undistort</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs)</PRE>
<DL>
<DD><p>Transforms an image to compensate for lens distortion.</p>
<p>The function transforms an image to compensate radial and tangential lens
distortion.</p>
<p>The function is simply a combination of "initUndistortRectifyMap" (with unity
<code>R</code>) and "remap" (with bilinear interpolation). See the former
function for details of the transformation being performed.</p>
<p>Those pixels in the destination image, for which there is no correspondent
pixels in the source image, are filled with zeros (black color).</p>
<p>A particular subset of the source image that will be visible in the corrected
image can be regulated by <code>newCameraMatrix</code>. You can use
"getOptimalNewCameraMatrix" to compute the appropriate <code>newCameraMatrix</code>
depending on your requirements.</p>
<p>The camera matrix and the distortion parameters can be determined using
"calibrateCamera". If the resolution of images is different from the
resolution used at the calibration stage, <em>f_x, f_y, c_x</em> and
<em>c_y</em> need to be scaled accordingly, while the distortion coefficients
remain the same.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input (distorted) image.<DD><CODE>dst</CODE> - Output (corrected) image that has the same size and type as
<code>src</code>.<DD><CODE>cameraMatrix</CODE> - Input camera matrix <em>A =
<p>|f_x 0 c_x|
|0 f_y c_y|
|0 0 1|
</em>.</p><DD><CODE>distCoeffs</CODE> - Input vector of distortion coefficients <em>(k_1, k_2, p_1,
p_2[, k_3[, k_4, k_5, k_6]])</em> of 4, 5, or 8 elements. If the vector is
NULL/empty, the zero distortion coefficients are assumed.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#undistort">org.opencv.imgproc.Imgproc.undistort</a></DL>
</DD>
</DL>
<HR>
<A NAME="undistort(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
undistort</H3>
<PRE>
public static void <B>undistort</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> newCameraMatrix)</PRE>
<DL>
<DD><p>Transforms an image to compensate for lens distortion.</p>
<p>The function transforms an image to compensate radial and tangential lens
distortion.</p>
<p>The function is simply a combination of "initUndistortRectifyMap" (with unity
<code>R</code>) and "remap" (with bilinear interpolation). See the former
function for details of the transformation being performed.</p>
<p>Those pixels in the destination image, for which there is no correspondent
pixels in the source image, are filled with zeros (black color).</p>
<p>A particular subset of the source image that will be visible in the corrected
image can be regulated by <code>newCameraMatrix</code>. You can use
"getOptimalNewCameraMatrix" to compute the appropriate <code>newCameraMatrix</code>
depending on your requirements.</p>
<p>The camera matrix and the distortion parameters can be determined using
"calibrateCamera". If the resolution of images is different from the
resolution used at the calibration stage, <em>f_x, f_y, c_x</em> and
<em>c_y</em> need to be scaled accordingly, while the distortion coefficients
remain the same.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Input (distorted) image.<DD><CODE>dst</CODE> - Output (corrected) image that has the same size and type as
<code>src</code>.<DD><CODE>cameraMatrix</CODE> - Input camera matrix <em>A =
<p>|f_x 0 c_x|
|0 f_y c_y|
|0 0 1|
</em>.</p><DD><CODE>distCoeffs</CODE> - Input vector of distortion coefficients <em>(k_1, k_2, p_1,
p_2[, k_3[, k_4, k_5, k_6]])</em> of 4, 5, or 8 elements. If the vector is
NULL/empty, the zero distortion coefficients are assumed.<DD><CODE>newCameraMatrix</CODE> - Camera matrix of the distorted image. By default, it
is the same as <code>cameraMatrix</code> but you may additionally scale and
shift the result by using a different matrix.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#undistort">org.opencv.imgproc.Imgproc.undistort</a></DL>
</DD>
</DL>
<HR>
<A NAME="undistortPoints(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
undistortPoints</H3>
<PRE>
public static void <B>undistortPoints</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> src,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs)</PRE>
<DL>
<DD><p>Computes the ideal point coordinates from the observed point coordinates.</p>
<p>The function is similar to "undistort" and "initUndistortRectifyMap" but it
operates on a sparse set of points instead of a raster image. Also the
function performs a reverse transformation to"projectPoints". In case of a 3D
object, it does not reconstruct its 3D coordinates, but for a planar object,
it does, up to a translation vector, if the proper <code>R</code> is
specified.
<code></p>
<p>// C++ code:</p>
<p>// (u,v) is the input point, (u', v') is the output point</p>
<p>// camera_matrix=[fx 0 cx; 0 fy cy; 0 0 1]</p>
<p>// P=[fx' 0 cx' tx; 0 fy' cy' ty; 0 0 1 tz]</p>
<p>x" = (u - cx)/fx</p>
<p>y" = (v - cy)/fy</p>
<p>(x',y') = undistort(x",y",dist_coeffs)</p>
<p>[X,Y,W]T = R*[x' y' 1]T</p>
<p>x = X/W, y = Y/W</p>
<p>// only performed if P=[fx' 0 cx' [tx]; 0 fy' cy' [ty]; 0 0 1 [tz]] is
specified</p>
<p>u' = x*fx' + cx'</p>
<p>v' = y*fy' + cy',</p>
<p>where <code>undistort()</code> is an approximate iterative algorithm that
estimates the normalized original point coordinates out of the normalized
distorted point coordinates ("normalized" means that the coordinates do not
depend on the camera matrix).
</code></p>
<p>The function can be used for both a stereo camera head or a monocular camera
(when R is empty).</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Observed point coordinates, 1xN or Nx1 2-channel (CV_32FC2 or
CV_64FC2).<DD><CODE>dst</CODE> - Output ideal point coordinates after undistortion and reverse
perspective transformation. If matrix <code>P</code> is identity or omitted,
<code>dst</code> will contain normalized point coordinates.<DD><CODE>cameraMatrix</CODE> - Camera matrix <em>
<p>|f_x 0 c_x|
|0 f_y c_y|
|0 0 1|
</em>.</p><DD><CODE>distCoeffs</CODE> - Input vector of distortion coefficients <em>(k_1, k_2, p_1,
p_2[, k_3[, k_4, k_5, k_6]])</em> of 4, 5, or 8 elements. If the vector is
NULL/empty, the zero distortion coefficients are assumed.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#undistortpoints">org.opencv.imgproc.Imgproc.undistortPoints</a></DL>
</DD>
</DL>
<HR>
<A NAME="undistortPoints(org.opencv.core.MatOfPoint2f, org.opencv.core.MatOfPoint2f, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
undistortPoints</H3>
<PRE>
public static void <B>undistortPoints</B>(<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> src,
<A HREF="../../../org/opencv/core/MatOfPoint2f.html" title="class in org.opencv.core">MatOfPoint2f</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> cameraMatrix,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> distCoeffs,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> R,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> P)</PRE>
<DL>
<DD><p>Computes the ideal point coordinates from the observed point coordinates.</p>
<p>The function is similar to "undistort" and "initUndistortRectifyMap" but it
operates on a sparse set of points instead of a raster image. Also the
function performs a reverse transformation to"projectPoints". In case of a 3D
object, it does not reconstruct its 3D coordinates, but for a planar object,
it does, up to a translation vector, if the proper <code>R</code> is
specified.
<code></p>
<p>// C++ code:</p>
<p>// (u,v) is the input point, (u', v') is the output point</p>
<p>// camera_matrix=[fx 0 cx; 0 fy cy; 0 0 1]</p>
<p>// P=[fx' 0 cx' tx; 0 fy' cy' ty; 0 0 1 tz]</p>
<p>x" = (u - cx)/fx</p>
<p>y" = (v - cy)/fy</p>
<p>(x',y') = undistort(x",y",dist_coeffs)</p>
<p>[X,Y,W]T = R*[x' y' 1]T</p>
<p>x = X/W, y = Y/W</p>
<p>// only performed if P=[fx' 0 cx' [tx]; 0 fy' cy' [ty]; 0 0 1 [tz]] is
specified</p>
<p>u' = x*fx' + cx'</p>
<p>v' = y*fy' + cy',</p>
<p>where <code>undistort()</code> is an approximate iterative algorithm that
estimates the normalized original point coordinates out of the normalized
distorted point coordinates ("normalized" means that the coordinates do not
depend on the camera matrix).
</code></p>
<p>The function can be used for both a stereo camera head or a monocular camera
(when R is empty).</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - Observed point coordinates, 1xN or Nx1 2-channel (CV_32FC2 or
CV_64FC2).<DD><CODE>dst</CODE> - Output ideal point coordinates after undistortion and reverse
perspective transformation. If matrix <code>P</code> is identity or omitted,
<code>dst</code> will contain normalized point coordinates.<DD><CODE>cameraMatrix</CODE> - Camera matrix <em>
<p>|f_x 0 c_x|
|0 f_y c_y|
|0 0 1|
</em>.</p><DD><CODE>distCoeffs</CODE> - Input vector of distortion coefficients <em>(k_1, k_2, p_1,
p_2[, k_3[, k_4, k_5, k_6]])</em> of 4, 5, or 8 elements. If the vector is
NULL/empty, the zero distortion coefficients are assumed.<DD><CODE>R</CODE> - Rectification transformation in the object space (3x3 matrix).
<code>R1</code> or <code>R2</code> computed by "stereoRectify" can be passed
here. If the matrix is empty, the identity transformation is used.<DD><CODE>P</CODE> - New camera matrix (3x3) or new projection matrix (3x4).
<code>P1</code> or <code>P2</code> computed by "stereoRectify" can be passed
here. If the matrix is empty, the identity new camera matrix is used.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#undistortpoints">org.opencv.imgproc.Imgproc.undistortPoints</a></DL>
</DD>
</DL>
<HR>
<A NAME="warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)"><!-- --></A><H3>
warpAffine</H3>
<PRE>
public static void <B>warpAffine</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize)</PRE>
<DL>
<DD><p>Applies an affine transformation to an image.</p>
<p>The function <code>warpAffine</code> transforms the source image using the
specified matrix:</p>
<p><em>dst(x,y) = src(M _11 x + M _12 y + M _13, M _21 x + M _22 y + M _23)</em></p>
<p>when the flag <code>WARP_INVERSE_MAP</code> is set. Otherwise, the
transformation is first inverted with "invertAffineTransform" and then put in
the formula above instead of <code>M</code>.
The function cannot operate in-place.</p>
<p>Note: <code>cvGetQuadrangleSubPix</code> is similar to <code>cvWarpAffine</code>,
but the outliers are extrapolated using replication border mode.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image that has the size <code>dsize</code> and the same
type as <code>src</code>.<DD><CODE>M</CODE> - <em>2x 3</em> transformation matrix.<DD><CODE>dsize</CODE> - size of the output image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#warpaffine">org.opencv.imgproc.Imgproc.warpAffine</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><CODE>getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)"><!-- --></A><H3>
warpAffine</H3>
<PRE>
public static void <B>warpAffine</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags)</PRE>
<DL>
<DD><p>Applies an affine transformation to an image.</p>
<p>The function <code>warpAffine</code> transforms the source image using the
specified matrix:</p>
<p><em>dst(x,y) = src(M _11 x + M _12 y + M _13, M _21 x + M _22 y + M _23)</em></p>
<p>when the flag <code>WARP_INVERSE_MAP</code> is set. Otherwise, the
transformation is first inverted with "invertAffineTransform" and then put in
the formula above instead of <code>M</code>.
The function cannot operate in-place.</p>
<p>Note: <code>cvGetQuadrangleSubPix</code> is similar to <code>cvWarpAffine</code>,
but the outliers are extrapolated using replication border mode.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image that has the size <code>dsize</code> and the same
type as <code>src</code>.<DD><CODE>M</CODE> - <em>2x 3</em> transformation matrix.<DD><CODE>dsize</CODE> - size of the output image.<DD><CODE>flags</CODE> - combination of interpolation methods (see "resize") and the
optional flag <code>WARP_INVERSE_MAP</code> that means that <code>M</code> is
the inverse transformation (<em>dst->src</em>).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#warpaffine">org.opencv.imgproc.Imgproc.warpAffine</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><CODE>getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
warpAffine</H3>
<PRE>
public static void <B>warpAffine</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags,
int borderMode,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</PRE>
<DL>
<DD><p>Applies an affine transformation to an image.</p>
<p>The function <code>warpAffine</code> transforms the source image using the
specified matrix:</p>
<p><em>dst(x,y) = src(M _11 x + M _12 y + M _13, M _21 x + M _22 y + M _23)</em></p>
<p>when the flag <code>WARP_INVERSE_MAP</code> is set. Otherwise, the
transformation is first inverted with "invertAffineTransform" and then put in
the formula above instead of <code>M</code>.
The function cannot operate in-place.</p>
<p>Note: <code>cvGetQuadrangleSubPix</code> is similar to <code>cvWarpAffine</code>,
but the outliers are extrapolated using replication border mode.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image that has the size <code>dsize</code> and the same
type as <code>src</code>.<DD><CODE>M</CODE> - <em>2x 3</em> transformation matrix.<DD><CODE>dsize</CODE> - size of the output image.<DD><CODE>flags</CODE> - combination of interpolation methods (see "resize") and the
optional flag <code>WARP_INVERSE_MAP</code> that means that <code>M</code> is
the inverse transformation (<em>dst->src</em>).<DD><CODE>borderMode</CODE> - pixel extrapolation method (see "borderInterpolate"); when
<code>borderMode=BORDER_TRANSPARENT</code>, it means that the pixels in the
destination image corresponding to the "outliers" in the source image are not
modified by the function.<DD><CODE>borderValue</CODE> - value used in case of a constant border; by default, it is
0.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#warpaffine">org.opencv.imgproc.Imgproc.warpAffine</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><CODE>getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.transform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size)"><!-- --></A><H3>
warpPerspective</H3>
<PRE>
public static void <B>warpPerspective</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize)</PRE>
<DL>
<DD><p>Applies a perspective transformation to an image.</p>
<p>The function <code>warpPerspective</code> transforms the source image using
the specified matrix:</p>
<p><em>dst(x,y) = src((M_11 x + M_12 y + M_13)/(M_(31) x + M_32 y +
M_33),<BR>(M_21 x + M_22 y + M_23)/(M_(31) x + M_32 y + M_33))</em></p>
<p>when the flag <code>WARP_INVERSE_MAP</code> is set. Otherwise, the
transformation is first inverted with "invert" and then put in the formula
above instead of <code>M</code>.
The function cannot operate in-place.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image that has the size <code>dsize</code> and the same
type as <code>src</code>.<DD><CODE>M</CODE> - <em>3x 3</em> transformation matrix.<DD><CODE>dsize</CODE> - size of the output image.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#warpperspective">org.opencv.imgproc.Imgproc.warpPerspective</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><CODE>getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int)"><!-- --></A><H3>
warpPerspective</H3>
<PRE>
public static void <B>warpPerspective</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags)</PRE>
<DL>
<DD><p>Applies a perspective transformation to an image.</p>
<p>The function <code>warpPerspective</code> transforms the source image using
the specified matrix:</p>
<p><em>dst(x,y) = src((M_11 x + M_12 y + M_13)/(M_(31) x + M_32 y +
M_33),<BR>(M_21 x + M_22 y + M_23)/(M_(31) x + M_32 y + M_33))</em></p>
<p>when the flag <code>WARP_INVERSE_MAP</code> is set. Otherwise, the
transformation is first inverted with "invert" and then put in the formula
above instead of <code>M</code>.
The function cannot operate in-place.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image that has the size <code>dsize</code> and the same
type as <code>src</code>.<DD><CODE>M</CODE> - <em>3x 3</em> transformation matrix.<DD><CODE>dsize</CODE> - size of the output image.<DD><CODE>flags</CODE> - combination of interpolation methods (<code>INTER_LINEAR</code>
or <code>INTER_NEAREST</code>) and the optional flag <code>WARP_INVERSE_MAP</code>,
that sets <code>M</code> as the inverse transformation (<em>dst->src</em>).<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#warpperspective">org.opencv.imgproc.Imgproc.warpPerspective</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><CODE>getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="warpPerspective(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><!-- --></A><H3>
warpPerspective</H3>
<PRE>
public static void <B>warpPerspective</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> src,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> dst,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> M,
<A HREF="../../../org/opencv/core/Size.html" title="class in org.opencv.core">Size</A> dsize,
int flags,
int borderMode,
<A HREF="../../../org/opencv/core/Scalar.html" title="class in org.opencv.core">Scalar</A> borderValue)</PRE>
<DL>
<DD><p>Applies a perspective transformation to an image.</p>
<p>The function <code>warpPerspective</code> transforms the source image using
the specified matrix:</p>
<p><em>dst(x,y) = src((M_11 x + M_12 y + M_13)/(M_(31) x + M_32 y +
M_33),<BR>(M_21 x + M_22 y + M_23)/(M_(31) x + M_32 y + M_33))</em></p>
<p>when the flag <code>WARP_INVERSE_MAP</code> is set. Otherwise, the
transformation is first inverted with "invert" and then put in the formula
above instead of <code>M</code>.
The function cannot operate in-place.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>src</CODE> - input image.<DD><CODE>dst</CODE> - output image that has the size <code>dsize</code> and the same
type as <code>src</code>.<DD><CODE>M</CODE> - <em>3x 3</em> transformation matrix.<DD><CODE>dsize</CODE> - size of the output image.<DD><CODE>flags</CODE> - combination of interpolation methods (<code>INTER_LINEAR</code>
or <code>INTER_NEAREST</code>) and the optional flag <code>WARP_INVERSE_MAP</code>,
that sets <code>M</code> as the inverse transformation (<em>dst->src</em>).<DD><CODE>borderMode</CODE> - pixel extrapolation method (<code>BORDER_CONSTANT</code> or
<code>BORDER_REPLICATE</code>).<DD><CODE>borderValue</CODE> - value used in case of a constant border; by default, it
equals 0.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/geometric_transformations.html#warpperspective">org.opencv.imgproc.Imgproc.warpPerspective</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)"><CODE>warpAffine(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)"><CODE>remap(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat, int, int, org.opencv.core.Scalar)</CODE></A>,
<A HREF="../../../org/opencv/core/Core.html#perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)"><CODE>Core.perspectiveTransform(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Mat)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)"><CODE>getRectSubPix(org.opencv.core.Mat, org.opencv.core.Size, org.opencv.core.Point, org.opencv.core.Mat, int)</CODE></A>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)"><CODE>resize(org.opencv.core.Mat, org.opencv.core.Mat, org.opencv.core.Size, double, double, int)</CODE></A></DL>
</DD>
</DL>
<HR>
<A NAME="watershed(org.opencv.core.Mat, org.opencv.core.Mat)"><!-- --></A><H3>
watershed</H3>
<PRE>
public static void <B>watershed</B>(<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> image,
<A HREF="../../../org/opencv/core/Mat.html" title="class in org.opencv.core">Mat</A> markers)</PRE>
<DL>
<DD><p>Performs a marker-based image segmentation using the watershed algorithm.</p>
<p>The function implements one of the variants of watershed, non-parametric
marker-based segmentation algorithm, described in [Meyer92].</p>
<p>Before passing the image to the function, you have to roughly outline the
desired regions in the image <code>markers</code> with positive
(<code>>0</code>) indices. So, every region is represented as one or more
connected components with the pixel values 1, 2, 3, and so on. Such markers
can be retrieved from a binary mask using "findContours" and "drawContours"
(see the <code>watershed.cpp</code> demo). The markers are "seeds" of the
future image regions. All the other pixels in <code>markers</code>, whose
relation to the outlined regions is not known and should be defined by the
algorithm, should be set to 0's. In the function output, each pixel in
markers is set to a value of the "seed" components or to -1 at boundaries
between the regions.</p>
<p>Visual demonstration and usage example of the function can be found in the
OpenCV samples directory (see the <code>watershed.cpp</code> demo).</p>
<p>Note: Any two neighbor connected components are not necessarily separated by
a watershed boundary (-1's pixels); for example, they can touch each other in
the initial marker image passed to the function.</p>
<P>
<DD><DL>
<DT><B>Parameters:</B><DD><CODE>image</CODE> - Input 8-bit 3-channel image.<DD><CODE>markers</CODE> - Input/output 32-bit single-channel image (map) of markers. It
should have the same size as <code>image</code>.<DT><B>See Also:</B><DD><a href="http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#watershed">org.opencv.imgproc.Imgproc.watershed</a>,
<A HREF="../../../org/opencv/imgproc/Imgproc.html#findContours(org.opencv.core.Mat, java.util.List, org.opencv.core.Mat, int, int, org.opencv.core.Point)"><CODE>findContours(org.opencv.core.Mat, java.util.List<org.opencv.core.MatOfPoint>, org.opencv.core.Mat, int, int, org.opencv.core.Point)</CODE></A></DL>
</DD>
</DL>
<!-- ========= END OF CLASS DATA ========= -->
<HR>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<A NAME="navbar_bottom"><!-- --></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_bottom_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
<TR ALIGN="center" VALIGN="top">
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-summary.html"><FONT CLASS="NavBarFont1"><B>Package</B></FONT></A> </TD>
<TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> <FONT CLASS="NavBarFont1Rev"><B>Class</B></FONT> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="package-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../index-all.html"><FONT CLASS="NavBarFont1"><B>Index</B></FONT></A> </TD>
<TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1"> <A HREF="../../../help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A> </TD>
</TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
<a href=http://docs.opencv.org>OpenCV 2.4.3.2 Documentation</a></EM>
</TD>
</TR>
<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
PREV CLASS
<A HREF="../../../org/opencv/imgproc/Moments.html" title="class in org.opencv.imgproc"><B>NEXT CLASS</B></A></FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
<A HREF="../../../index.html?org/opencv/imgproc/Imgproc.html" target="_top"><B>FRAMES</B></A>
<A HREF="Imgproc.html" target="_top"><B>NO FRAMES</B></A>
<SCRIPT type="text/javascript">
<!--
if(window==top) {
document.writeln('<A HREF="../../../allclasses-noframe.html"><B>All Classes</B></A>');
}
//-->
</SCRIPT>
<NOSCRIPT>
<A HREF="../../../allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>
</FONT></TD>
</TR>
<TR>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
SUMMARY: NESTED | <A HREF="#field_summary">FIELD</A> | <A HREF="#constructor_summary">CONSTR</A> | <A HREF="#method_summary">METHOD</A></FONT></TD>
<TD VALIGN="top" CLASS="NavBarCell3"><FONT SIZE="-2">
DETAIL: <A HREF="#field_detail">FIELD</A> | <A HREF="#constructor_detail">CONSTR</A> | <A HREF="#method_detail">METHOD</A></FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<HR>
</BODY>
</HTML>
|
navicore/augie
|
libraries/OpenCV-2.4.3.2-android-sdk/sdk/java/javadoc/org/opencv/imgproc/Imgproc.html
|
HTML
|
apache-2.0
| 797,310
|
/*
* Copyright (c) 2016-2022 GraphDefined GmbH
* This file is part of WWCP OIOI <https://github.com/OpenChargingCloud/WWCP_OIOI>
*
* 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.
*/
#region Usings
using System;
using org.GraphDefined.Vanaheimr.Illias;
using Org.BouncyCastle.Crypto.Parameters;
using org.GraphDefined.WWCP.OIOIv4_x.CPO;
using org.GraphDefined.WWCP.OIOIv4_x;
#endregion
namespace org.GraphDefined.WWCP
{
/// <summary>
/// Extensions methods for the WWCP wrapper for OIOI roaming clients for charging station operators.
/// </summary>
public static class CPOExtensions
{
/// <summary>
/// Create and register a new electric vehicle roaming provider
/// using the OIOI protocol and having the given unique electric
/// vehicle roaming provider identification.
/// </summary>
///
/// <param name="RoamingNetwork">A WWCP roaming network.</param>
/// <param name="Id">The unique identification of the roaming provider.</param>
/// <param name="Name">The offical (multi-language) name of the roaming provider.</param>
///
/// <param name="IncludeChargingStations">Only include the EVSEs matching the given delegate.</param>
/// <param name="ServiceCheckEvery">The service check intervall.</param>
/// <param name="StatusCheckEvery">The status check intervall.</param>
///
/// <param name="DisablePushData">This service can be disabled, e.g. for debugging reasons.</param>
/// <param name="DisablePushStatus">This service can be disabled, e.g. for debugging reasons.</param>
/// <param name="DisableAuthentication">This service can be disabled, e.g. for debugging reasons.</param>
/// <param name="DisableSendChargeDetailRecords">This service can be disabled, e.g. for debugging reasons.</param>
///
/// <param name="OIOIConfigurator">An optional delegate to configure the new OIOI roaming provider after its creation.</param>
/// <param name="Configurator">An optional delegate to configure the new roaming provider after its creation.</param>
public static WWCPCPOAdapter
CreateOIOIv4_x_CPORoamingProvider(this RoamingNetwork RoamingNetwork,
EMPRoamingProvider_Id Id,
I18NString Name,
I18NString Description,
CPORoaming CPORoaming,
OIOIv4_x.CPO.ChargingStation2StationDelegate ChargingStation2Station = null,
OIOIv4_x.CPO.EVSEStatusUpdate2ConnectorStatusUpdateDelegate EVSEStatusUpdate2ConnectorStatusUpdate = null,
OIOIv4_x.CPO.ChargeDetailRecord2SessionDelegate ChargeDetailRecord2Session = null,
OIOIv4_x.CPO.Station2JSONDelegate Station2JSON = null,
OIOIv4_x.CPO.ConnectorStatus2JSONDelegate ConnectorStatus2JSON = null,
OIOIv4_x.CPO.Session2JSONDelegate Session2JSON = null,
IncludeEVSEIdDelegate IncludeEVSEIds = null,
IncludeEVSEDelegate IncludeEVSEs = null,
IncludeChargingStationIdDelegate IncludeChargingStationIds = null,
IncludeChargingStationDelegate IncludeChargingStations = null,
ChargeDetailRecordFilterDelegate ChargeDetailRecordFilter = null,
OIOIv4_x.CPO.CustomOperatorIdMapperDelegate CustomOperatorIdMapper = null,
OIOIv4_x.CPO.CustomEVSEIdMapperDelegate CustomEVSEIdMapper = null,
OIOIv4_x.CPO.CustomConnectorIdMapperDelegate CustomConnectorIdMapper = null,
TimeSpan? ServiceCheckEvery = null,
TimeSpan? StatusCheckEvery = null,
TimeSpan? CDRCheckEvery = null,
Boolean DisablePushData = false,
Boolean DisablePushStatus = false,
Boolean DisableAuthentication = false,
Boolean DisableSendChargeDetailRecords = false,
Action<WWCPCPOAdapter> OIOIConfigurator = null,
Action<IEMPRoamingProvider> Configurator = null,
String EllipticCurve = "P-256",
ECPrivateKeyParameters PrivateKey = null,
PublicKeyCertificates PublicKeyCertificates = null)
{
#region Initial checks
if (RoamingNetwork == null)
throw new ArgumentNullException(nameof(RoamingNetwork), "The given roaming network must not be null!");
if (Id == null)
throw new ArgumentNullException(nameof(Id), "The given unique roaming provider identification must not be null!");
if (Name.IsNullOrEmpty())
throw new ArgumentNullException(nameof(Name), "The given roaming provider name must not be null or empty!");
if (CPORoaming is null)
throw new ArgumentNullException(nameof(CPORoaming), "The given CPO roaming must not be null!");
#endregion
var NewRoamingProvider = new WWCPCPOAdapter(Id,
Name,
Description,
RoamingNetwork,
CPORoaming,
ChargingStation2Station,
EVSEStatusUpdate2ConnectorStatusUpdate,
ChargeDetailRecord2Session,
Station2JSON,
ConnectorStatus2JSON,
Session2JSON,
IncludeEVSEIds,
IncludeEVSEs,
IncludeChargingStationIds,
IncludeChargingStations,
ChargeDetailRecordFilter,
CustomOperatorIdMapper,
CustomEVSEIdMapper,
CustomConnectorIdMapper,
ServiceCheckEvery,
StatusCheckEvery,
CDRCheckEvery,
DisablePushData,
DisablePushStatus,
DisableAuthentication,
DisableSendChargeDetailRecords,
EllipticCurve,
PrivateKey,
PublicKeyCertificates);
OIOIConfigurator?.Invoke(NewRoamingProvider);
return RoamingNetwork.
CreateNewRoamingProvider(NewRoamingProvider,
Configurator) as WWCPCPOAdapter;
}
}
}
|
OpenChargingCloud/WWCP_OIOI
|
WWCP_OIOIv4.x_Adapter/CPO/CPOExtentions.cs
|
C#
|
apache-2.0
| 10,737
|
Scala Thrift Type Provider
============================
###Usage:
@fromSchema("myThrift.thrift") object ChatIDL
val msg = ChatIDL.Message("Hello")
object MyImpl extends ChatIDL.Communication {
def ping = logPingReceived()
def join(userId: ChatIDL.ID)
}
###More elaborate example
Given this thrift file:
struct Point {
1: double x
}
struct Elem {
1: i32 x
}
struct Missing {
1: bool y
2: list<string> aa
3: Elem i
4: set<bool> bb
5: map<string, string> cc
}
union Thing {
1: Point a
2: Elem b
3: Missing c
}
union OtherThig {
1: Elem b
2: string c
3: Missing d
}
service Heartbeet {
string ping(1: string greet, 2: Thing b)
}
You could use the type provider like this:
object MyApp extends App {
import typeproviders.rdfs.public._
@fromSchema("/dctype.rdf") object dct
import dct._
val a = Point(4)
val b = Elem(3)
val c = Missing(true,List("allo"), Elem(4), Set(true), Map("hey" -> "you"))
println(a)
println(b)
println(a.x)
object MyImpl extends Heartbeet {
def ping(greet: String, c: Thing): String = "greetings!"
}
val h: Heartbeet = MyImpl
h.ping("hello", Thing.a(Point(4)))
}
|
jedesah/thrift-scala-type-provider
|
README.markdown
|
Markdown
|
apache-2.0
| 1,523
|
package com.inn.trusthings.model.types;
/*
* #%L
* trusthings-model
* %%
* Copyright (C) 2015 COMPOSE project
* %%
* 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.
* #L%
*/
import com.hp.hpl.jena.datatypes.BaseDatatype;
import com.hp.hpl.jena.datatypes.RDFDatatype;
public class USDLSecExpression extends BaseDatatype{
public USDLSecExpression(String uri) {
super(uri);
}
public static final String theTypeURI = "http://www.compose-project.eu/ns/web-of-things/security/profiles#USDLSecType";
public static final RDFDatatype TYPE = new USDLSecExpression(theTypeURI);
@Override
public String getURI() {
return super.getURI();
}
}
|
vujasm/trusthings-compose
|
trusthings-model/src/main/java/com/inn/trusthings/model/types/USDLSecExpression.java
|
Java
|
apache-2.0
| 1,183
|
-- Licensed to the Apache Software Foundation (ASF) under one or more
-- contributor license agreements. See the NOTICE file distributed with
-- this work for additional information regarding copyright ownership.
-- The ASF licenses this file to You 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.
create user sqooptest identified by 12345 default tablespace users;
alter user sqooptest quota unlimited on users;
grant create session to sqooptest;
grant create procedure to sqooptest;
grant alter session to sqooptest;
grant select on v_$instance to sqooptest;
grant select on dba_tables to sqooptest;
grant select on dba_tab_columns to sqooptest;
grant select on dba_objects to sqooptest;
grant select on dba_extents to sqooptest;
grant select on dba_segments to sqooptest;
grant select on v_$database to sqooptest;
grant select on v_$parameter to sqooptest;
grant select on v_$session to sqooptest;
grant select on v_$sql to sqooptest;
grant create table to sqooptest;
grant select on dba_tab_partitions to sqooptest;
grant select on dba_tab_subpartitions to sqooptest;
grant select on dba_indexes to sqooptest;
grant select on dba_ind_columns to sqooptest;
grant select any table to sqooptest;
grant create any table to sqooptest;
grant insert any table to sqooptest;
grant alter any table to sqooptest;
create user sqooptest2 identified by ABCDEF default tablespace users;
alter user sqooptest2 quota unlimited on users;
grant create session to sqooptest2;
grant create procedure to sqooptest2;
grant alter session to sqooptest2;
grant select on v_$instance to sqooptest2;
grant select on dba_tables to sqooptest2;
grant select on dba_tab_columns to sqooptest2;
grant select on dba_objects to sqooptest2;
grant select on dba_extents to sqooptest2;
grant select on dba_segments to sqooptest2;
grant select on v_$database to sqooptest2;
grant select on v_$parameter to sqooptest2;
grant select on v_$session to sqooptest2;
grant select on v_$sql to sqooptest2;
grant create table to sqooptest2;
grant select on dba_tab_partitions to sqooptest2;
grant select on dba_tab_subpartitions to sqooptest2;
grant select on dba_indexes to sqooptest2;
grant select on dba_ind_columns to sqooptest2;
grant select any table to sqooptest2;
grant create any table to sqooptest2;
grant insert any table to sqooptest2;
grant alter any table to sqooptest2;
|
sahilsehgal81/Sqoop
|
src/test/oraoop/create_users.sql
|
SQL
|
apache-2.0
| 2,840
|
package ht.pq.khanh.util;
import android.content.Context;
import android.support.design.widget.CoordinatorLayout;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.widget.Toolbar;
import android.util.AttributeSet;
import android.view.View;
/**
* Created by khanhpq on 10/2/17.
*/
public class ScrollFABBehaviour extends CoordinatorLayout.Behavior<FloatingActionButton> {
private int toolbarHeight;
private static boolean scrolledUp = false;
private static boolean scrolledDown = false;
public ScrollFABBehaviour(Context context, AttributeSet attributeSet) {
super(context, attributeSet);
this.toolbarHeight = Common.INSTANCE.getToolbarHeight(context);
}
@Override
public boolean layoutDependsOn(CoordinatorLayout parent, FloatingActionButton child, View dependency) {
return (dependency instanceof Snackbar.SnackbarLayout) || (dependency instanceof Toolbar);
// return (dependency instanceof Snackbar.SnackbarLayout);
}
@Override
public boolean onDependentViewChanged(CoordinatorLayout parent, final FloatingActionButton child, View dependency) {
if (dependency instanceof Snackbar.SnackbarLayout) {
float finalVal = (float) parent.getHeight() - dependency.getY();
child.setTranslationY(-finalVal);
}
//
// if(dependency instanceof RecyclerView){
// RecyclerView view = (RecyclerView)dependency;
// CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams)child.getLayoutParams();
// int fabBottomMargin = lp.bottomMargin;
// final int distanceToScroll = child.getHeight() + fabBottomMargin;
//
// final RecyclerView.LayoutManager rlp = (RecyclerView.LayoutManager)view.getLayoutManager();
// Log.d("OskarSchindler", "Height: "+rlp.getHeight());
//
//
//
// }
if (dependency instanceof Toolbar) {
CoordinatorLayout.LayoutParams lp = (CoordinatorLayout.LayoutParams) child.getLayoutParams();
int fabBottomMargin = lp.bottomMargin;
int distanceToScroll = child.getHeight() + fabBottomMargin;
float finalVal = dependency.getY() / (float) toolbarHeight;
float distFinal = -distanceToScroll * finalVal;
child.setTranslationY(distFinal);
}
return true;
}
}
|
khanhpq29/My-Task
|
app/src/main/java/ht/pq/khanh/util/ScrollFABBehaviour.java
|
Java
|
apache-2.0
| 2,446
|
// [[[[INFO>
// Copyright 2015 Epicycle (http://epicycle.org, https://github.com/open-epicycle)
//
// 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.
//
// For more information check https://github.com/open-epicycle/Epicycle.Photogrammetry-cs
// ]]]]
using Epicycle.Commons.Collections;
using Epicycle.Math.Geometry;
using System.Collections.Generic;
namespace Epicycle.Photogrammetry
{
public static class ImageModelUtils
{
public static Ray3? Ray(this IImageModel @this, Vector2 imagePoint)
{
var los = @this.LineOfSight(imagePoint);
if (los == null)
{
return null;
}
else
{
return new Ray3(@this.OpticalCenter, los);
}
}
public static bool IsVisibleOn(this Vector2 @this, IImageModel model)
{
return model.Domain.Contains(@this);
}
public static bool IsVisibleOn(this Vector2? @this, IImageModel model)
{
return @this.HasValue && @this.Value.IsVisibleOn(model);
}
public static bool IsVisibleOn(this Vector3 @this, IImageModel model)
{
return model.Project(@this).IsVisibleOn(model);
}
public static Vector2? StrictlyProject(this IImageModel @this, Vector3 point)
{
var projection = @this.Project(point);
if (projection.IsVisibleOn(@this))
{
return projection;
}
else
{
return null;
}
}
public static Vector3 ReverseProject(this IImageModel @this, Vector2 point, Plane plane)
{
var ray = @this.Ray(point);
if (ray == null)
{
return null;
}
else
{
return ray.Value.Intersect(plane);
}
}
public static IEnumerable<Plane> VisibilityBoundaries(this IImageModel @this)
{
var vertices = @this.Domain.Vertices;
for (var i = 0; i < 4; i++)
{
var los1 = @this.LineOfSight(vertices[i]);
var los2 = @this.LineOfSight(vertices.ElementAtCyclic(i + 1));
yield return Plane.Parametric(@this.OpticalCenter, los2, los1);
}
}
}
}
|
open-epicycle/Epicycle.Photogrammetry-cs
|
projects/Epicycle.Photogrammetry_cs/ImageModelUtils.cs
|
C#
|
apache-2.0
| 2,910
|
package disk_test
import (
"errors"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/ginkgo"
. "github.com/cloudfoundry/bosh-init/internal/github.com/onsi/gomega"
. "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-agent/platform/disk"
fakesys "github.com/cloudfoundry/bosh-init/internal/github.com/cloudfoundry/bosh-utils/system/fakes"
)
var _ = Describe("procMountsSearcher", func() {
var (
fs *fakesys.FakeFileSystem
searcher MountsSearcher
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
searcher = NewProcMountsSearcher(fs)
})
Describe("SearchMounts", func() {
Context("when reading /proc/mounts succeeds", func() {
It("returns parsed mount information", func() {
fs.WriteFileString(
"/proc/mounts",
`none /run/lock tmpfs rw,nosuid,nodev,noexec,relatime,size=5120k 0 0
none /run/shm tmpfs rw,nosuid,nodev,relatime 0 0
/dev/sda1 /boot ext2 rw,relatime,errors=continue 0 0
none /tmp/warden/cgroup tmpfs rw,relatime 0 0`,
)
mounts, err := searcher.SearchMounts()
Expect(err).ToNot(HaveOccurred())
Expect(mounts).To(Equal([]Mount{
Mount{PartitionPath: "none", MountPoint: "/run/lock"},
Mount{PartitionPath: "none", MountPoint: "/run/shm"},
Mount{PartitionPath: "/dev/sda1", MountPoint: "/boot"},
Mount{PartitionPath: "none", MountPoint: "/tmp/warden/cgroup"},
}))
})
It("ignores empty lines", func() {
fs.WriteFileString("/proc/mounts", `
none /run/shm tmpfs rw,nosuid,nodev,relatime 0 0
/dev/sda1 /boot ext2 rw,relatime,errors=continue 0 0
`,
)
mounts, err := searcher.SearchMounts()
Expect(err).ToNot(HaveOccurred())
Expect(mounts).To(Equal([]Mount{
Mount{PartitionPath: "none", MountPoint: "/run/shm"},
Mount{PartitionPath: "/dev/sda1", MountPoint: "/boot"},
}))
})
})
Context("when reading /proc/mounts fails", func() {
It("returns error", func() {
fs.WriteFileString("/proc/mounts", "")
fs.ReadFileError = errors.New("fake-read-err")
mounts, err := searcher.SearchMounts()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-read-err"))
Expect(mounts).To(BeEmpty())
})
})
})
})
|
allomov/bosh-init
|
internal/github.com/cloudfoundry/bosh-agent/platform/disk/proc_mounts_searcher_test.go
|
GO
|
apache-2.0
| 2,228
|
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [http://neo4j.com]
*
* This file is part of Neo4j.
*
* 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.
*/
package org.neo4j.docs.driver;
// tag::config-connection-pool-import[]
import java.util.concurrent.TimeUnit;
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Config;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;
import org.neo4j.driver.Result;
// end::config-connection-pool-import[]
public class ConfigConnectionPoolExample implements AutoCloseable
{
private final Driver driver;
// tag::config-connection-pool[]
public ConfigConnectionPoolExample( String uri, String user, String password )
{
Config config = Config.builder()
.withMaxConnectionLifetime( 30, TimeUnit.MINUTES )
.withMaxConnectionPoolSize( 50 )
.withConnectionAcquisitionTimeout( 2, TimeUnit.MINUTES )
.build();
driver = GraphDatabase.driver( uri, AuthTokens.basic( user, password ), config );
}
// end::config-connection-pool[]
@Override
public void close() throws Exception
{
driver.close();
}
public boolean canConnect()
{
Result result = driver.session().run( "RETURN 1" );
return result.single().get( 0 ).asInt() == 1;
}
}
|
neo4j/neo4j-java-driver
|
examples/src/main/java/org/neo4j/docs/driver/ConfigConnectionPoolExample.java
|
Java
|
apache-2.0
| 1,855
|
# Carex parryana subsp. idahoa SUBSPECIES
#### Status
SYNONYM
#### According to
The Catalogue of Life, 3rd January 2011
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Liliopsida/Poales/Cyperaceae/Carex/Carex idahoa/ Syn. Carex parryana idahoa/README.md
|
Markdown
|
apache-2.0
| 188
|
# Rhexia viminea D.Don SPECIES
#### Status
ACCEPTED
#### According to
International Plant Names Index
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Magnoliopsida/Myrtales/Melastomataceae/Rhexia/Rhexia viminea/README.md
|
Markdown
|
apache-2.0
| 170
|
# Claoxylon rubescens var. cumingianum VARIETY
#### Status
SYNONYM
#### According to
The Catalogue of Life, 3rd January 2011
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Magnoliopsida/Malpighiales/Euphorbiaceae/Claoxylon/Claoxylon albicans/ Syn. Claoxylon rubescens cumingianum/README.md
|
Markdown
|
apache-2.0
| 193
|
# Cooperia brasiliensis Traub SPECIES
#### Status
SYNONYM
#### According to
The Catalogue of Life, 3rd January 2011
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Liliopsida/Asparagales/Amaryllidaceae/Zephyranthes/Zephyranthes chlorosolen/ Syn. Cooperia brasiliensis/README.md
|
Markdown
|
apache-2.0
| 184
|
# Nepenthes ×mastersiana cv. SPECIES
#### Status
ACCEPTED
#### According to
GRIN Taxonomy for Plants
#### Published in
Gard. Chron. ser. 2, 16:748, fig. 148. 1881
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Magnoliopsida/Caryophyllales/Nepenthaceae/Nepenthes/Nepenthes mastersiana cv./README.md
|
Markdown
|
apache-2.0
| 209
|
# Erysiphe labiatarum f. galeopsidis (Desm.) Jacz. FORM
#### Status
ACCEPTED
#### According to
Index Fungorum
#### Published in
Taschenbestimmb. f. Pilze 2, Erysiphaceen 158 (1926)
#### Original name
Erysiphe communis var. ptilomyiae Desm.
### Remarks
null
|
mdoering/backbone
|
life/Fungi/Ascomycota/Leotiomycetes/Erysiphales/Erysiphaceae/Erysiphe/Erysiphe labiatarum/Erysiphe labiatarum galeopsidis/README.md
|
Markdown
|
apache-2.0
| 261
|
# Andreaea viridis C. Müller in Neumayer, 1890 SPECIES
#### Status
ACCEPTED
#### According to
The Catalogue of Life, 3rd January 2011
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Bryophyta/Andreaeopsida/Andreaeales/Andreaeaceae/Andreaea/Andreaea viridis/README.md
|
Markdown
|
apache-2.0
| 203
|
using System;
using JetBrains.Diagnostics;
using JetBrains.Diagnostics.Internal;
using JetBrains.Lifetimes;
namespace JetBrains.Rider.Unity.Editor.Logger
{
public static class LogInitializer
{
public static void InitLog(LoggingLevel selectedLoggingLevel)
{
if (selectedLoggingLevel > LoggingLevel.OFF)
{
var lifetimeDefinition = Lifetime.Eternal.CreateNested();
var lifetime = lifetimeDefinition.Lifetime;
AppDomain.CurrentDomain.DomainUnload += (sender, args) =>
{
lifetimeDefinition.Terminate();
};
var fileLogFactory = Log.CreateFileLogFactory(lifetime, PluginEntryPoint.LogPath, true, selectedLoggingLevel);
fileLogFactory.Handlers += message =>
{
if (lifetime.IsAlive && (message.Level == LoggingLevel.ERROR || message.Level == LoggingLevel.FATAL))
MainThreadDispatcher.Instance.Queue(() =>
{
if (lifetime.IsAlive)
UnityEngine.Debug.LogError(message.FormattedMessage);
});
};
Log.DefaultFactory = fileLogFactory;
}
else
Log.DefaultFactory = new SingletonLogFactory(NullLog.Instance); // use profiler in Unity - this is faster than leaving TextWriterLogFactory with LoggingLevel OFF
}
}
}
|
JetBrains/resharper-unity
|
unity/EditorPlugin/Logger/LogInitializer.cs
|
C#
|
apache-2.0
| 1,542
|
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated from a template.
//
// Manual changes to this file may cause unexpected behavior in your application.
// Manual changes to this file will be overwritten if the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace Framework.DataAccess
{
using System;
using System.Collections.Generic;
public partial class CustomerInfo
{
public override int ID { get; set; }
public override System.Guid Key { get; set; }
public string FirstName { get; set; }
public string MiddleName { get; set; }
public string LastName { get; set; }
public System.DateTime BirthDate { get; set; }
public int GenderID { get; set; }
public System.Guid CustomerTypeKey { get; set; }
public override int ActivityContextID { get; set; }
public override System.DateTime CreatedDate { get; set; }
public override System.DateTime ModifiedDate { get; set; }
}
}
|
pubcrede/Framework-for-WebAPI
|
src/Framework.DataAccess/CustomerInfo.cs
|
C#
|
apache-2.0
| 1,154
|
// Copyright 2018 The Grafeas Authors. 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.
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.27.1
// protoc v3.13.0
// source: vulnerability.proto
package vulnerability_go_proto
import (
timestamp "github.com/golang/protobuf/ptypes/timestamp"
common_go_proto "github.com/grafeas/grafeas/proto/v1beta1/common_go_proto"
cvss_go_proto "github.com/grafeas/grafeas/proto/v1beta1/cvss_go_proto"
package_go_proto "github.com/grafeas/grafeas/proto/v1beta1/package_go_proto"
_ "google.golang.org/genproto/googleapis/api/annotations"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Note provider-assigned severity/impact ranking.
type Severity int32
const (
// Unknown.
Severity_SEVERITY_UNSPECIFIED Severity = 0
// Minimal severity.
Severity_MINIMAL Severity = 1
// Low severity.
Severity_LOW Severity = 2
// Medium severity.
Severity_MEDIUM Severity = 3
// High severity.
Severity_HIGH Severity = 4
// Critical severity.
Severity_CRITICAL Severity = 5
)
// Enum value maps for Severity.
var (
Severity_name = map[int32]string{
0: "SEVERITY_UNSPECIFIED",
1: "MINIMAL",
2: "LOW",
3: "MEDIUM",
4: "HIGH",
5: "CRITICAL",
}
Severity_value = map[string]int32{
"SEVERITY_UNSPECIFIED": 0,
"MINIMAL": 1,
"LOW": 2,
"MEDIUM": 3,
"HIGH": 4,
"CRITICAL": 5,
}
)
func (x Severity) Enum() *Severity {
p := new(Severity)
*p = x
return p
}
func (x Severity) String() string {
return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}
func (Severity) Descriptor() protoreflect.EnumDescriptor {
return file_vulnerability_proto_enumTypes[0].Descriptor()
}
func (Severity) Type() protoreflect.EnumType {
return &file_vulnerability_proto_enumTypes[0]
}
func (x Severity) Number() protoreflect.EnumNumber {
return protoreflect.EnumNumber(x)
}
// Deprecated: Use Severity.Descriptor instead.
func (Severity) EnumDescriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{0}
}
// Vulnerability provides metadata about a security vulnerability in a Note.
type Vulnerability struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The CVSS score for this vulnerability.
CvssScore float32 `protobuf:"fixed32,1,opt,name=cvss_score,json=cvssScore,proto3" json:"cvss_score,omitempty"`
// Note provider assigned impact of the vulnerability.
Severity Severity `protobuf:"varint,2,opt,name=severity,proto3,enum=grafeas.v1beta1.vulnerability.Severity" json:"severity,omitempty"`
// All information about the package to specifically identify this
// vulnerability. One entry per (version range and cpe_uri) the package
// vulnerability has manifested in.
Details []*Vulnerability_Detail `protobuf:"bytes,3,rep,name=details,proto3" json:"details,omitempty"`
// The full description of the CVSS for version 3.
CvssV3 *cvss_go_proto.CVSS `protobuf:"bytes,4,opt,name=cvss_v3,json=cvssV3,proto3" json:"cvss_v3,omitempty"`
// Windows details get their own format because the information format and
// model don't match a normal detail. Specifically Windows updates are done as
// patches, thus Windows vulnerabilities really are a missing package, rather
// than a package being at an incorrect version.
WindowsDetails []*Vulnerability_WindowsDetail `protobuf:"bytes,5,rep,name=windows_details,json=windowsDetails,proto3" json:"windows_details,omitempty"`
// The time this information was last changed at the source. This is an
// upstream timestamp from the underlying information source - e.g. Ubuntu
// security tracker.
SourceUpdateTime *timestamp.Timestamp `protobuf:"bytes,6,opt,name=source_update_time,json=sourceUpdateTime,proto3" json:"source_update_time,omitempty"`
// The full description of the CVSS for version 2.
CvssV2 *cvss_go_proto.CVSS `protobuf:"bytes,7,opt,name=cvss_v2,json=cvssV2,proto3" json:"cvss_v2,omitempty"`
// A list of CWE for this vulnerability.
// For details, see: https://cwe.mitre.org/index.html
Cwe []string `protobuf:"bytes,8,rep,name=cwe,proto3" json:"cwe,omitempty"`
}
func (x *Vulnerability) Reset() {
*x = Vulnerability{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Vulnerability) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Vulnerability) ProtoMessage() {}
func (x *Vulnerability) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Vulnerability.ProtoReflect.Descriptor instead.
func (*Vulnerability) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{0}
}
func (x *Vulnerability) GetCvssScore() float32 {
if x != nil {
return x.CvssScore
}
return 0
}
func (x *Vulnerability) GetSeverity() Severity {
if x != nil {
return x.Severity
}
return Severity_SEVERITY_UNSPECIFIED
}
func (x *Vulnerability) GetDetails() []*Vulnerability_Detail {
if x != nil {
return x.Details
}
return nil
}
func (x *Vulnerability) GetCvssV3() *cvss_go_proto.CVSS {
if x != nil {
return x.CvssV3
}
return nil
}
func (x *Vulnerability) GetWindowsDetails() []*Vulnerability_WindowsDetail {
if x != nil {
return x.WindowsDetails
}
return nil
}
func (x *Vulnerability) GetSourceUpdateTime() *timestamp.Timestamp {
if x != nil {
return x.SourceUpdateTime
}
return nil
}
func (x *Vulnerability) GetCvssV2() *cvss_go_proto.CVSS {
if x != nil {
return x.CvssV2
}
return nil
}
func (x *Vulnerability) GetCwe() []string {
if x != nil {
return x.Cwe
}
return nil
}
// Details of a vulnerability Occurrence.
type Details struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The type of package; whether native or non native(ruby gems, node.js
// packages etc)
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
// Output only. The note provider assigned Severity of the vulnerability.
Severity Severity `protobuf:"varint,2,opt,name=severity,proto3,enum=grafeas.v1beta1.vulnerability.Severity" json:"severity,omitempty"`
// Output only. The CVSS score of this vulnerability. CVSS score is on a
// scale of 0-10 where 0 indicates low severity and 10 indicates high
// severity.
CvssScore float32 `protobuf:"fixed32,3,opt,name=cvss_score,json=cvssScore,proto3" json:"cvss_score,omitempty"`
// Required. The set of affected locations and their fixes (if available)
// within the associated resource.
PackageIssue []*PackageIssue `protobuf:"bytes,4,rep,name=package_issue,json=packageIssue,proto3" json:"package_issue,omitempty"`
// Output only. A one sentence description of this vulnerability.
ShortDescription string `protobuf:"bytes,5,opt,name=short_description,json=shortDescription,proto3" json:"short_description,omitempty"`
// Output only. A detailed description of this vulnerability.
LongDescription string `protobuf:"bytes,6,opt,name=long_description,json=longDescription,proto3" json:"long_description,omitempty"`
// Output only. URLs related to this vulnerability.
RelatedUrls []*common_go_proto.RelatedUrl `protobuf:"bytes,7,rep,name=related_urls,json=relatedUrls,proto3" json:"related_urls,omitempty"`
// The distro assigned severity for this vulnerability when it is
// available, and note provider assigned severity when distro has not yet
// assigned a severity for this vulnerability.
//
// When there are multiple PackageIssues for this vulnerability, they can have
// different effective severities because some might be provided by the distro
// while others are provided by the language ecosystem for a language pack.
// For this reason, it is advised to use the effective severity on the
// PackageIssue level. In the case where multiple PackageIssues have differing
// effective severities, this field should be the highest severity for any of
// the PackageIssues.
EffectiveSeverity Severity `protobuf:"varint,8,opt,name=effective_severity,json=effectiveSeverity,proto3,enum=grafeas.v1beta1.vulnerability.Severity" json:"effective_severity,omitempty"`
}
func (x *Details) Reset() {
*x = Details{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Details) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Details) ProtoMessage() {}
func (x *Details) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Details.ProtoReflect.Descriptor instead.
func (*Details) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{1}
}
func (x *Details) GetType() string {
if x != nil {
return x.Type
}
return ""
}
func (x *Details) GetSeverity() Severity {
if x != nil {
return x.Severity
}
return Severity_SEVERITY_UNSPECIFIED
}
func (x *Details) GetCvssScore() float32 {
if x != nil {
return x.CvssScore
}
return 0
}
func (x *Details) GetPackageIssue() []*PackageIssue {
if x != nil {
return x.PackageIssue
}
return nil
}
func (x *Details) GetShortDescription() string {
if x != nil {
return x.ShortDescription
}
return ""
}
func (x *Details) GetLongDescription() string {
if x != nil {
return x.LongDescription
}
return ""
}
func (x *Details) GetRelatedUrls() []*common_go_proto.RelatedUrl {
if x != nil {
return x.RelatedUrls
}
return nil
}
func (x *Details) GetEffectiveSeverity() Severity {
if x != nil {
return x.EffectiveSeverity
}
return Severity_SEVERITY_UNSPECIFIED
}
// This message wraps a location affected by a vulnerability and its
// associated fix (if one is available).
type PackageIssue struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The location of the vulnerability.
AffectedLocation *VulnerabilityLocation `protobuf:"bytes,1,opt,name=affected_location,json=affectedLocation,proto3" json:"affected_location,omitempty"`
// The location of the available fix for vulnerability.
FixedLocation *VulnerabilityLocation `protobuf:"bytes,2,opt,name=fixed_location,json=fixedLocation,proto3" json:"fixed_location,omitempty"`
// Deprecated, use Details.effective_severity instead
// The severity (e.g., distro assigned severity) for this vulnerability.
SeverityName string `protobuf:"bytes,3,opt,name=severity_name,json=severityName,proto3" json:"severity_name,omitempty"`
// The type of package (e.g. OS, MAVEN, GO).
PackageType string `protobuf:"bytes,4,opt,name=package_type,json=packageType,proto3" json:"package_type,omitempty"`
// The distro or language system assigned severity for this vulnerability
// when that is available and note provider assigned severity when it is not
// available.
EffectiveSeverity Severity `protobuf:"varint,5,opt,name=effective_severity,json=effectiveSeverity,proto3,enum=grafeas.v1beta1.vulnerability.Severity" json:"effective_severity,omitempty"`
}
func (x *PackageIssue) Reset() {
*x = PackageIssue{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *PackageIssue) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*PackageIssue) ProtoMessage() {}
func (x *PackageIssue) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use PackageIssue.ProtoReflect.Descriptor instead.
func (*PackageIssue) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{2}
}
func (x *PackageIssue) GetAffectedLocation() *VulnerabilityLocation {
if x != nil {
return x.AffectedLocation
}
return nil
}
func (x *PackageIssue) GetFixedLocation() *VulnerabilityLocation {
if x != nil {
return x.FixedLocation
}
return nil
}
func (x *PackageIssue) GetSeverityName() string {
if x != nil {
return x.SeverityName
}
return ""
}
func (x *PackageIssue) GetPackageType() string {
if x != nil {
return x.PackageType
}
return ""
}
func (x *PackageIssue) GetEffectiveSeverity() Severity {
if x != nil {
return x.EffectiveSeverity
}
return Severity_SEVERITY_UNSPECIFIED
}
// The location of the vulnerability.
type VulnerabilityLocation struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The CPE URI in [cpe format](https://cpe.mitre.org/specification/)
// format. Examples include distro or storage location for vulnerable jar.
CpeUri string `protobuf:"bytes,1,opt,name=cpe_uri,json=cpeUri,proto3" json:"cpe_uri,omitempty"`
// Required. The package being described.
Package string `protobuf:"bytes,2,opt,name=package,proto3" json:"package,omitempty"`
// Required. The version of the package being described.
Version *package_go_proto.Version `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
}
func (x *VulnerabilityLocation) Reset() {
*x = VulnerabilityLocation{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *VulnerabilityLocation) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*VulnerabilityLocation) ProtoMessage() {}
func (x *VulnerabilityLocation) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use VulnerabilityLocation.ProtoReflect.Descriptor instead.
func (*VulnerabilityLocation) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{3}
}
func (x *VulnerabilityLocation) GetCpeUri() string {
if x != nil {
return x.CpeUri
}
return ""
}
func (x *VulnerabilityLocation) GetPackage() string {
if x != nil {
return x.Package
}
return ""
}
func (x *VulnerabilityLocation) GetVersion() *package_go_proto.Version {
if x != nil {
return x.Version
}
return nil
}
// Identifies all appearances of this vulnerability in the package for a
// specific distro/location. For example: glibc in
// cpe:/o:debian:debian_linux:8 for versions 2.1 - 2.2
type Vulnerability_Detail struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The CPE URI in
// [cpe format](https://cpe.mitre.org/specification/) in which the
// vulnerability manifests. Examples include distro or storage location for
// vulnerable jar.
CpeUri string `protobuf:"bytes,1,opt,name=cpe_uri,json=cpeUri,proto3" json:"cpe_uri,omitempty"`
// Required. The name of the package where the vulnerability was found.
Package string `protobuf:"bytes,2,opt,name=package,proto3" json:"package,omitempty"`
// The min version of the package in which the vulnerability exists.
MinAffectedVersion *package_go_proto.Version `protobuf:"bytes,3,opt,name=min_affected_version,json=minAffectedVersion,proto3" json:"min_affected_version,omitempty"`
// The max version of the package in which the vulnerability exists.
MaxAffectedVersion *package_go_proto.Version `protobuf:"bytes,4,opt,name=max_affected_version,json=maxAffectedVersion,proto3" json:"max_affected_version,omitempty"`
// The severity (eg: distro assigned severity) for this vulnerability.
SeverityName string `protobuf:"bytes,5,opt,name=severity_name,json=severityName,proto3" json:"severity_name,omitempty"`
// A vendor-specific description of this note.
Description string `protobuf:"bytes,6,opt,name=description,proto3" json:"description,omitempty"`
// The fix for this specific package version.
FixedLocation *VulnerabilityLocation `protobuf:"bytes,7,opt,name=fixed_location,json=fixedLocation,proto3" json:"fixed_location,omitempty"`
// The type of package; whether native or non native(ruby gems, node.js
// packages etc).
PackageType string `protobuf:"bytes,8,opt,name=package_type,json=packageType,proto3" json:"package_type,omitempty"`
// Whether this detail is obsolete. Occurrences are expected not to point to
// obsolete details.
IsObsolete bool `protobuf:"varint,9,opt,name=is_obsolete,json=isObsolete,proto3" json:"is_obsolete,omitempty"`
// The time this information was last changed at the source. This is an
// upstream timestamp from the underlying information source - e.g. Ubuntu
// security tracker.
SourceUpdateTime *timestamp.Timestamp `protobuf:"bytes,10,opt,name=source_update_time,json=sourceUpdateTime,proto3" json:"source_update_time,omitempty"`
// The source from which the information in this Detail was obtained.
Source string `protobuf:"bytes,11,opt,name=source,proto3" json:"source,omitempty"`
// The name of the vendor of the product.
Vendor string `protobuf:"bytes,12,opt,name=vendor,proto3" json:"vendor,omitempty"`
}
func (x *Vulnerability_Detail) Reset() {
*x = Vulnerability_Detail{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Vulnerability_Detail) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Vulnerability_Detail) ProtoMessage() {}
func (x *Vulnerability_Detail) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Vulnerability_Detail.ProtoReflect.Descriptor instead.
func (*Vulnerability_Detail) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{0, 0}
}
func (x *Vulnerability_Detail) GetCpeUri() string {
if x != nil {
return x.CpeUri
}
return ""
}
func (x *Vulnerability_Detail) GetPackage() string {
if x != nil {
return x.Package
}
return ""
}
func (x *Vulnerability_Detail) GetMinAffectedVersion() *package_go_proto.Version {
if x != nil {
return x.MinAffectedVersion
}
return nil
}
func (x *Vulnerability_Detail) GetMaxAffectedVersion() *package_go_proto.Version {
if x != nil {
return x.MaxAffectedVersion
}
return nil
}
func (x *Vulnerability_Detail) GetSeverityName() string {
if x != nil {
return x.SeverityName
}
return ""
}
func (x *Vulnerability_Detail) GetDescription() string {
if x != nil {
return x.Description
}
return ""
}
func (x *Vulnerability_Detail) GetFixedLocation() *VulnerabilityLocation {
if x != nil {
return x.FixedLocation
}
return nil
}
func (x *Vulnerability_Detail) GetPackageType() string {
if x != nil {
return x.PackageType
}
return ""
}
func (x *Vulnerability_Detail) GetIsObsolete() bool {
if x != nil {
return x.IsObsolete
}
return false
}
func (x *Vulnerability_Detail) GetSourceUpdateTime() *timestamp.Timestamp {
if x != nil {
return x.SourceUpdateTime
}
return nil
}
func (x *Vulnerability_Detail) GetSource() string {
if x != nil {
return x.Source
}
return ""
}
func (x *Vulnerability_Detail) GetVendor() string {
if x != nil {
return x.Vendor
}
return ""
}
type Vulnerability_WindowsDetail struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// Required. The CPE URI in
// [cpe format](https://cpe.mitre.org/specification/) in which the
// vulnerability manifests. Examples include distro or storage location for
// vulnerable jar.
CpeUri string `protobuf:"bytes,1,opt,name=cpe_uri,json=cpeUri,proto3" json:"cpe_uri,omitempty"`
// Required. The name of the vulnerability.
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
// The description of the vulnerability.
Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
// Required. The names of the KBs which have hotfixes to mitigate this
// vulnerability. Note that there may be multiple hotfixes (and thus
// multiple KBs) that mitigate a given vulnerability. Currently any listed
// kb's presence is considered a fix.
FixingKbs []*Vulnerability_WindowsDetail_KnowledgeBase `protobuf:"bytes,4,rep,name=fixing_kbs,json=fixingKbs,proto3" json:"fixing_kbs,omitempty"`
}
func (x *Vulnerability_WindowsDetail) Reset() {
*x = Vulnerability_WindowsDetail{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Vulnerability_WindowsDetail) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Vulnerability_WindowsDetail) ProtoMessage() {}
func (x *Vulnerability_WindowsDetail) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Vulnerability_WindowsDetail.ProtoReflect.Descriptor instead.
func (*Vulnerability_WindowsDetail) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{0, 1}
}
func (x *Vulnerability_WindowsDetail) GetCpeUri() string {
if x != nil {
return x.CpeUri
}
return ""
}
func (x *Vulnerability_WindowsDetail) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Vulnerability_WindowsDetail) GetDescription() string {
if x != nil {
return x.Description
}
return ""
}
func (x *Vulnerability_WindowsDetail) GetFixingKbs() []*Vulnerability_WindowsDetail_KnowledgeBase {
if x != nil {
return x.FixingKbs
}
return nil
}
type Vulnerability_WindowsDetail_KnowledgeBase struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
// The KB name (generally of the form KB[0-9]+ i.e. KB123456).
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
// A link to the KB in the Windows update catalog -
// https://www.catalog.update.microsoft.com/
Url string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
}
func (x *Vulnerability_WindowsDetail_KnowledgeBase) Reset() {
*x = Vulnerability_WindowsDetail_KnowledgeBase{}
if protoimpl.UnsafeEnabled {
mi := &file_vulnerability_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Vulnerability_WindowsDetail_KnowledgeBase) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Vulnerability_WindowsDetail_KnowledgeBase) ProtoMessage() {}
func (x *Vulnerability_WindowsDetail_KnowledgeBase) ProtoReflect() protoreflect.Message {
mi := &file_vulnerability_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Vulnerability_WindowsDetail_KnowledgeBase.ProtoReflect.Descriptor instead.
func (*Vulnerability_WindowsDetail_KnowledgeBase) Descriptor() ([]byte, []int) {
return file_vulnerability_proto_rawDescGZIP(), []int{0, 1, 0}
}
func (x *Vulnerability_WindowsDetail_KnowledgeBase) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Vulnerability_WindowsDetail_KnowledgeBase) GetUrl() string {
if x != nil {
return x.Url
}
return ""
}
var File_vulnerability_proto protoreflect.FileDescriptor
var file_vulnerability_proto_rawDesc = []byte{
0x0a, 0x13, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x1d, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76,
0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69,
0x6c, 0x69, 0x74, 0x79, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x61, 0x70, 0x69,
0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x62, 0x65, 0x68, 0x61, 0x76, 0x69, 0x6f, 0x72, 0x2e,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1a, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x31,
0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f,
0x74, 0x6f, 0x1a, 0x18, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
0x31, 0x2f, 0x63, 0x76, 0x73, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x70, 0x72,
0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x70, 0x61, 0x63, 0x6b,
0x61, 0x67, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xc8, 0x0a, 0x0a, 0x0d, 0x56, 0x75,
0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x63,
0x76, 0x73, 0x73, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x02, 0x52,
0x09, 0x63, 0x76, 0x73, 0x73, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x43, 0x0a, 0x08, 0x73, 0x65,
0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x67,
0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76,
0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x53, 0x65, 0x76,
0x65, 0x72, 0x69, 0x74, 0x79, 0x52, 0x08, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x12,
0x4d, 0x0a, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b,
0x32, 0x33, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
0x2e, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x44,
0x65, 0x74, 0x61, 0x69, 0x6c, 0x52, 0x07, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, 0x3c,
0x0a, 0x07, 0x63, 0x76, 0x73, 0x73, 0x5f, 0x76, 0x33, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x23, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
0x43, 0x56, 0x53, 0x53, 0x52, 0x06, 0x63, 0x76, 0x73, 0x73, 0x56, 0x33, 0x12, 0x63, 0x0a, 0x0f,
0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18,
0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e,
0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62,
0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c,
0x69, 0x74, 0x79, 0x2e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69,
0x6c, 0x52, 0x0e, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c,
0x73, 0x12, 0x48, 0x0a, 0x12, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61,
0x74, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63,
0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x3c, 0x0a, 0x07, 0x63,
0x76, 0x73, 0x73, 0x5f, 0x76, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x67,
0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76,
0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x43, 0x56, 0x53,
0x53, 0x52, 0x06, 0x63, 0x76, 0x73, 0x73, 0x56, 0x32, 0x12, 0x10, 0x0a, 0x03, 0x63, 0x77, 0x65,
0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x03, 0x63, 0x77, 0x65, 0x1a, 0xc5, 0x04, 0x0a, 0x06,
0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x17, 0x0a, 0x07, 0x63, 0x70, 0x65, 0x5f, 0x75, 0x72,
0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x70, 0x65, 0x55, 0x72, 0x69, 0x12,
0x18, 0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
0x52, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x52, 0x0a, 0x14, 0x6d, 0x69, 0x6e,
0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61,
0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
0x65, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x12, 0x6d, 0x69, 0x6e, 0x41, 0x66,
0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x52, 0x0a,
0x14, 0x6d, 0x61, 0x78, 0x5f, 0x61, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x76, 0x65,
0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x72,
0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x70, 0x61,
0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x12, 0x6d,
0x61, 0x78, 0x41, 0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f,
0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69,
0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69,
0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73,
0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5b, 0x0a, 0x0e, 0x66, 0x69, 0x78, 0x65,
0x64, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b,
0x32, 0x34, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74,
0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79,
0x2e, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x4c, 0x6f,
0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x66, 0x69, 0x78, 0x65, 0x64, 0x4c, 0x6f, 0x63,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x63,
0x6b, 0x61, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x6f,
0x62, 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69,
0x73, 0x4f, 0x62, 0x73, 0x6f, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x48, 0x0a, 0x12, 0x73, 0x6f, 0x75,
0x72, 0x63, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18,
0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70,
0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d,
0x70, 0x52, 0x10, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54,
0x69, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x0b, 0x20,
0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x76,
0x65, 0x6e, 0x64, 0x6f, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x76, 0x65, 0x6e,
0x64, 0x6f, 0x72, 0x1a, 0xfe, 0x01, 0x0a, 0x0d, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44,
0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x17, 0x0a, 0x07, 0x63, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x69,
0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x70, 0x65, 0x55, 0x72, 0x69, 0x12, 0x12,
0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70,
0x74, 0x69, 0x6f, 0x6e, 0x12, 0x67, 0x0a, 0x0a, 0x66, 0x69, 0x78, 0x69, 0x6e, 0x67, 0x5f, 0x6b,
0x62, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x48, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65,
0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65,
0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61,
0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x44, 0x65,
0x74, 0x61, 0x69, 0x6c, 0x2e, 0x4b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x42, 0x61,
0x73, 0x65, 0x52, 0x09, 0x66, 0x69, 0x78, 0x69, 0x6e, 0x67, 0x4b, 0x62, 0x73, 0x1a, 0x35, 0x0a,
0x0d, 0x4b, 0x6e, 0x6f, 0x77, 0x6c, 0x65, 0x64, 0x67, 0x65, 0x42, 0x61, 0x73, 0x65, 0x12, 0x12,
0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
0x03, 0x75, 0x72, 0x6c, 0x22, 0xc3, 0x03, 0x0a, 0x07, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73,
0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04,
0x74, 0x79, 0x70, 0x65, 0x12, 0x43, 0x0a, 0x08, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73,
0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61,
0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x53, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x52,
0x08, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x76, 0x73,
0x73, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x02, 0x52, 0x09, 0x63,
0x76, 0x73, 0x73, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x50, 0x0a, 0x0d, 0x70, 0x61, 0x63, 0x6b,
0x61, 0x67, 0x65, 0x5f, 0x69, 0x73, 0x73, 0x75, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32,
0x2b, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x49, 0x73, 0x73, 0x75, 0x65, 0x52, 0x0c, 0x70, 0x61,
0x63, 0x6b, 0x61, 0x67, 0x65, 0x49, 0x73, 0x73, 0x75, 0x65, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x68,
0x6f, 0x72, 0x74, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18,
0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x44, 0x65, 0x73, 0x63,
0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x10, 0x6c, 0x6f, 0x6e, 0x67, 0x5f,
0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28,
0x09, 0x52, 0x0f, 0x6c, 0x6f, 0x6e, 0x67, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69,
0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0c, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x75, 0x72,
0x6c, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65,
0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x52, 0x65, 0x6c, 0x61, 0x74,
0x65, 0x64, 0x55, 0x72, 0x6c, 0x52, 0x0b, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x55, 0x72,
0x6c, 0x73, 0x12, 0x56, 0x0a, 0x12, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f,
0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x27,
0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x53,
0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x52, 0x11, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69,
0x76, 0x65, 0x53, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x22, 0xf3, 0x02, 0x0a, 0x0c, 0x50,
0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x49, 0x73, 0x73, 0x75, 0x65, 0x12, 0x61, 0x0a, 0x11, 0x61,
0x66, 0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73,
0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61,
0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69,
0x6c, 0x69, 0x74, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x61, 0x66,
0x66, 0x65, 0x63, 0x74, 0x65, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5b,
0x0a, 0x0e, 0x66, 0x69, 0x78, 0x65, 0x64, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73,
0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61,
0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69,
0x6c, 0x69, 0x74, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x66, 0x69,
0x78, 0x65, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x73,
0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01,
0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x4e, 0x61, 0x6d, 0x65,
0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 0x70, 0x65,
0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x54,
0x79, 0x70, 0x65, 0x12, 0x5b, 0x0a, 0x12, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65,
0x5f, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32,
0x27, 0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61,
0x31, 0x2e, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x2e,
0x53, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x42, 0x03, 0xe0, 0x41, 0x03, 0x52, 0x11, 0x65,
0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x53, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79,
0x22, 0x86, 0x01, 0x0a, 0x15, 0x56, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69,
0x74, 0x79, 0x4c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x17, 0x0a, 0x07, 0x63, 0x70,
0x65, 0x5f, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x70, 0x65,
0x55, 0x72, 0x69, 0x12, 0x18, 0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x02,
0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12, 0x3a, 0x0a,
0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20,
0x2e, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31,
0x2e, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x2a, 0x5e, 0x0a, 0x08, 0x53, 0x65, 0x76,
0x65, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x14, 0x53, 0x45, 0x56, 0x45, 0x52, 0x49, 0x54,
0x59, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12,
0x0b, 0x0a, 0x07, 0x4d, 0x49, 0x4e, 0x49, 0x4d, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03,
0x4c, 0x4f, 0x57, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x4d, 0x45, 0x44, 0x49, 0x55, 0x4d, 0x10,
0x03, 0x12, 0x08, 0x0a, 0x04, 0x48, 0x49, 0x47, 0x48, 0x10, 0x04, 0x12, 0x0c, 0x0a, 0x08, 0x43,
0x52, 0x49, 0x54, 0x49, 0x43, 0x41, 0x4c, 0x10, 0x05, 0x42, 0x6b, 0x0a, 0x20, 0x69, 0x6f, 0x2e,
0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2e,
0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x50, 0x01, 0x5a,
0x3f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x72, 0x61, 0x66,
0x65, 0x61, 0x73, 0x2f, 0x67, 0x72, 0x61, 0x66, 0x65, 0x61, 0x73, 0x2f, 0x70, 0x72, 0x6f, 0x74,
0x6f, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x31, 0x2f, 0x76, 0x75, 0x6c, 0x6e, 0x65, 0x72,
0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x5f, 0x67, 0x6f, 0x5f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0xa2, 0x02, 0x03, 0x47, 0x52, 0x41, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_vulnerability_proto_rawDescOnce sync.Once
file_vulnerability_proto_rawDescData = file_vulnerability_proto_rawDesc
)
func file_vulnerability_proto_rawDescGZIP() []byte {
file_vulnerability_proto_rawDescOnce.Do(func() {
file_vulnerability_proto_rawDescData = protoimpl.X.CompressGZIP(file_vulnerability_proto_rawDescData)
})
return file_vulnerability_proto_rawDescData
}
var file_vulnerability_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_vulnerability_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_vulnerability_proto_goTypes = []interface{}{
(Severity)(0), // 0: grafeas.v1beta1.vulnerability.Severity
(*Vulnerability)(nil), // 1: grafeas.v1beta1.vulnerability.Vulnerability
(*Details)(nil), // 2: grafeas.v1beta1.vulnerability.Details
(*PackageIssue)(nil), // 3: grafeas.v1beta1.vulnerability.PackageIssue
(*VulnerabilityLocation)(nil), // 4: grafeas.v1beta1.vulnerability.VulnerabilityLocation
(*Vulnerability_Detail)(nil), // 5: grafeas.v1beta1.vulnerability.Vulnerability.Detail
(*Vulnerability_WindowsDetail)(nil), // 6: grafeas.v1beta1.vulnerability.Vulnerability.WindowsDetail
(*Vulnerability_WindowsDetail_KnowledgeBase)(nil), // 7: grafeas.v1beta1.vulnerability.Vulnerability.WindowsDetail.KnowledgeBase
(*cvss_go_proto.CVSS)(nil), // 8: grafeas.v1beta1.vulnerability.CVSS
(*timestamp.Timestamp)(nil), // 9: google.protobuf.Timestamp
(*common_go_proto.RelatedUrl)(nil), // 10: grafeas.v1beta1.RelatedUrl
(*package_go_proto.Version)(nil), // 11: grafeas.v1beta1.package.Version
}
var file_vulnerability_proto_depIdxs = []int32{
0, // 0: grafeas.v1beta1.vulnerability.Vulnerability.severity:type_name -> grafeas.v1beta1.vulnerability.Severity
5, // 1: grafeas.v1beta1.vulnerability.Vulnerability.details:type_name -> grafeas.v1beta1.vulnerability.Vulnerability.Detail
8, // 2: grafeas.v1beta1.vulnerability.Vulnerability.cvss_v3:type_name -> grafeas.v1beta1.vulnerability.CVSS
6, // 3: grafeas.v1beta1.vulnerability.Vulnerability.windows_details:type_name -> grafeas.v1beta1.vulnerability.Vulnerability.WindowsDetail
9, // 4: grafeas.v1beta1.vulnerability.Vulnerability.source_update_time:type_name -> google.protobuf.Timestamp
8, // 5: grafeas.v1beta1.vulnerability.Vulnerability.cvss_v2:type_name -> grafeas.v1beta1.vulnerability.CVSS
0, // 6: grafeas.v1beta1.vulnerability.Details.severity:type_name -> grafeas.v1beta1.vulnerability.Severity
3, // 7: grafeas.v1beta1.vulnerability.Details.package_issue:type_name -> grafeas.v1beta1.vulnerability.PackageIssue
10, // 8: grafeas.v1beta1.vulnerability.Details.related_urls:type_name -> grafeas.v1beta1.RelatedUrl
0, // 9: grafeas.v1beta1.vulnerability.Details.effective_severity:type_name -> grafeas.v1beta1.vulnerability.Severity
4, // 10: grafeas.v1beta1.vulnerability.PackageIssue.affected_location:type_name -> grafeas.v1beta1.vulnerability.VulnerabilityLocation
4, // 11: grafeas.v1beta1.vulnerability.PackageIssue.fixed_location:type_name -> grafeas.v1beta1.vulnerability.VulnerabilityLocation
0, // 12: grafeas.v1beta1.vulnerability.PackageIssue.effective_severity:type_name -> grafeas.v1beta1.vulnerability.Severity
11, // 13: grafeas.v1beta1.vulnerability.VulnerabilityLocation.version:type_name -> grafeas.v1beta1.package.Version
11, // 14: grafeas.v1beta1.vulnerability.Vulnerability.Detail.min_affected_version:type_name -> grafeas.v1beta1.package.Version
11, // 15: grafeas.v1beta1.vulnerability.Vulnerability.Detail.max_affected_version:type_name -> grafeas.v1beta1.package.Version
4, // 16: grafeas.v1beta1.vulnerability.Vulnerability.Detail.fixed_location:type_name -> grafeas.v1beta1.vulnerability.VulnerabilityLocation
9, // 17: grafeas.v1beta1.vulnerability.Vulnerability.Detail.source_update_time:type_name -> google.protobuf.Timestamp
7, // 18: grafeas.v1beta1.vulnerability.Vulnerability.WindowsDetail.fixing_kbs:type_name -> grafeas.v1beta1.vulnerability.Vulnerability.WindowsDetail.KnowledgeBase
19, // [19:19] is the sub-list for method output_type
19, // [19:19] is the sub-list for method input_type
19, // [19:19] is the sub-list for extension type_name
19, // [19:19] is the sub-list for extension extendee
0, // [0:19] is the sub-list for field type_name
}
func init() { file_vulnerability_proto_init() }
func file_vulnerability_proto_init() {
if File_vulnerability_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_vulnerability_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Vulnerability); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vulnerability_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Details); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vulnerability_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*PackageIssue); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vulnerability_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*VulnerabilityLocation); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vulnerability_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Vulnerability_Detail); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vulnerability_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Vulnerability_WindowsDetail); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_vulnerability_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Vulnerability_WindowsDetail_KnowledgeBase); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_vulnerability_proto_rawDesc,
NumEnums: 1,
NumMessages: 7,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_vulnerability_proto_goTypes,
DependencyIndexes: file_vulnerability_proto_depIdxs,
EnumInfos: file_vulnerability_proto_enumTypes,
MessageInfos: file_vulnerability_proto_msgTypes,
}.Build()
File_vulnerability_proto = out.File
file_vulnerability_proto_rawDesc = nil
file_vulnerability_proto_goTypes = nil
file_vulnerability_proto_depIdxs = nil
}
|
grafeas/grafeas
|
proto/v1beta1/vulnerability_go_proto/vulnerability.pb.go
|
GO
|
apache-2.0
| 49,312
|
# Pimelea williamsonii J.M.Black SPECIES
#### Status
ACCEPTED
#### According to
International Plant Names Index
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Magnoliopsida/Malvales/Malvaceae/Pimelea/Pimelea williamsonii/README.md
|
Markdown
|
apache-2.0
| 180
|
/*
Copyright 2012 Twitter, Inc.
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.
*/
package com.twitter.scalding
import org.scalacheck.Arbitrary
import org.scalacheck.Properties
import org.scalacheck.Prop.forAll
import org.scalacheck.Gen.choose
import org.scalacheck.Prop._
import scala.util.control.Exception.allCatch
import AbsoluteDuration.fromMillisecs
object DateProperties extends Properties("Date Properties") {
implicit def dateParser: DateParser = DateParser.default
implicit val durationArb: Arbitrary[Duration] =
Arbitrary { choose(0, 10000).map { Millisecs(_) } }
implicit val richDateArb: Arbitrary[RichDate] = Arbitrary {
for (v <- choose(0L, 1L << 32)) yield RichDate(v)
}
implicit val dateRangeArb: Arbitrary[DateRange] = Arbitrary {
for (
v1 <- choose(0L, 1L << 33);
v2 <- choose(v1, 1L << 33)
) yield DateRange(RichDate(v1), RichDate(v2))
}
implicit val absdur: Arbitrary[AbsoluteDuration] =
Arbitrary {
implicitly[Arbitrary[Long]]
.arbitrary
// Ignore Longs that are too big to fit, and make sure we can add any random 3 together
// Long.MaxValue / 1200 ms is the biggest that will fit, we divide by 3 to make sure
// we can add three together in tests
.map { ms => fromMillisecs(ms / (1200 * 3)) }
}
property("Shifting DateRanges breaks containment") = forAll { (dr: DateRange, r: Duration) =>
val newDr = dr + r
!newDr.contains(dr) || (newDr == dr)
}
property("Arithmetic works as expected") = forAll { (dr: DateRange, r: Duration) =>
(dr + r) - r == dr &&
(dr.start + r) - r == dr.start
}
property("fromMillisecs toMillisecs") = forAll { (ad: AbsoluteDuration) =>
val ms = ad.toMillisecs
(fromMillisecs(ms) == ad)
}
def asInt(b: Boolean) = if (b) 1 else 0
property("Before/After works") = forAll { (dr: DateRange, rd: RichDate) =>
(asInt(dr.contains(rd)) + asInt(dr.isBefore(rd)) + asInt(dr.isAfter(rd)) == 1) &&
(dr.isBefore(dr.end + (dr.end - dr.start))) &&
(dr.isAfter(dr.start - (dr.end - dr.start)))
}
def divDur(ad: AbsoluteDuration, div: Int) = fromMillisecs(ad.toMillisecs / div)
property("each output is contained") = forAll { (dr: DateRange) =>
val r = divDur(dr.end - dr.start, 10)
dr.each(r).forall { dr.contains(_) }
}
property("Embiggen/extend always contains") = forAll { (dr: DateRange, d: Duration) =>
dr.embiggen(d).contains(dr) &&
dr.extend(d).contains(dr)
}
property("RichDate subtraction Roundtrip") = forAll { (timestamp0: Long, delta: AbsoluteDuration) =>
val start = RichDate(timestamp0)
val end = start + delta
end - delta == start && (end - start) == delta
}
property("Millisecs rt") = forAll { (ms: Int) =>
Millisecs(ms).toMillisecs.toInt == ms
}
property("AbsoluteDuration group properties") =
forAll { (a: AbsoluteDuration, b: AbsoluteDuration, c: AbsoluteDuration) =>
(a + b) - c == a + (b - c) &&
(a + b) + c == a + (b + c) &&
(a - a) == fromMillisecs(0) &&
(b - b) == fromMillisecs(0) &&
(c - c) == fromMillisecs(0) &&
{
b.toMillisecs == 0 || {
// Don't divide by zero:
val (d, rem) = (a / b)
a == b * d + rem && (rem.toMillisecs.abs < b.toMillisecs.abs)
}
}
}
property("DateRange.length is correct") = forAll { (dr: DateRange) =>
dr.start + dr.length - AbsoluteDuration.fromMillisecs(1L) == dr.end
}
property("DateRange.exclusiveUpper works") = forAll { (a: RichDate, b: RichDate) =>
val lower = Ordering[RichDate].min(a, b)
val upper = Ordering[RichDate].max(a, b)
val ex = DateRange.exclusiveUpper(lower, upper)
val in = DateRange(lower, upper)
val upperPred = upper - Millisecs(1)
(false == ex.contains(upper)) &&
(ex.contains(upperPred) || (lower == upper))
}
def toRegex(glob: String) = (glob.flatMap { c => if (c == '*') ".*" else c.toString }).r
def matches(l: List[String], arg: String): Int = l
.map { toRegex _ }
.map { _.findFirstMatchIn(arg).map { _ => 1 }.getOrElse(0) }
.sum
// Make sure globifier always contains:
val pattern = "%1$tY/%1$tm/%1$td/%1$tH"
val glob = Globifier(pattern)(DateOps.UTC)
property("Globifying produces matching patterns") = forAll { (dr: DateRange) =>
val globbed = glob.globify(dr)
// Brute force
dr.each(Hours(1)).map { _.start.format(pattern)(DateOps.UTC) }
.forall { matches(globbed, _) == 1 }
}
}
|
oeddyo/scalding
|
scalding-date/src/test/scala/com/twitter/scalding/DateProperties.scala
|
Scala
|
apache-2.0
| 5,004
|
// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: google/ads/googleads/v9/enums/feed_item_target_type.proto
package com.google.ads.googleads.v9.enums;
/**
* <pre>
* Container for enum describing possible types of a feed item target.
* </pre>
*
* Protobuf type {@code google.ads.googleads.v9.enums.FeedItemTargetTypeEnum}
*/
public final class FeedItemTargetTypeEnum extends
com.google.protobuf.GeneratedMessageV3 implements
// @@protoc_insertion_point(message_implements:google.ads.googleads.v9.enums.FeedItemTargetTypeEnum)
FeedItemTargetTypeEnumOrBuilder {
private static final long serialVersionUID = 0L;
// Use FeedItemTargetTypeEnum.newBuilder() to construct.
private FeedItemTargetTypeEnum(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
super(builder);
}
private FeedItemTargetTypeEnum() {
}
@java.lang.Override
@SuppressWarnings({"unused"})
protected java.lang.Object newInstance(
UnusedPrivateParameter unused) {
return new FeedItemTargetTypeEnum();
}
@java.lang.Override
public final com.google.protobuf.UnknownFieldSet
getUnknownFields() {
return this.unknownFields;
}
private FeedItemTargetTypeEnum(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
this();
if (extensionRegistry == null) {
throw new java.lang.NullPointerException();
}
com.google.protobuf.UnknownFieldSet.Builder unknownFields =
com.google.protobuf.UnknownFieldSet.newBuilder();
try {
boolean done = false;
while (!done) {
int tag = input.readTag();
switch (tag) {
case 0:
done = true;
break;
default: {
if (!parseUnknownField(
input, unknownFields, extensionRegistry, tag)) {
done = true;
}
break;
}
}
}
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
throw e.setUnfinishedMessage(this);
} catch (java.io.IOException e) {
throw new com.google.protobuf.InvalidProtocolBufferException(
e).setUnfinishedMessage(this);
} finally {
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeProto.internal_static_google_ads_googleads_v9_enums_FeedItemTargetTypeEnum_descriptor;
}
@java.lang.Override
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeProto.internal_static_google_ads_googleads_v9_enums_FeedItemTargetTypeEnum_fieldAccessorTable
.ensureFieldAccessorsInitialized(
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.class, com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.Builder.class);
}
/**
* <pre>
* Possible type of a feed item target.
* </pre>
*
* Protobuf enum {@code google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.FeedItemTargetType}
*/
public enum FeedItemTargetType
implements com.google.protobuf.ProtocolMessageEnum {
/**
* <pre>
* Not specified.
* </pre>
*
* <code>UNSPECIFIED = 0;</code>
*/
UNSPECIFIED(0),
/**
* <pre>
* Used for return value only. Represents value unknown in this version.
* </pre>
*
* <code>UNKNOWN = 1;</code>
*/
UNKNOWN(1),
/**
* <pre>
* Feed item targets a campaign.
* </pre>
*
* <code>CAMPAIGN = 2;</code>
*/
CAMPAIGN(2),
/**
* <pre>
* Feed item targets an ad group.
* </pre>
*
* <code>AD_GROUP = 3;</code>
*/
AD_GROUP(3),
/**
* <pre>
* Feed item targets a criterion.
* </pre>
*
* <code>CRITERION = 4;</code>
*/
CRITERION(4),
UNRECOGNIZED(-1),
;
/**
* <pre>
* Not specified.
* </pre>
*
* <code>UNSPECIFIED = 0;</code>
*/
public static final int UNSPECIFIED_VALUE = 0;
/**
* <pre>
* Used for return value only. Represents value unknown in this version.
* </pre>
*
* <code>UNKNOWN = 1;</code>
*/
public static final int UNKNOWN_VALUE = 1;
/**
* <pre>
* Feed item targets a campaign.
* </pre>
*
* <code>CAMPAIGN = 2;</code>
*/
public static final int CAMPAIGN_VALUE = 2;
/**
* <pre>
* Feed item targets an ad group.
* </pre>
*
* <code>AD_GROUP = 3;</code>
*/
public static final int AD_GROUP_VALUE = 3;
/**
* <pre>
* Feed item targets a criterion.
* </pre>
*
* <code>CRITERION = 4;</code>
*/
public static final int CRITERION_VALUE = 4;
public final int getNumber() {
if (this == UNRECOGNIZED) {
throw new java.lang.IllegalArgumentException(
"Can't get the number of an unknown enum value.");
}
return value;
}
/**
* @param value The numeric wire value of the corresponding enum entry.
* @return The enum associated with the given numeric wire value.
* @deprecated Use {@link #forNumber(int)} instead.
*/
@java.lang.Deprecated
public static FeedItemTargetType valueOf(int value) {
return forNumber(value);
}
/**
* @param value The numeric wire value of the corresponding enum entry.
* @return The enum associated with the given numeric wire value.
*/
public static FeedItemTargetType forNumber(int value) {
switch (value) {
case 0: return UNSPECIFIED;
case 1: return UNKNOWN;
case 2: return CAMPAIGN;
case 3: return AD_GROUP;
case 4: return CRITERION;
default: return null;
}
}
public static com.google.protobuf.Internal.EnumLiteMap<FeedItemTargetType>
internalGetValueMap() {
return internalValueMap;
}
private static final com.google.protobuf.Internal.EnumLiteMap<
FeedItemTargetType> internalValueMap =
new com.google.protobuf.Internal.EnumLiteMap<FeedItemTargetType>() {
public FeedItemTargetType findValueByNumber(int number) {
return FeedItemTargetType.forNumber(number);
}
};
public final com.google.protobuf.Descriptors.EnumValueDescriptor
getValueDescriptor() {
if (this == UNRECOGNIZED) {
throw new java.lang.IllegalStateException(
"Can't get the descriptor of an unrecognized enum value.");
}
return getDescriptor().getValues().get(ordinal());
}
public final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptorForType() {
return getDescriptor();
}
public static final com.google.protobuf.Descriptors.EnumDescriptor
getDescriptor() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.getDescriptor().getEnumTypes().get(0);
}
private static final FeedItemTargetType[] VALUES = values();
public static FeedItemTargetType valueOf(
com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
if (desc.getType() != getDescriptor()) {
throw new java.lang.IllegalArgumentException(
"EnumValueDescriptor is not for this type.");
}
if (desc.getIndex() == -1) {
return UNRECOGNIZED;
}
return VALUES[desc.getIndex()];
}
private final int value;
private FeedItemTargetType(int value) {
this.value = value;
}
// @@protoc_insertion_point(enum_scope:google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.FeedItemTargetType)
}
private byte memoizedIsInitialized = -1;
@java.lang.Override
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
if (isInitialized == 1) return true;
if (isInitialized == 0) return false;
memoizedIsInitialized = 1;
return true;
}
@java.lang.Override
public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
unknownFields.writeTo(output);
}
@java.lang.Override
public int getSerializedSize() {
int size = memoizedSize;
if (size != -1) return size;
size = 0;
size += unknownFields.getSerializedSize();
memoizedSize = size;
return size;
}
@java.lang.Override
public boolean equals(final java.lang.Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum)) {
return super.equals(obj);
}
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum other = (com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum) obj;
if (!unknownFields.equals(other.unknownFields)) return false;
return true;
}
@java.lang.Override
public int hashCode() {
if (memoizedHashCode != 0) {
return memoizedHashCode;
}
int hash = 41;
hash = (19 * hash) + getDescriptor().hashCode();
hash = (29 * hash) + unknownFields.hashCode();
memoizedHashCode = hash;
return hash;
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
java.nio.ByteBuffer data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
java.nio.ByteBuffer data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(byte[] data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
byte[] data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseDelimitedFrom(java.io.InputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseDelimitedWithIOException(PARSER, input, extensionRegistry);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input, extensionRegistry);
}
@java.lang.Override
public Builder newBuilderForType() { return newBuilder(); }
public static Builder newBuilder() {
return DEFAULT_INSTANCE.toBuilder();
}
public static Builder newBuilder(com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum prototype) {
return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
}
@java.lang.Override
public Builder toBuilder() {
return this == DEFAULT_INSTANCE
? new Builder() : new Builder().mergeFrom(this);
}
@java.lang.Override
protected Builder newBuilderForType(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
Builder builder = new Builder(parent);
return builder;
}
/**
* <pre>
* Container for enum describing possible types of a feed item target.
* </pre>
*
* Protobuf type {@code google.ads.googleads.v9.enums.FeedItemTargetTypeEnum}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
// @@protoc_insertion_point(builder_implements:google.ads.googleads.v9.enums.FeedItemTargetTypeEnum)
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnumOrBuilder {
public static final com.google.protobuf.Descriptors.Descriptor
getDescriptor() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeProto.internal_static_google_ads_googleads_v9_enums_FeedItemTargetTypeEnum_descriptor;
}
@java.lang.Override
protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
internalGetFieldAccessorTable() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeProto.internal_static_google_ads_googleads_v9_enums_FeedItemTargetTypeEnum_fieldAccessorTable
.ensureFieldAccessorsInitialized(
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.class, com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.Builder.class);
}
// Construct using com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
private Builder(
com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessageV3
.alwaysUseFieldBuilders) {
}
}
@java.lang.Override
public Builder clear() {
super.clear();
return this;
}
@java.lang.Override
public com.google.protobuf.Descriptors.Descriptor
getDescriptorForType() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeProto.internal_static_google_ads_googleads_v9_enums_FeedItemTargetTypeEnum_descriptor;
}
@java.lang.Override
public com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum getDefaultInstanceForType() {
return com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.getDefaultInstance();
}
@java.lang.Override
public com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum build() {
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
@java.lang.Override
public com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum buildPartial() {
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum result = new com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum(this);
onBuilt();
return result;
}
@java.lang.Override
public Builder clone() {
return super.clone();
}
@java.lang.Override
public Builder setField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return super.setField(field, value);
}
@java.lang.Override
public Builder clearField(
com.google.protobuf.Descriptors.FieldDescriptor field) {
return super.clearField(field);
}
@java.lang.Override
public Builder clearOneof(
com.google.protobuf.Descriptors.OneofDescriptor oneof) {
return super.clearOneof(oneof);
}
@java.lang.Override
public Builder setRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
int index, java.lang.Object value) {
return super.setRepeatedField(field, index, value);
}
@java.lang.Override
public Builder addRepeatedField(
com.google.protobuf.Descriptors.FieldDescriptor field,
java.lang.Object value) {
return super.addRepeatedField(field, value);
}
@java.lang.Override
public Builder mergeFrom(com.google.protobuf.Message other) {
if (other instanceof com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum) {
return mergeFrom((com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum)other);
} else {
super.mergeFrom(other);
return this;
}
}
public Builder mergeFrom(com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum other) {
if (other == com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum.getDefaultInstance()) return this;
this.mergeUnknownFields(other.unknownFields);
onChanged();
return this;
}
@java.lang.Override
public final boolean isInitialized() {
return true;
}
@java.lang.Override
public Builder mergeFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
parsedMessage = (com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum) e.getUnfinishedMessage();
throw e.unwrapIOException();
} finally {
if (parsedMessage != null) {
mergeFrom(parsedMessage);
}
}
return this;
}
@java.lang.Override
public final Builder setUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.setUnknownFields(unknownFields);
}
@java.lang.Override
public final Builder mergeUnknownFields(
final com.google.protobuf.UnknownFieldSet unknownFields) {
return super.mergeUnknownFields(unknownFields);
}
// @@protoc_insertion_point(builder_scope:google.ads.googleads.v9.enums.FeedItemTargetTypeEnum)
}
// @@protoc_insertion_point(class_scope:google.ads.googleads.v9.enums.FeedItemTargetTypeEnum)
private static final com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum DEFAULT_INSTANCE;
static {
DEFAULT_INSTANCE = new com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum();
}
public static com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum getDefaultInstance() {
return DEFAULT_INSTANCE;
}
private static final com.google.protobuf.Parser<FeedItemTargetTypeEnum>
PARSER = new com.google.protobuf.AbstractParser<FeedItemTargetTypeEnum>() {
@java.lang.Override
public FeedItemTargetTypeEnum parsePartialFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return new FeedItemTargetTypeEnum(input, extensionRegistry);
}
};
public static com.google.protobuf.Parser<FeedItemTargetTypeEnum> parser() {
return PARSER;
}
@java.lang.Override
public com.google.protobuf.Parser<FeedItemTargetTypeEnum> getParserForType() {
return PARSER;
}
@java.lang.Override
public com.google.ads.googleads.v9.enums.FeedItemTargetTypeEnum getDefaultInstanceForType() {
return DEFAULT_INSTANCE;
}
}
|
googleads/google-ads-java
|
google-ads-stubs-v9/src/main/java/com/google/ads/googleads/v9/enums/FeedItemTargetTypeEnum.java
|
Java
|
apache-2.0
| 20,725
|
# Literature Review for Tensorflow Learning on Android
# Papers
## Signal Processing and Machine Learning with Differential Privacy
By: Anand D. Sarwate and Kamalika Chaudhuri
## Crowd-ML: A Privacy-Preserving Learning Framework for a Crowd of Smart Devices
By: Jihun Hamm, Adam C. Champion, Guoxing Chen, Mikhail Belkin, Dong Xuan
Link: [Code](https://github.com/jihunhamm/Crowd-ML) or [Paper](https://github.com/jihunhamm/Crowd-ML/blob/master/docs/icdcs15_jh_final.pdf)
Summary:
- Inspiration
- Good discussion of privacy needs
## Distributed Stochastic Optimization and Learning
By: Ohad Shamir and Nathan Srebro
Link: [Paper](http://www.wisdom.weizmann.ac.il/~shamiro/publications/2014_Allerton_ShaSre.pdf)
Summary:
- Great content on SGD on distributed systems
- Comparison table of algorithms
|
chelexa/tensorflow-on-android
|
literature-review.md
|
Markdown
|
apache-2.0
| 809
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Interface io.permazen.Session.RetryableAction (Permazen 4.1.9-SNAPSHOT API)</title>
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Interface io.permazen.Session.RetryableAction (Permazen 4.1.9-SNAPSHOT API)";
}
}
catch(err) {
}
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../io/permazen/Session.RetryableAction.html" title="interface in io.permazen">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../index-all.html">Index</a></li>
<li><a href="../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?io/permazen/class-use/Session.RetryableAction.html" target="_top">Frames</a></li>
<li><a href="Session.RetryableAction.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="header">
<h2 title="Uses of Interface io.permazen.Session.RetryableAction" class="title">Uses of Interface<br>io.permazen.Session.RetryableAction</h2>
</div>
<div class="classUseContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../io/permazen/Session.RetryableAction.html" title="interface in io.permazen">Session.RetryableAction</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#io.permazen.kv.raft.cmd">io.permazen.kv.raft.cmd</a></td>
<td class="colLast">
<div class="block">Raft-related CLI <a href="../../../io/permazen/cli/cmd/Command.html" title="interface in io.permazen.cli.cmd"><code>Command</code></a>s.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<ul class="blockList">
<li class="blockList"><a name="io.permazen.kv.raft.cmd">
<!-- -->
</a>
<h3>Uses of <a href="../../../io/permazen/Session.RetryableAction.html" title="interface in io.permazen">Session.RetryableAction</a> in <a href="../../../io/permazen/kv/raft/cmd/package-summary.html">io.permazen.kv.raft.cmd</a></h3>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing classes, and an explanation">
<caption><span>Classes in <a href="../../../io/permazen/kv/raft/cmd/package-summary.html">io.permazen.kv.raft.cmd</a> that implement <a href="../../../io/permazen/Session.RetryableAction.html" title="interface in io.permazen">Session.RetryableAction</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Class and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><code>protected class </code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../io/permazen/kv/raft/cmd/AbstractTransactionRaftCommand.RaftTransactionAction.html" title="class in io.permazen.kv.raft.cmd">AbstractTransactionRaftCommand.RaftTransactionAction</a></span></code> </td>
</tr>
</tbody>
</table>
</li>
</ul>
</li>
</ul>
</div>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../overview-summary.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../../../io/permazen/Session.RetryableAction.html" title="interface in io.permazen">Class</a></li>
<li class="navBarCell1Rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../index-all.html">Index</a></li>
<li><a href="../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?io/permazen/class-use/Session.RetryableAction.html" target="_top">Frames</a></li>
<li><a href="Session.RetryableAction.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright © 2022. All rights reserved.</small></p>
</body>
</html>
|
permazen/permazen
|
site/apidocs/io/permazen/class-use/Session.RetryableAction.html
|
HTML
|
apache-2.0
| 6,507
|
package com.hiwhitley.easy.day16;
/**
* Created by hiwhitley on 2016/9/10.
*/
public class SingleNumber {
public static int singleNumber(int[] nums) {
int result = 0;
for(int i : nums) {
result ^= i;
}
return result;
}
public static void main(String[] args) {
System.out.println(singleNumber(new int[]{1}));
}
}
|
hiwhitley/CodingEveryDay
|
src/com/hiwhitley/easy/day16/SingleNumber.java
|
Java
|
apache-2.0
| 384
|
package org.myrobotlab.service;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import org.myrobotlab.framework.Service;
import org.myrobotlab.logging.Level;
import org.myrobotlab.logging.LoggerFactory;
import org.myrobotlab.logging.Logging;
import org.myrobotlab.logging.LoggingFactory;
import org.myrobotlab.service.interfaces.SerialDataListener;
import org.slf4j.Logger;
public class Lidar extends Service implements SerialDataListener {
private static final long serialVersionUID = 1L;
public final static Logger log = LoggerFactory.getLogger(Lidar.class.getCanonicalName());
public static final String MODEL_SICK_LMS200 = "SICK LMS200";
public String serialName;
public transient Serial serial;
public transient ByteArrayOutputStream buffer = new ByteArrayOutputStream();
String model;
// states
public static final String STATE_PRE_INITIALIZATION = "state pre initialization";
public static final String STATE_INITIALIZATION_STAGE_1 = "state initialization stage 1";
public static final String STATE_INITIALIZATION_STAGE_2 = "state initialization stage 2";
public static final String STATE_INITIALIZATION_STAGE_3 = "state initialization stage 3";
public static final String STATE_INITIALIZATION_STAGE_4 = "state initialization stage 4";
public static final String STATE_SINGLE_SCAN = "taking a single scan";
public static final String STATE_MODE_CHANGE = "changing mode";
public static final String STATE_NOMINAL = "waiting on user to tell me what to do";
public int dataMessageSize = 213; // default size for a SICK LMS-200
String state = STATE_PRE_INITIALIZATION;
// String state = STATE_SINGLE_SCAN;//STATE_PRE_INITIALIZATION; // for
// testing with SEAR Simulator
int index = 0;
private int LIDARbaudRate = 9600; // by default
private String serialPort;
private byte[] message;
// private boolean dataAvailable = false;
String info; // used for outputting log.info messages
public static void main(String[] args) {
LoggingFactory.init(Level.WARN);
try {
Lidar template = (Lidar) Runtime.start("Lidar", "Lidar");
template.startService();
// Lidar lidar01 = (Lidar) Runtime.createAndStart("lidar01",
// "Lidar");
// creates and runs a serial service
// lidar01.connect("dev/lidar01");
// send a command
// this sets the mode to a spread of 180 degrees with readings every
// 0.5
// degrees
// lidar01.setMode(180, 0.5f);
// this setMode command catches the reply from the LMS in the
// listener
// within the
// Lidar service and returns a bool stating if it was successful or
// not.
// an array of floats holding ranges (after the LDIAR service strips
// and
// parses the data.
// lidar01.singleScan();
Python python = (Python) Runtime.start("python", "Python");
python.startService();
Runtime.createAndStart("gui", "SwingGui");
/*
* SwingGui gui = new SwingGui("gui"); gui.startService();
*/
} catch (Exception e) {
Logging.logError(e);
}
}
public Lidar(String n, String id) {
super(n, id);
// reserve(String.format("%s_serial", n), "Serial", "serial port for
// Lidar"); describe it in meta data
}
@Override
public void onBytes(byte[] bytes) {
for (int i = 0; i < bytes.length; i++) {
Integer b = bytes[i] & 0xFF;
index++;
if (log.isDebugEnabled()) {
log.debug(String.format("byteReceived Index = %d expected message size = %d data = %02x", index, dataMessageSize, b));
}
buffer.write(b);
// so a byte was appended
// now depending on what model it was and
// what stage of initialization we do that funky stuff
if (MODEL_SICK_LMS200.equals(model) && STATE_MODE_CHANGE.equals(state) && buffer.size() == 14) {
// These modes always have 14 bytes replies
// log.info(buffer.toString());
message = buffer.toByteArray();
// dataAvailable = true;
if (message[5] == 1 || message[6] == 1) {
log.info("Mode change was a Success!!!");
}
if (message[5] == 0 || message[6] == 0) {
log.error("Sorry dude, but I failed to change mode. Please try again.");
}
state = STATE_NOMINAL;
}
if (MODEL_SICK_LMS200.equals(model) && STATE_SINGLE_SCAN.equals(state) && index == dataMessageSize) {
if (log.isDebugEnabled()) {
log.debug("Buffer size = {} Buffer = {}", buffer.size(), buffer);
}
// WTF do I do with this data now?
try {
buffer.flush();
} catch (IOException e) {
log.warn("Buffer flush error", e);
} // flush entire buffer so I can convert it to a byte
// array
message = buffer.toByteArray();
info = String.format("size of message = %s", message.length);
log.info(info);
// dataAvailable = true;
invoke("publishLidarData");
state = STATE_NOMINAL;
index = 0;
}
}
}
public void connect(String port) throws IOException {
serial = getSerial();
serialPort = port;
serial.open(port, LIDARbaudRate, 8, 1, 0);
}
public boolean connect(String port, int baud) throws IOException {
serial = getSerial();
serialPort = port;
LIDARbaudRate = baud;
serial.open(port, baud, 8, 1, 0);
return serial.isConnected();
}
public boolean disconnect() {
serial = getSerial();
serial.disconnect();
return serial.isConnected();
}
public Serial getSerial() {
if (serialName == null) {
serialName = String.format("%s_serial", getName());
}
serial = (Serial) Runtime.create(serialName, "Serial");
return serial;
}
public int[] publishLidarData() {
int[] intData = new int[(message.length - 11) / 2];
log.info("publishLidarData has been called. Message length = " + message.length + " We should have = " + intData.length + "data readings");
StringBuilder data = new StringBuilder("");
for (int i = 8; i < (message.length - 3); i = i + 2) // excluding the
// header and
// the footer,
// taking every
// other byte as
// the LSB of
// the new
// number
{
// Do some bitwise stuff to get our integer distance in cm(default)
// or mm if you changed the mode
// data = MSB << 8 | LSB
ByteBuffer bb = ByteBuffer.wrap(new byte[] { 0, 0, message[i + 1], message[i] });
intData[(i - 8) / 2] = bb.getInt();
log.info("IntData index = " + (i - 8) / 2 + " i = " + i + " message = " + String.format(" %02x %02x", message[i], message[i + 1])
+ String.format(" Integer = %02x", intData[(i - 8) / 2]));
data.append(intData[(i - 8) / 2]).append(", ");
} // end for loop
// log.info("Data = "+data.toString());
return intData; // This should return data to the python code if the
// user has subscribed to it
}// end dataToString
public boolean reconnectSerial() throws IOException {
serial = getSerial();
serial.disconnect();
serial.open(serialPort, LIDARbaudRate, 8, 1, 0);
return serial.isConnected();
}
public void setBaud(int baudRate) throws Exception {
state = STATE_SINGLE_SCAN;
LIDARbaudRate = baudRate;
index = 0;
buffer.reset();
/*
* 9600 is default, but just in case you ever need it... PC sends : 02 00 02
* 00 20 42 52 08 LMS replies: 06 02 81 03 00 A0 00 10 36 1A (success)
*/
if (baudRate == 9600) {
serial.write(new byte[] { 0x02, 0x00, 0x02, 0x00, 0x20, 0x42, 0x52, 0x08 });
} /*
* 19200 PC sends : 02 00 02 00 20 41 51 08 LMS replies: 06 02 81 03 00 A0
* 00 10 36 1A (success)
*/else if (baudRate == 19200) {
serial.write(new byte[] { 0x02, 0x00, 0x02, 0x00, 0x20, 0x41, 0x52, 0x08 });
} /*
* 38400 PC sends : 02 00 02 00 20 41 51 08 LMS replies: 06 02 81 03 00 A0
* 00 10 36 1A (success)
*/else if (baudRate == 38400) {
serial.write(new byte[] { 0x02, 0x00, 0x02, 0x00, 0x20, 0x40, 0x52, 0x08 });
} else {
log.error("You've specified an unsupported baud rate");
}
}
public void setModel(String m) {
model = m;
}
public void setScanMode(int spread, float angularResolution) throws Exception {
state = STATE_MODE_CHANGE;
buffer.reset();
index = 0;
if (spread == 100) {
if (angularResolution == 1) {
serial.write(new byte[] { 0x02, 0x00, 0x05, 0x00, 0x3B, 0x64, 0x00, 0x64, 0x00, 0x1D, 0x0F });
// Start bytes and header = 8 bytes, 202 data bytes, 1 status
// and 2 bytes for checksum
dataMessageSize = 213;
} else if (angularResolution == 0.5) {
serial.write(new byte[] { 0x02, 0x00, 0x05, 0x00, 0x3B, 0x64, 0x00, 0x32, 0x00, (byte) 0xb1, 0x59 });
// Start bytes and header = 8 bytes, 402 data bytes, 1 status
// and 2 bytes for checksum
dataMessageSize = 413;
} else if (angularResolution == 0.25) {
serial.write(new byte[] { 0x02, 0x00, 0x05, 0x00, 0x3B, 0x64, 0x00, 0x19, 0x00, (byte) 0xe7, 0x72 });
// Start bytes and header = 8 bytes, 802 data bytes, 1 status
// and 2 bytes for checksum
dataMessageSize = 813;
} else {
log.error("You've defined an unsupported Mode");
}
} // end if spread = 100
if (spread == 180) {
if (angularResolution == 1) {
serial.write(new byte[] { 0x02, 0x00, 0x05, 0x00, 0x3B, (byte) 0xB4, 0x00, 0x64, 0x00, (byte) 0x97, 0x49 });
// Start bytes and header = 8 bytes, 362 data bytes, 1 status
// and 2 bytes for checksum
dataMessageSize = 373;
} else if (angularResolution == 0.5) {
serial.write(new byte[] { 0x02, 0x00, 0x05, 0x00, 0x3B, (byte) 0xB4, 0x00, 0x32, 0x00, 0x3B, 0x1F });
// Start bytes and header = 8 bytes, 722 data bytes, 1 status
// and 2 bytes for checksum
dataMessageSize = 733;
} else {
log.error("You've defined an unsupported Mode");
}
} // end if spread = 180
}// end of setMode
/*
* Set Lidar to use centimeters
*/
public boolean setToCM() {
return true;
// if (true) {
// return true;
// } else {
// return false;
// }
}
/*
* Set Lidar to use millimeters
*/
public boolean setToMM() {
return true;
// if (true) {
// return true;
// } else {
// return false;
// }
}
public void singleScan() throws Exception {
state = STATE_SINGLE_SCAN;
serial.write(new byte[] { 0x02, 0x00, 0x02, 0x00, 0x30, 0x01, 0x31, 0x18 });
index = 0;
buffer.reset();
}// end singleScan
@Override
public void startService() {
super.startService();
try {
serial = (Serial) startPeer("serial");
serial.addByteListener(this);
// setting callback / message route
serial.addListener("publishByte", getName(), "byteReceived");
serial.startService();
if (model == null) {
model = MODEL_SICK_LMS200;
}
// start Lidar hardware initialization here
// data coming back from the hardware will be in byteRecieved
if (MODEL_SICK_LMS200.equals(model)) {
serial.write(new byte[] { 1, 38, 32, 43 });
}
state = STATE_INITIALIZATION_STAGE_1;
} catch (Exception e) {
error(e.getMessage());
}
}
public void write(byte[] command) throws Exception {
// iterate through the byte array sending each one to the serial port.
for (int i = 0; i < command.length; i++) {
serial.write(command[i]);
}
}
@Override
public void onConnect(String portName) {
info("%s connected to %s", getName(), portName);
}
@Override
public void onDisconnect(String portName) {
info("%s disconnected from %s", getName(), portName);
}
}
|
MyRobotLab/myrobotlab
|
src/main/java/org/myrobotlab/service/Lidar.java
|
Java
|
apache-2.0
| 12,290
|
package com.android.org.bouncycastle.crypto.modes;
/*
* #%L
* Matos
* $Id:$
* $HeadURL:$
* %%
* Copyright (C) 2010 - 2014 Orange SA
* %%
* 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.
* #L%
*/
@com.francetelecom.rd.stubs.annotation.ClassDone(0)
public class CBCBlockCipher
implements com.android.org.bouncycastle.crypto.BlockCipher
{
// Constructors
public CBCBlockCipher(com.android.org.bouncycastle.crypto.BlockCipher arg1){
}
// Methods
public void init(boolean arg1, com.android.org.bouncycastle.crypto.CipherParameters arg2) throws java.lang.IllegalArgumentException{
}
public void reset(){
}
public com.android.org.bouncycastle.crypto.BlockCipher getUnderlyingCipher(){
return (com.android.org.bouncycastle.crypto.BlockCipher) null;
}
public int getBlockSize(){
return 0;
}
public java.lang.String getAlgorithmName(){
return (java.lang.String) null;
}
public int processBlock(byte [] arg1, int arg2, byte [] arg3, int arg4) throws com.android.org.bouncycastle.crypto.DataLengthException, java.lang.IllegalStateException{
return 0;
}
}
|
Orange-OpenSource/matos-profiles
|
matos-android/src/main/java/com/android/org/bouncycastle/crypto/modes/CBCBlockCipher.java
|
Java
|
apache-2.0
| 1,616
|
package io.quarkus.rest.client.reactive.runtime;
import java.io.Closeable;
import java.io.IOException;
import javax.annotation.PreDestroy;
import org.jboss.logging.Logger;
import io.quarkus.arc.NoClassInterceptors;
import io.quarkus.runtime.MockedThroughWrapper;
public abstract class RestClientReactiveCDIWrapperBase<T extends Closeable> implements Closeable, MockedThroughWrapper {
private static final Logger log = Logger.getLogger(RestClientReactiveCDIWrapperBase.class);
private final T delegate;
private Object mock;
public RestClientReactiveCDIWrapperBase(Class<T> jaxrsInterface, String baseUriFromAnnotation, String configKey) {
this.delegate = RestClientCDIDelegateBuilder.createDelegate(jaxrsInterface, baseUriFromAnnotation, configKey);
}
@Override
@NoClassInterceptors
public void close() throws IOException {
if (mock == null) {
delegate.close();
}
}
@PreDestroy
@NoClassInterceptors
public void destroy() {
try {
if (mock == null) {
close();
}
} catch (IOException e) {
log.warn("Failed to close cdi-created rest client instance", e);
}
}
// used by generated code
@SuppressWarnings("unused")
@NoClassInterceptors
public Object getDelegate() {
return mock == null ? delegate : mock;
}
public void setMock(Object mock) {
this.mock = mock;
}
}
|
quarkusio/quarkus
|
extensions/resteasy-reactive/rest-client-reactive/runtime/src/main/java/io/quarkus/rest/client/reactive/runtime/RestClientReactiveCDIWrapperBase.java
|
Java
|
apache-2.0
| 1,476
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_25) on Tue Apr 28 18:49:25 EEST 2015 -->
<title>Generated Documentation (Untitled)</title>
<script type="text/javascript">
targetPage = "" + window.location.search;
if (targetPage != "" && targetPage != "undefined")
targetPage = targetPage.substring(1);
if (targetPage.indexOf(":") != -1 || (targetPage != "" && !validURL(targetPage)))
targetPage = "undefined";
function validURL(url) {
try {
url = decodeURIComponent(url);
}
catch (error) {
return false;
}
var pos = url.indexOf(".html");
if (pos == -1 || pos != url.length - 5)
return false;
var allowNumber = false;
var allowSep = false;
var seenDot = false;
for (var i = 0; i < url.length - 5; i++) {
var ch = url.charAt(i);
if ('a' <= ch && ch <= 'z' ||
'A' <= ch && ch <= 'Z' ||
ch == '$' ||
ch == '_' ||
ch.charCodeAt(0) > 127) {
allowNumber = true;
allowSep = true;
} else if ('0' <= ch && ch <= '9'
|| ch == '-') {
if (!allowNumber)
return false;
} else if (ch == '/' || ch == '.') {
if (!allowSep)
return false;
allowNumber = false;
allowSep = false;
if (ch == '.')
seenDot = true;
if (ch == '/' && seenDot)
return false;
} else {
return false;
}
}
return true;
}
function loadFrames() {
if (targetPage != "" && targetPage != "undefined")
top.classFrame.location = top.targetPage;
}
</script>
</head>
<frameset cols="20%,80%" title="Documentation frame" onload="top.loadFrames()">
<frameset rows="30%,70%" title="Left frames" onload="top.loadFrames()">
<frame src="overview-frame.html" name="packageListFrame" title="All Packages">
<frame src="allclasses-frame.html" name="packageFrame" title="All classes and interfaces (except non-static nested types)">
</frameset>
<frame src="overview-summary.html" name="classFrame" title="Package, class and interface descriptions" scrolling="yes">
<noframes>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<h2>Frame Alert</h2>
<p>This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client. Link to <a href="overview-summary.html">Non-frame version</a>.</p>
</noframes>
</frameset>
</html>
|
OhtuWearable/WearableDataServer
|
javadoc/index.html
|
HTML
|
apache-2.0
| 2,864
|
package jp.uphy.maven.svg.mojo;
import static jp.uphy.maven.svg.mojo.Constants.MOJO_NAME_RASTERIZE_DIRECTORY;
public class RasterizeDirectoryMojoTest extends AbstractRasterizeMojoTest {
public void testRasterizeDirectory() throws Exception {
executeMojo("rasterize-directory.xml", MOJO_NAME_RASTERIZE_DIRECTORY, RasterizeDirectoryMojo.class);
assertRasterizedImages(
new RasterizedImage("48x48/image1.png", 48, 48, "png"),
new RasterizedImage("48x48/image2.png", 48, 48, "png"),
new RasterizedImage("32x32/image1.png", 32, 32, "png"),
new RasterizedImage("32x32/image2.png", 32, 32, "png"),
new RasterizedImage("image1-24x24.png", 24, 24, "png"),
new RasterizedImage("image2-24x24.png", 24, 24, "png"));
}
public void testRasterizeDirectoryWithDefaults() throws Exception {
executeMojo("rasterize-directory-with-defaults.xml", MOJO_NAME_RASTERIZE_DIRECTORY, RasterizeDirectoryMojo.class);
assertRasterizedImages(
new RasterizedImage("48x48/image1.png", 48, 48, "png"),
new RasterizedImage("48x48/image2.png", 48, 48, "png"),
new RasterizedImage("32x32/image1.png", 32, 32, "png"),
new RasterizedImage("32x32/image2.png", 32, 32, "png"),
new RasterizedImage("image1+24x24.png", 24, 24, "png"),
new RasterizedImage("image2+24x24.png", 24, 24, "png"));
}
public void testRasterizeImageWithOutputsFromFiles() throws Exception {
executeMojo("rasterize-directory-outputs-from-files.xml", MOJO_NAME_RASTERIZE_DIRECTORY, RasterizeDirectoryMojo.class);
assertRasterizedImages(
new RasterizedImage("48x48/image1.jpg", 48, 48, "jpeg"),
new RasterizedImage("32x32/image1.jpg", 32, 32, "jpeg"),
new RasterizedImage("32x32/image2.jpg", 32, 32, "jpeg"),
new RasterizedImage("16x16/image2.jpg", 16, 16, "jpeg"));
}
}
|
Argelbargel/svg-rasterizer-maven-plugin
|
src/test/java/jp/uphy/maven/svg/mojo/RasterizeDirectoryMojoTest.java
|
Java
|
apache-2.0
| 2,037
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/transitional.dtd">
<html>
<head>
<meta HTTP-EQUIV=CONTENT-TYPE CONTENT="text/html; charset=utf-8">
<title>Slide 26</title>
</head>
<body text="#000000" bgcolor="#FFFFFF" link="#000080" vlink="#0000CC" alink="#000080">
<center>
<a href="text0.html">First page</a> <a href="text24.html">Back</a> <a href="text26.html">Continue</a> <a href="text68.html">Last page</a> <a href="WASM.htm">Overview</a> <a href="img25.html">Image</a></center><br>
<h1></h1>
<p>WASM – Exports</p>
<p><font color="#EEEEEE">(module</font></p>
<p><font color="#EEEEEE"> (type $0 (func (result i32)))</font></p>
<p><font color="#EEEEEE"> (func $main (type $0)</font></p>
<p><font color="#EEEEEE"> (i32.const 0)</font></p>
<p><font color="#EEEEEE"> )</font></p>
<p> <font color="#ACB20C">(</font><font color="#FF4000">export</font> <font color="#00A933">"main"</font> <font color="#ED4C05">(</font><font color="#2A6099">func</font> <font color="#FF8000">$main</font><font color="#650953">)</font><font color="#1E6A39">)</font></p>
<p><font color="#EEEEEE">)</font></p>
<p><font color="#EEEEEE">...</font></p>
<p><font color="#EEEEEE">; section "Function" (3)</font></p>
<p><font color="#EEEEEE">000000f: 03 ; section code</font></p>
<p><font color="#EEEEEE">0000010: 00 ; section size (guess)</font></p>
<p><font color="#EEEEEE">0000011: 01 ; num functions</font></p>
<p><font color="#EEEEEE">0000012: 00 ; function 0 signature index</font></p>
<p><font color="#EEEEEE">0000010: 02 ; FIXUP section size</font></p>
<p>; section "Export" (7)</p>
<p>0000013: 07 ; section code</p>
<p>0000014: 00 ; section size (guess)</p>
<p>0000015: 01 ; num exports</p>
<p><font color="#00A933">0000016: 04 ; string length</font></p>
<p><font color="#00A933">0000017: 6d61 696e main ; export name</font></p>
<p><font color="#2A6099">000001b: 00 ; export kind</font></p>
<p><font color="#FF8000">000001c: 00 ; export func index</font></p>
<p><font color="#EEEEEE">0000014: 08 ; FIXUP section size</font></p>
<p><font color="#EEEEEE">; section "Code" (10)</font></p>
<p><font color="#EEEEEE">000001d: 0a ; section code</font></p>
<p><font color="#EEEEEE">000001e: 00 ; section size (guess)</font></p>
<p><font color="#EEEEEE">000001f: 01 ; num functions</font></p>
<p><font color="#EEEEEE">; function body 0</font></p>
<p><font color="#EEEEEE">0000020: 00 ; func body size (guess)</font></p>
<p><font color="#EEEEEE">0000021: 00 ; local decl count</font></p>
<p><font color="#EEEEEE">0000022: 41 ; i32.const</font></p>
<p><font color="#EEEEEE">0000023: 00 ; i32 literal</font></p>
<p><font color="#EEEEEE">0000024: 0b ; end</font></p>
<p><font color="#EEEEEE">0000020: 04 ; FIXUP func body size</font></p>
<p><font color="#EEEEEE">000001e: 06 ; FIXUP section size</font></p>
<p><font color="#EEEEEE">...</font></p>
<p>It decodes into a vector of exports that represent the exports component of a module.</p>
<p>Export = <font color="#ACB20C">‘(’ </font><font color="#FF0000">‘export’ </font><font color="#00A933">name exported </font><font color="#1E6A39">‘)’</font></p>
<p><font color="#1E6A39">Exported = </font><font color="#BE480A">‘(’ </font><font color="#2A6099">‘func’ </font><font color="#FF8000">funcid </font><font color="#650953">‘)’</font></p>
<p><font color="#650953"></font></p>
<p><font color="#650953">https://webassembly.github.io/spec/core/text/modules.html#exports</font></p>
<p>4.</p>
</body>
</html>
|
xunilrj/sandbox
|
sources/webassembly/workshop/text25.html
|
HTML
|
apache-2.0
| 4,438
|
#ifndef _FULLSIMULATOR_H_
#define _FULLSIMULATOR_H_
#include <string>
#include <assertext.h>
#include <boost/shared_ptr.hpp>
#include <eigen3/Eigen/Dense>
#include <eigen3/Eigen/Sparse>
#include <FullElasticModel.h>
#include <JsonFilePaser.h>
using namespace std;
using namespace Eigen;
namespace SIMULATOR{
/**
* @class BaseFullSim base class for making simulation in full space, child
* class would implement different integration approaches (implicit,
* semi-implicit, and explicit integration method), and different constraint
* approaches (Lagrangian or Penalty method.).
*
*/
class BaseFullSim{
public:
BaseFullSim(){
h = 0.01;
alpha_k = 0.01;
alpha_m = 0.01;
correct_initialized = false;
}
BaseFullSim(pBaseFullModel def_model){
this->def_model = def_model;
h = 0.01;
alpha_k = 0.01;
alpha_m = 0.01;
correct_initialized = false;
}
virtual void setElasticModel(pBaseFullModel def_model){
this->def_model = def_model;
}
virtual bool init(const string init_filename){
UTILITY::JsonFilePaser jsonf;
if (!jsonf.open(init_filename)){
ERROR_LOG("failed to open" << init_filename);
return false;
}
correct_initialized = jsonf.read("h",h); assert_gt(h,0);
correct_initialized &= jsonf.read("alpha_m",alpha_m); assert_ge(alpha_m,0);
correct_initialized &= jsonf.read("alpha_k",alpha_k); assert_ge(alpha_k,0);
correct_initialized &= def_model->init(init_filename);
if (correct_initialized) BaseFullSim::setInitValue();
ERROR_LOG_COND("failed to initialze. ", correct_initialized);
return correct_initialized;
}
virtual bool prepare(){
const bool succ = def_model->prepare();
this->reset();
return succ;
}
bool initialized()const{
return correct_initialized;
}
void setU0(const VectorXd &u0){u = u0;}
void setV0(const VectorXd &v0){v = v0;}
virtual void setTimeStep(const double h){
assert_gt (h ,0.0f);
this->h = h;
}
virtual void setDampings(const double alpha_k,const double alpha_m){
assert_ge (alpha_k , 0.0f);
assert_ge (alpha_m , 0.0f);
this->alpha_k = alpha_k;
this->alpha_m = alpha_m;
}
virtual void reset(){
const int r = getDim();
v.resize(r);
v.setZero();
u.resize(r);
u.setZero();
fext.resize(r);
fext.setZero();
}
/**
* set constraints,where C_triplet is the triplet format of the constrain
* matrix, uc is displacements of the the constrained nodes (or the
* barycenters of constrained groups), where Cu = uc.
* C_rows, C_cols: the rows and cols of C.
*/
virtual void setConM(const VecT &C_triplet,const int C_rows,const int C_cols) = 0;
virtual void setUc(const VectorXd &uc){
this->uc = uc;
}
virtual void removeAllCon(){
uc.resize(0);
}
const VectorXd &getPosCon()const{
return uc;
}
// set external forces in fullspace.
void setExtForce(const VectorXd &full_fext){
this->fext = full_fext;
}
virtual void setExtForceOfNode(const double force[3],int vertex_id){
assert_ge(vertex_id,0);
assert_gt(fext.size(),(vertex_id*3+2));
fext[vertex_id*3+0] = force[0];
fext[vertex_id*3+1] = force[1];
fext[vertex_id*3+2] = force[2];
}
void setExtForceForAllNodes(const double force_x,const double force_y,const double force_z){
const int n = getDim()/3;
fext.resize(3*n);
for (int vertex_id = 0; vertex_id < n; ++vertex_id){
fext[vertex_id*3+0] = force_x;
fext[vertex_id*3+1] = force_y;
fext[vertex_id*3+2] = force_z;
}
}
// simulation
virtual bool forward() = 0;
// get results
const VectorXd &getU()const{
return u;
}
const VectorXd &getV()const{
return v;
}
VectorXd &getVelocity () {
return v;
}
VectorXd &getModifyU () {
return u;
}
VectorXd &getU(){
return u;
}
VectorXd &getV(){
return v;
}
int getDim()const{
if (def_model){
return def_model->dimension();
}
return 0;
}
double getTimestep()const{
return h;
}
double getAlphaK()const{
return alpha_k;
}
double getAlphaM()const{
return alpha_m;
}
protected:
void setInitValue(){
const int n3 = this->getDim();
v.resize(n3);
v.setZero();
u.resize(n3);
u.setZero();
fext.resize(n3);
fext.setZero();
}
protected:
pBaseFullModel def_model; // deformation data model, calculate F(u), K(u).
bool correct_initialized; // the forward() should only be called when this
// class is correctly initialized.
double h;
double alpha_k;
double alpha_m;
VectorXd v; // velocity.
VectorXd u; // displacements.
VectorXd fext;// external forces.
VectorXd uc;// displacements of the the constrained nodes (or the
// barycenters of the constrained groups) with respect to the
// rest shape.
};
typedef boost::shared_ptr<BaseFullSim> pBaseFullSim;
/**
* @class LagImpFullSim simulator in full space using Lagrangian constraints
* and implicit integration scheme.
* @see Doc/IntegrationMethods.pdf
*/
class LagImpFullSim: public BaseFullSim{
public:
LagImpFullSim():BaseFullSim(){}
LagImpFullSim(pBaseFullModel def_model):BaseFullSim(def_model){}
bool prepare(){
bool succ = false;
if (BaseFullSim::prepare()){
succ = def_model->evaluateM(M);
}
C_Ct_triplet.clear();
resetM_triplet();
return succ;
}
void setTimeStep(const double h){
BaseFullSim::setTimeStep(h);
resetM_triplet();
}
void setDampings(const double alpha_k,const double alpha_m){
BaseFullSim::setDampings(alpha_k, alpha_m);
resetM_triplet();
}
void setConM(const VecT &C_triplet,const int C_rows,const int C_cols);
void removeAllCon(){
BaseFullSim::removeAllCon();
C_Ct_triplet.clear();
C.resize(0,0);
}
bool forward();
protected:
bool assembleA();
bool assembleB();
bool resetM_triplet();
bool resetK_triplet();
void resetA_triplet();
void copyTriplet(VecT &Full_triplet, const VecT &sub_triplet, const int start)const;
protected:
VectorXd f; // internal forces.
SparseMatrix<double> M; // mass matrix.
SparseMatrix<double> C; // constraint matrix.
/**
* right hand side and left hand side for the linear system at each time
* step to sovle for the integration, where
* |H C^t|
* A = |C O |, b = M*v + h*(fext-f),
* and H = (1+h*alpha_m)*M + h*(h+alpha_k)*K(u),
* C is the constraint matrix.
*/
SparseMatrix<double> A;
VectorXd b;
/**
* Inorder to fastly assemble sparse matrix A, we record the triplets for
* each submatrix in A_triplet, then generate A from A_triplet each step.
* A_triplet is consisted of three parts:
* 1. scaled mass matrix: update when intialization or time step is changed.
* 2. constraint matrix and its transpose, update when constraints is changed.
* 3. scaled stiffness matrix, update at each step.
*/
VecT C_Ct_triplet; // C and C^t.
VecT Scaled_M_triplet; // (1+alpha_m)*M.
VecT Scaled_K_triplet; // h*(h+alpha_k)*K(u).
VecT A_triplet; // [scaled_M, C, C^T, scaled_K].
};
typedef boost::shared_ptr<LagImpFullSim> pLagImpFullSim;
/**
* @class PenStaticFullSim quasi-static simulator with penalty constraints,
* and we solve the nonlinear equation using newton method.
* @see Doc/StaticDeformation.pdf
*/
class PenStaticFullSim: public BaseFullSim{
public:
PenStaticFullSim():BaseFullSim(){
lambda = 100.0f;
max_it = 5;
tolerance = 0.1f;
}
PenStaticFullSim(pBaseFullModel def_model):BaseFullSim(def_model){
lambda = 100.0f;
max_it = 5;
tolerance = 0.1f;
}
bool init(const string init_filename);
void setConM(const VecT &C_triplet,const int C_rows,const int C_cols);
void setUc(const VectorXd &uc);
void removeAllCon();
virtual bool forward();
protected:
const VectorXd &grad(const VectorXd &u);
const SparseMatrix<double> &jac(const VectorXd &u);
protected:
double lambda; // penalty for con.
SparseMatrix<double> C; // constraint matrix.
SparseMatrix<double> lambda_CtC; // C^t*C
VectorXd lambda_CtUc; // C^t*Uc
VectorXd g;
SparseMatrix<double> J;
int max_it;
double tolerance;
};
/**
* @class PenStaticFullSim semi-implicit simulator with penalty constraints.
* @see Doc/IntegrationMethods.pdf
* @note currently, we only use the mass-damping, and ignore the stiffness damping.
*/
class PenSemiImpFullSim: public PenStaticFullSim{
public:
PenSemiImpFullSim(): PenStaticFullSim(){}
PenSemiImpFullSim(pBaseFullModel def_model):PenStaticFullSim(def_model){}
bool prepare();
bool forward();
private:
DiagonalMatrix<double,-1> h_M_inv; // h*(M^{-1})
};
typedef boost::shared_ptr<PenSemiImpFullSim> pPenSemiImpFullSim;
}//end of namespace
#endif /* _FULLSIMULATOR_H_ */
|
wegatron/embedded_thin_shell
|
src/volume_simulator/solid_elastic/ElasticModel/FullSimulator.h
|
C
|
apache-2.0
| 8,687
|
webtechWS1314
=============
Projekt für Webtechnologien
Sven Weiser
Michael Gehring
|
GreatBounty/webtechWS1314
|
README.md
|
Markdown
|
apache-2.0
| 87
|
#include <windows.h>
#include "class.MojaTrieda.hpp"
#include "../com.carlos.architecture/DllExports.h"
#include "../com.carlos.architecture/modules/class.ModulVypocitaniaPolohy.hpp"
#include "../com.carlos.architecture/configuration/class.Configuration.hpp"
#ifdef _DEBUG
#pragma comment(lib, "../Debug/com.carlos.architecture.lib")
#else
#pragma comment(lib, "../Release/com.carlos.architecture.lib")
#endif
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void*) {
printf("Dll nacitane\n");
return 1;
}
using namespace Architecture;
class DllModulVypocitaniaPolohy : public ModulVypocitaniaPolohy, public MojaTrieda {
public:
virtual Out vypocitajPolohuTextu(In in) {
// Vzpocitanie priamej vydialenosti detegovaneho objektu od auta
double distanceInM = calculateDistanceInM(in.gps, in.gpsPolohaObjektu);
// Velkost pixelu v metroch na okne auta
double sizeOfPixelInMInWidth = CAR_WINDOW_WIDTH_IN_M/CAR_WINDOW_WIDTH_IN_PX;
double sizeOfPixelInMInHeight = CAR_WINDOW_HEIGHT_IN_M/CAR_WINDOW_HEIGHT_IN_PX;
// Poloha objektu v okne pride v pixeloch
double objPosInWindowInPxX = in.polohaObjektu.center.x-in.polohaObjektu.size.width/2;
double objPosInWindowInPxY = in.polohaObjektu.center.y-in.polohaObjektu.size.height/2;
// Upravena poloha objektu v okne v metroch
double objPosInWindowInMX = objPosInWindowInPxX*sizeOfPixelInMInWidth;
double objPosInWindowInMY = objPosInWindowInPxY*sizeOfPixelInMInHeight;
// Vypocitame cosinus na upravu priamej vzdialenosti medzi autom a objektom
double cos = calculateCosBtwnCameraAndObj(objPosInWindowInMX);
// Pozicia detegovaneho objektu v metroch
Point3f detecObjPosition;
detecObjPosition.x = objPosInWindowInMX;
detecObjPosition.y = objPosInWindowInMY;
detecObjPosition.z = - distanceInM * cos;
// Pozicia hlavy pride v milimetroch, premenime ju na metre
Point3f headPosition;
headPosition.x = in.rotaciaHlavy.x/1000.;
headPosition.y = in.rotaciaHlavy.y/1000.;
headPosition.z = in.rotaciaHlavy.z/1000.;
Point2f textPos = calculateTextPos(headPosition, detecObjPosition);
Out out;
out.id = in.id;
out.najdeny = true;
out.polohaTextu = normalizeTextPosToInterval(textPos);
return out;
}
virtual double getHeadPosition(Point3f headPosition) {
// Pozicia hlavy pride v milimetroch, premenime ju na metre
headPosition.x = headPosition.x/1000.;
headPosition.y = headPosition.y/1000.;
headPosition.z = headPosition.z/1000.;
// Vytvorime bod, ktory reprezentuje polchu na ktoru sa premieta video,
// aby sme vedeli vypocitat v akom uhle sa nachadza pouzivatelova hlava
// v ramci osi x
Point3f projectionAreaPosition;
projectionAreaPosition.x = CAR_WINDOW_WIDTH_IN_M/2;
projectionAreaPosition.y = CAR_WINDOW_HEIGHT_IN_M/2;
projectionAreaPosition.z = - PROJECTION_AREA_DISTANCE_FROM_CAR_WINDOW_IN_M;
Point2f intersection = calculateTextPos(headPosition, projectionAreaPosition);
return normalizeHeadPosInWindowToInterval(intersection.x);
}
virtual void init() {
/*
* Z configuracie musim ziskat data:
* - PROJECTION_AREA_DISTANCE_FROM_CAR_WINDOW_IN_M
* - CAR_WINDOW_WIDTH_IN_M
* - CAR_WINDOW_HEIGHT_IN_M
* - CAMERA_DISTANCE_FROM_WINDOW_IN_M
* - CAMERA_X_POSITION_IN_WINDOW_IN_M
*/
PROJECTION_AREA_DISTANCE_FROM_CAR_WINDOW_IN_M =
Configuration::getInstance().getConfigf("projection_area_distance_from_car_window_in_m");
CAR_WINDOW_WIDTH_IN_M = Configuration::getInstance().getConfigf("CAR_WINDOW_WIDTH_IN_M");
CAR_WINDOW_HEIGHT_IN_M = Configuration::getInstance().getConfigf("CAR_WINDOW_HEIGHT_IN_M");
CAMERA_DISTANCE_FROM_WINDOW_IN_M = Configuration::getInstance().getConfigf("CAMERA_DISTANCE_FROM_WINDOW_IN_M");
CAMERA_X_POSITION_IN_WINDOW_IN_M = Configuration::getInstance().getConfigf("CAMERA_X_POSITION_IN_WINDOW_IN_M");
}
private:
Point2f normalizeTextPosToInterval(Point2f textPosition) {
if (textPosition.x < 0.0) {
textPosition.x = 0.0;
}
if (textPosition.x > CAR_WINDOW_WIDTH_IN_M) {
textPosition.x = CAR_WINDOW_WIDTH_IN_M;
}
if (textPosition.y < 0.0) {
textPosition.y = 0.0;
}
if (textPosition.y > CAR_WINDOW_HEIGHT_IN_M) {
textPosition.y = CAR_WINDOW_HEIGHT_IN_M;
}
textPosition.x /= CAR_WINDOW_WIDTH_IN_M;
textPosition.y /= CAR_WINDOW_HEIGHT_IN_M;
return textPosition;
}
double normalizeHeadPosInWindowToInterval(double xPosInM) {
if (xPosInM < CAR_WINDOW_WIDTH_IN_M/2) { // Lava polka okna
// Ak je to mimo laveho okraju okna
if (xPosInM < 0.0) {
xPosInM = 0.0;
}
xPosInM /= (CAR_WINDOW_WIDTH_IN_M/2);
return xPosInM - 1.0;
} else if (xPosInM > CAR_WINDOW_WIDTH_IN_M/2) { // Prava polka okna
// Ak je to mimo praveho okraja okna
if (xPosInM > CAR_WINDOW_WIDTH_IN_M) {
xPosInM = CAR_WINDOW_WIDTH_IN_M;
}
xPosInM -= (CAR_WINDOW_WIDTH_IN_M/2);
xPosInM /= (CAR_WINDOW_WIDTH_IN_M/2);
return xPosInM;
} else { // Stred okna
return 0.0;
}
}
};
IMPEXP void* callFactory() {
return static_cast< void* > (new DllModulVypocitaniaPolohy());
}
|
sekys/Carlos
|
com.carlos.textPosModule/DllMain.cpp
|
C++
|
apache-2.0
| 5,058
|
// Copyright 2009 Todd Ditchendorf
//
// 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.
#import "FUBasePreferences.h"
// Abstract base class for FUUserthingPreferences and FUUserstylePreferences
@interface FUUserthingPreferences : FUBasePreferences {
NSArrayController *arrayController;
NSTextView *textView;
NSMutableArray *userthings;
}
- (void)insertObject:(NSMutableDictionary *)dict inUserthingsAtIndex:(NSInteger)i;
- (void)removeObjectFromUserthingsAtIndex:(NSInteger)i;
- (void)startObservingRule:(NSMutableDictionary *)rule;
- (void)stopObservingRule:(NSMutableDictionary *)rule;
- (void)loadUserthings;
- (void)storeUserthings;
@property (nonatomic, retain) IBOutlet NSArrayController *arrayController;
@property (nonatomic, retain) IBOutlet NSTextView *textView;
@property (nonatomic, retain) NSMutableArray *userthings;
@end
|
thekarladam/fluidium
|
Fluidium/src/FUUserthingPreferences.h
|
C
|
apache-2.0
| 1,370
|
// Copyright 2019 The MediaPipe Authors.
//
// 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 MEDIAPIPE_PORT_PORT_H_
#define MEDIAPIPE_PORT_PORT_H_
#include "absl/base/port.h"
#endif // MEDIAPIPE_PORT_PORT_H_
|
google/mediapipe
|
mediapipe/framework/port/port.h
|
C
|
apache-2.0
| 727
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_151) on Mon Jun 22 05:15:32 MST 2020 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Package org.wildfly.swarm.config.jca (BOM: * : All 2.7.1.Final-SNAPSHOT API)</title>
<meta name="date" content="2020-06-22">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="Uses of Package org.wildfly.swarm.config.jca (BOM: * : All 2.7.1.Final-SNAPSHOT API)";
}
}
catch(err) {
}
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li>Class</li>
<li class="navBarCell1Rev">Use</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">Thorntail API, 2.7.1.Final-SNAPSHOT</div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/wildfly/swarm/config/jca/package-use.html" target="_top">Frames</a></li>
<li><a href="package-use.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="header">
<h1 title="Uses of Package org.wildfly.swarm.config.jca" class="title">Uses of Package<br>org.wildfly.swarm.config.jca</h1>
</div>
<div class="contentContainer">
<ul class="blockList">
<li class="blockList">
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing packages, and an explanation">
<caption><span>Packages that use <a href="../../../../../org/wildfly/swarm/config/jca/package-summary.html">org.wildfly.swarm.config.jca</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Package</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="#org.wildfly.swarm.config">org.wildfly.swarm.config</a></td>
<td class="colLast"> </td>
</tr>
<tr class="rowColor">
<td class="colFirst"><a href="#org.wildfly.swarm.config.jca">org.wildfly.swarm.config.jca</a></td>
<td class="colLast"> </td>
</tr>
</tbody>
</table>
</li>
<li class="blockList"><a name="org.wildfly.swarm.config">
<!-- -->
</a>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing classes, and an explanation">
<caption><span>Classes in <a href="../../../../../org/wildfly/swarm/config/jca/package-summary.html">org.wildfly.swarm.config.jca</a> used by <a href="../../../../../org/wildfly/swarm/config/package-summary.html">org.wildfly.swarm.config</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colOne" scope="col">Class and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ArchiveValidation.html#org.wildfly.swarm.config">ArchiveValidation</a>
<div class="block">Archive validation for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ArchiveValidationConsumer.html#org.wildfly.swarm.config">ArchiveValidationConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ArchiveValidationSupplier.html#org.wildfly.swarm.config">ArchiveValidationSupplier</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BeanValidation.html#org.wildfly.swarm.config">BeanValidation</a>
<div class="block">Bean validation (JSR-303) for resource adapters</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BeanValidationConsumer.html#org.wildfly.swarm.config">BeanValidationConsumer</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BeanValidationSupplier.html#org.wildfly.swarm.config">BeanValidationSupplier</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BootstrapContext.html#org.wildfly.swarm.config">BootstrapContext</a>
<div class="block">Bootstrap context for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BootstrapContextConsumer.html#org.wildfly.swarm.config">BootstrapContextConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BootstrapContextSupplier.html#org.wildfly.swarm.config">BootstrapContextSupplier</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/CachedConnectionManager.html#org.wildfly.swarm.config">CachedConnectionManager</a>
<div class="block">Cached connection manager for resource adapters</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/CachedConnectionManagerConsumer.html#org.wildfly.swarm.config">CachedConnectionManagerConsumer</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/CachedConnectionManagerSupplier.html#org.wildfly.swarm.config">CachedConnectionManagerSupplier</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanager.html#org.wildfly.swarm.config">DistributedWorkmanager</a>
<div class="block">DistributedWorkManager for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanagerConsumer.html#org.wildfly.swarm.config">DistributedWorkmanagerConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanagerSupplier.html#org.wildfly.swarm.config">DistributedWorkmanagerSupplier</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/Tracer.html#org.wildfly.swarm.config">Tracer</a>
<div class="block">Tracer for resource adapters</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/TracerConsumer.html#org.wildfly.swarm.config">TracerConsumer</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/TracerSupplier.html#org.wildfly.swarm.config">TracerSupplier</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/Workmanager.html#org.wildfly.swarm.config">Workmanager</a>
<div class="block">WorkManager for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/WorkmanagerConsumer.html#org.wildfly.swarm.config">WorkmanagerConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/WorkmanagerSupplier.html#org.wildfly.swarm.config">WorkmanagerSupplier</a> </td>
</tr>
</tbody>
</table>
</li>
<li class="blockList"><a name="org.wildfly.swarm.config.jca">
<!-- -->
</a>
<table class="useSummary" border="0" cellpadding="3" cellspacing="0" summary="Use table, listing classes, and an explanation">
<caption><span>Classes in <a href="../../../../../org/wildfly/swarm/config/jca/package-summary.html">org.wildfly.swarm.config.jca</a> used by <a href="../../../../../org/wildfly/swarm/config/jca/package-summary.html">org.wildfly.swarm.config.jca</a></span><span class="tabEnd"> </span></caption>
<tr>
<th class="colOne" scope="col">Class and Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ArchiveValidation.html#org.wildfly.swarm.config.jca">ArchiveValidation</a>
<div class="block">Archive validation for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ArchiveValidationConsumer.html#org.wildfly.swarm.config.jca">ArchiveValidationConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BeanValidation.html#org.wildfly.swarm.config.jca">BeanValidation</a>
<div class="block">Bean validation (JSR-303) for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BeanValidationConsumer.html#org.wildfly.swarm.config.jca">BeanValidationConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BootstrapContext.html#org.wildfly.swarm.config.jca">BootstrapContext</a>
<div class="block">Bootstrap context for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/BootstrapContextConsumer.html#org.wildfly.swarm.config.jca">BootstrapContextConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/CachedConnectionManager.html#org.wildfly.swarm.config.jca">CachedConnectionManager</a>
<div class="block">Cached connection manager for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/CachedConnectionManagerConsumer.html#org.wildfly.swarm.config.jca">CachedConnectionManagerConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanager.html#org.wildfly.swarm.config.jca">DistributedWorkmanager</a>
<div class="block">DistributedWorkManager for resource adapters</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanager.DistributedWorkmanagerResources.html#org.wildfly.swarm.config.jca">DistributedWorkmanager.DistributedWorkmanagerResources</a>
<div class="block">Child mutators for DistributedWorkmanager</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanager.Policy.html#org.wildfly.swarm.config.jca">DistributedWorkmanager.Policy</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanager.Selector.html#org.wildfly.swarm.config.jca">DistributedWorkmanager.Selector</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/DistributedWorkmanagerConsumer.html#org.wildfly.swarm.config.jca">DistributedWorkmanagerConsumer</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/LongRunningThreads.html#org.wildfly.swarm.config.jca">LongRunningThreads</a>
<div class="block">A thread pool executor with a bounded queue where threads submittings tasks
may block.</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/LongRunningThreadsConsumer.html#org.wildfly.swarm.config.jca">LongRunningThreadsConsumer</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/LongRunningThreadsSupplier.html#org.wildfly.swarm.config.jca">LongRunningThreadsSupplier</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ShortRunningThreads.html#org.wildfly.swarm.config.jca">ShortRunningThreads</a>
<div class="block">A thread pool executor with a bounded queue where threads submittings tasks
may block.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ShortRunningThreadsConsumer.html#org.wildfly.swarm.config.jca">ShortRunningThreadsConsumer</a> </td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/ShortRunningThreadsSupplier.html#org.wildfly.swarm.config.jca">ShortRunningThreadsSupplier</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/Tracer.html#org.wildfly.swarm.config.jca">Tracer</a>
<div class="block">Tracer for resource adapters</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/TracerConsumer.html#org.wildfly.swarm.config.jca">TracerConsumer</a> </td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/Workmanager.html#org.wildfly.swarm.config.jca">Workmanager</a>
<div class="block">WorkManager for resource adapters</div>
</td>
</tr>
<tr class="altColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/Workmanager.WorkmanagerResources.html#org.wildfly.swarm.config.jca">Workmanager.WorkmanagerResources</a>
<div class="block">Child mutators for Workmanager</div>
</td>
</tr>
<tr class="rowColor">
<td class="colOne"><a href="../../../../../org/wildfly/swarm/config/jca/class-use/WorkmanagerConsumer.html#org.wildfly.swarm.config.jca">WorkmanagerConsumer</a> </td>
</tr>
</tbody>
</table>
</li>
</ul>
</div>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li>Class</li>
<li class="navBarCell1Rev">Use</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
<div class="aboutLanguage">Thorntail API, 2.7.1.Final-SNAPSHOT</div>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev</li>
<li>Next</li>
</ul>
<ul class="navList">
<li><a href="../../../../../index.html?org/wildfly/swarm/config/jca/package-use.html" target="_top">Frames</a></li>
<li><a href="package-use.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright © 2020 <a href="http://www.jboss.org">JBoss by Red Hat</a>. All rights reserved.</small></p>
</body>
</html>
|
wildfly-swarm/wildfly-swarm-javadocs
|
2.7.1.Final-SNAPSHOT/apidocs/org/wildfly/swarm/config/jca/package-use.html
|
HTML
|
apache-2.0
| 16,870
|
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
#
from .TProtocol import TType, TProtocolBase, TProtocolException
from struct import pack, unpack
class TBinaryProtocol(TProtocolBase):
"""Binary implementation of the Thrift protocol driver."""
# NastyHaxx. Python 2.4+ on 32-bit machines forces hex constants to be
# positive, converting this into a long. If we hardcode the int value
# instead it'll stay in 32 bit-land.
# VERSION_MASK = 0xffff0000
VERSION_MASK = -65536
# VERSION_1 = 0x80010000
VERSION_1 = -2147418112
TYPE_MASK = 0x000000ff
def __init__(self, trans, strictRead=False, strictWrite=True, **kwargs):
TProtocolBase.__init__(self, trans)
self.strictRead = strictRead
self.strictWrite = strictWrite
self.string_length_limit = kwargs.get('string_length_limit', None)
self.container_length_limit = kwargs.get('container_length_limit', None)
def _check_string_length(self, length):
self._check_length(self.string_length_limit, length)
def _check_container_length(self, length):
self._check_length(self.container_length_limit, length)
def writeMessageBegin(self, name, type, seqid):
if self.strictWrite:
self.writeI32(TBinaryProtocol.VERSION_1 | type)
self.writeString(name)
self.writeI32(seqid)
else:
self.writeString(name)
self.writeByte(type)
self.writeI32(seqid)
def writeMessageEnd(self):
pass
def writeStructBegin(self, name):
pass
def writeStructEnd(self):
pass
def writeFieldBegin(self, name, type, id):
self.writeByte(type)
self.writeI16(id)
def writeFieldEnd(self):
pass
def writeFieldStop(self):
self.writeByte(TType.STOP)
def writeMapBegin(self, ktype, vtype, size):
self.writeByte(ktype)
self.writeByte(vtype)
self.writeI32(size)
def writeMapEnd(self):
pass
def writeListBegin(self, etype, size):
self.writeByte(etype)
self.writeI32(size)
def writeListEnd(self):
pass
def writeSetBegin(self, etype, size):
self.writeByte(etype)
self.writeI32(size)
def writeSetEnd(self):
pass
def writeBool(self, bool):
if bool:
self.writeByte(1)
else:
self.writeByte(0)
def writeByte(self, byte):
buff = pack("!b", byte)
self.trans.write(buff)
def writeI16(self, i16):
buff = pack("!h", i16)
self.trans.write(buff)
def writeI32(self, i32):
buff = pack("!i", i32)
self.trans.write(buff)
def writeI64(self, i64):
buff = pack("!q", i64)
self.trans.write(buff)
def writeDouble(self, dub):
buff = pack("!d", dub)
self.trans.write(buff)
def writeBinary(self, str):
self.writeI32(len(str))
self.trans.write(str)
def readMessageBegin(self):
sz = self.readI32()
if sz < 0:
version = sz & TBinaryProtocol.VERSION_MASK
if version != TBinaryProtocol.VERSION_1:
raise TProtocolException(
type=TProtocolException.BAD_VERSION,
message='Bad version in readMessageBegin: %d' % (sz))
type = sz & TBinaryProtocol.TYPE_MASK
name = self.readString()
seqid = self.readI32()
else:
if self.strictRead:
raise TProtocolException(type=TProtocolException.BAD_VERSION,
message='No protocol version header')
name = self.trans.readAll(sz)
type = self.readByte()
seqid = self.readI32()
return (name, type, seqid)
def readMessageEnd(self):
pass
def readStructBegin(self):
pass
def readStructEnd(self):
pass
def readFieldBegin(self):
type = self.readByte()
if type == TType.STOP:
return (None, type, 0)
id = self.readI16()
return (None, type, id)
def readFieldEnd(self):
pass
def readMapBegin(self):
ktype = self.readByte()
vtype = self.readByte()
size = self.readI32()
self._check_container_length(size)
return (ktype, vtype, size)
def readMapEnd(self):
pass
def readListBegin(self):
etype = self.readByte()
size = self.readI32()
self._check_container_length(size)
return (etype, size)
def readListEnd(self):
pass
def readSetBegin(self):
etype = self.readByte()
size = self.readI32()
self._check_container_length(size)
return (etype, size)
def readSetEnd(self):
pass
def readBool(self):
byte = self.readByte()
if byte == 0:
return False
return True
def readByte(self):
buff = self.trans.readAll(1)
val, = unpack('!b', buff)
return val
def readI16(self):
buff = self.trans.readAll(2)
val, = unpack('!h', buff)
return val
def readI32(self):
buff = self.trans.readAll(4)
val, = unpack('!i', buff)
return val
def readI64(self):
buff = self.trans.readAll(8)
val, = unpack('!q', buff)
return val
def readDouble(self):
buff = self.trans.readAll(8)
val, = unpack('!d', buff)
return val
def readBinary(self):
size = self.readI32()
self._check_string_length(size)
s = self.trans.readAll(size)
return s
class TBinaryProtocolFactory(object):
def __init__(self, strictRead=False, strictWrite=True, **kwargs):
self.strictRead = strictRead
self.strictWrite = strictWrite
self.string_length_limit = kwargs.get('string_length_limit', None)
self.container_length_limit = kwargs.get('container_length_limit', None)
def getProtocol(self, trans):
prot = TBinaryProtocol(trans, self.strictRead, self.strictWrite,
string_length_limit=self.string_length_limit,
container_length_limit=self.container_length_limit)
return prot
class TBinaryProtocolAccelerated(TBinaryProtocol):
"""C-Accelerated version of TBinaryProtocol.
This class does not override any of TBinaryProtocol's methods,
but the generated code recognizes it directly and will call into
our C module to do the encoding, bypassing this object entirely.
We inherit from TBinaryProtocol so that the normal TBinaryProtocol
encoding can happen if the fastbinary module doesn't work for some
reason. (TODO(dreiss): Make this happen sanely in more cases.)
In order to take advantage of the C module, just use
TBinaryProtocolAccelerated instead of TBinaryProtocol.
NOTE: This code was contributed by an external developer.
The internal Thrift team has reviewed and tested it,
but we cannot guarantee that it is production-ready.
Please feel free to report bugs and/or success stories
to the public mailing list.
"""
pass
class TBinaryProtocolAcceleratedFactory(object):
def __init__(self,
string_length_limit=None,
container_length_limit=None):
self.string_length_limit = string_length_limit
self.container_length_limit = container_length_limit
def getProtocol(self, trans):
return TBinaryProtocolAccelerated(
trans,
string_length_limit=self.string_length_limit,
container_length_limit=self.container_length_limit)
|
reTXT/thrift
|
lib/py/src/protocol/TBinaryProtocol.py
|
Python
|
apache-2.0
| 7,772
|
-- ALF implementation for ngx_lua/Kong
-- ALF version: 1.1.0
-- @version 2.0.0
-- @see https://github.com/Kong/galileo-agent-spec
--
-- Incompatibilities with ALF 1.1 and important notes
-- ==================================================
-- * The following fields cannot be retrieved as of ngx_lua 0.10.2:
-- * response.statusText
-- * response.headersSize
--
-- * Kong can modify the request/response due to its nature, hence,
-- we distinguish the original req/res from the current req/res
-- * request.headersSize will be the size of the _original_ headers
-- received by Kong
-- * request.headers will contain the _current_ headers
-- * response.headers will contain the _current_ headers
--
-- * bodyCaptured properties are determined using HTTP headers
-- * timings.blocked is ignored
-- * timings.connect is ignored
local cjson = require "cjson.safe"
local resp_get_headers = ngx.resp.get_headers
local req_start_time = ngx.req.start_time
local req_get_method = ngx.req.get_method
local req_get_headers = ngx.req.get_headers
local req_get_uri_args = ngx.req.get_uri_args
local encode_base64 = ngx.encode_base64
local http_version = ngx.req.http_version
local setmetatable = setmetatable
local tonumber = tonumber
local os_date = os.date
local pairs = pairs
local type = type
local gsub = string.gsub
local fmt = string.format
local _M = {
_VERSION = "2.0.0",
_ALF_VERSION = "1.1.0",
_ALF_CREATOR = "galileo-agent-kong"
}
local _mt = {
__index = _M
}
function _M.new(log_bodies, server_addr)
local alf = {
server_addr = server_addr,
log_bodies = log_bodies,
entries = {}
}
return setmetatable(alf, _mt)
end
-- Convert a table such as returned by ngx.*.get_headers()
-- to integer-indexed arrays.
local function hash_to_array(t)
local arr = setmetatable({}, cjson.empty_array_mt)
for k, v in pairs(t) do
if type(v) == "table" then
for i = 1, #v do
arr[#arr+1] = {name = k, value = v[i]}
end
else
arr[#arr+1] = {name = k, value = v}
end
end
return arr
end
-- Calculate an approximation of header size (it doesn't calculate white
-- space that may be sorrounding values, other than that it's accurate)
local function calculate_headers_size(request_line, headers)
local size = 0
for k, v in pairs(headers) do
if type(v) == "table" then
for _, y in ipairs(v) do
size = size + #k + 2 + #tostring(y) + 2 --First 2 is semicolon + space
end
else
size = size + #k + 2 + #tostring(v) + 2 --First 2 is semicolon + space
end
end
return #request_line + 2 + size + 2 -- 2 it's \r\n, 4 it's trailing \r\n\r\n
end
local function get_header(t, name, default)
local v = t[name]
if not v then
return default
elseif type(v) == "table" then
return v[#v]
end
return v
end
--- Add an entry to the ALF's `entries`
-- @param[type=table] _ngx The ngx table, containing .var and .ctx
-- @param[type=string] req_body_str The request body
-- @param[type=string] res_body_str The response body
-- @treturn table The entry created
-- @treturn number The new size of the `entries` array
function _M:add_entry(_ngx, req_body_str, resp_body_str)
if not self.entries then
return nil, "no entries table"
elseif not _ngx then
return nil, "arg #1 (_ngx) must be given"
elseif req_body_str ~= nil and type(req_body_str) ~= "string" then
return nil, "arg #2 (req_body_str) must be a string"
elseif resp_body_str ~= nil and type(resp_body_str) ~= "string" then
return nil, "arg #3 (resp_body_str) must be a string"
end
-- retrieval
local var = _ngx.var
local ctx = _ngx.ctx
local http_version = "HTTP/" .. http_version()
local method = req_get_method()
local request_headers = req_get_headers()
local request_content_len = get_header(request_headers, "content-length", 0)
local request_transfer_encoding = get_header(request_headers, "transfer-encoding")
local request_content_type = get_header(request_headers, "content-type",
"application/octet-stream")
-- if log_bodies is false, we don't want to still call
-- ngx.req.read_body() anyways, hence we rely on RFC 2616
-- to determine if the request seems to have a body.
local req_has_body = tonumber(request_content_len) > 0
or request_transfer_encoding ~= nil
or request_content_type == "multipart/byteranges"
local resp_headers = resp_get_headers()
local resp_content_len = get_header(resp_headers, "content-length", 0)
local resp_transfer_encoding = get_header(resp_headers, "transfer-encoding")
local resp_content_type = get_header(resp_headers, "content-type",
"application/octet-stream")
local resp_has_body = tonumber(resp_content_len) > 0
or resp_transfer_encoding ~= nil
or resp_content_type == "multipart/byteranges"
-- request.postData. we don't check has_body here, but rather
-- stick to what the request really contains, since it was
-- already read anyways.
local post_data, response_content
local req_body_size, resp_body_size
if self.log_bodies then
if req_body_str then
req_body_size = #req_body_str
post_data = {
text = encode_base64(req_body_str),
encoding = "base64",
mimeType = request_content_type
}
end
if resp_body_str then
resp_body_size = #resp_body_str
response_content = {
text = encode_base64(resp_body_str),
encoding = "base64",
mimeType = resp_content_type
}
end
end
if not req_body_size then
req_body_size = tonumber(request_content_len) or 0
end
if not resp_body_size then
resp_body_size = tonumber(resp_content_len) or 0
end
-- timings
local send_t = ctx.KONG_PROXY_LATENCY or 0
local wait_t = ctx.KONG_WAITING_TIME or 0
local receive_t = ctx.KONG_RECEIVE_TIME or 0
local idx = #self.entries + 1
self.entries[idx] = {
time = send_t + wait_t + receive_t,
startedDateTime = os_date("!%Y-%m-%dT%TZ", req_start_time()),
serverIPAddress = self.server_addr,
clientIPAddress = var.remote_addr,
request = {
httpVersion = http_version,
method = method,
url = var.scheme .. "://" .. var.host .. var.request_uri,
queryString = hash_to_array(req_get_uri_args()),
headers = hash_to_array(request_headers),
headersSize = calculate_headers_size(
fmt("%s %s %s", method, var.request_uri, http_version),
request_headers),
postData = post_data,
bodyCaptured = req_has_body,
bodySize = req_body_size,
},
response = {
status = _ngx.status,
statusText = "",
httpVersion = http_version,
headers = hash_to_array(resp_headers),
content = response_content,
headersSize = 0,
bodyCaptured = resp_has_body,
bodySize = resp_body_size
},
timings = {
send = send_t,
wait = wait_t,
receive = receive_t
}
}
return self.entries[idx], idx
end
local buf = {
version = _M._ALF_VERSION,
serviceToken = nil,
environment = nil,
har = {
log = {
creator = {
name = _M._ALF_CREATOR,
version = _M._VERSION
},
entries = nil
}
}
}
local _alf_max_size = 20 * 2^20
--- Encode the current ALF to JSON
-- @param[type=string] service_token The ALF `serviceToken`
-- @param[type=string] environment (optional) The ALF `environment`
-- @treturn string The ALF, JSON encoded
function _M:serialize(service_token, environment)
if not self.entries then
return nil, "no entries table"
elseif type(service_token) ~= "string" then
return nil, "arg #1 (service_token) must be a string"
elseif environment ~= nil and type(environment) ~= "string" then
return nil, "arg #2 (environment) must be a string"
end
buf.serviceToken = service_token
buf.environment = environment
buf.har.log.entries = self.entries
local json = cjson.encode(buf)
if #json > _alf_max_size then
return nil, "ALF too large (> 20MB)"
end
return gsub(json, "\\/", "/"), #self.entries
end
--- Empty the ALF
function _M:reset()
self.entries = {}
end
return _M
|
jebenexer/kong
|
kong/plugins/galileo/alf.lua
|
Lua
|
apache-2.0
| 8,283
|
package jadx.core.deobf;
import org.jetbrains.annotations.*;
import org.slf4j.*;
import java.io.*;
import java.util.*;
import jadx.api.*;
import jadx.core.dex.attributes.*;
import jadx.core.dex.attributes.nodes.*;
import jadx.core.dex.info.*;
import jadx.core.dex.instructions.args.*;
import jadx.core.dex.nodes.*;
public class Deobfuscator {
private static final Logger LOG = LoggerFactory.getLogger(Deobfuscator.class);
private static final boolean DEBUG = false;
public static final String CLASS_NAME_SEPARATOR = ".";
public static final String INNER_CLASS_SEPARATOR = "$";
private final IJadxArgs args;
@NotNull
private final List<DexNode> dexNodes;
private final DeobfPresets deobfPresets;
private final Map<ClassInfo, DeobfClsInfo> clsMap = new HashMap<ClassInfo, DeobfClsInfo>();
private final Map<FieldInfo, String> fldMap = new HashMap<FieldInfo, String>();
private final Map<MethodInfo, String> mthMap = new HashMap<MethodInfo, String>();
private final Map<MethodInfo, OverridedMethodsNode> ovrdMap = new HashMap<MethodInfo, OverridedMethodsNode>();
private final List<OverridedMethodsNode> ovrd = new ArrayList<OverridedMethodsNode>();
private final PackageNode rootPackage = new PackageNode("");
private final Set<String> pkgSet = new TreeSet<String>();
private final int maxLength;
private final int minLength;
private final boolean useSourceNameAsAlias;
private int pkgIndex = 0;
private int clsIndex = 0;
private int fldIndex = 0;
private int mthIndex = 0;
public Deobfuscator(IJadxArgs args, @NotNull List<DexNode> dexNodes, File deobfMapFile) {
this.args = args;
this.dexNodes = dexNodes;
this.minLength = args.getDeobfuscationMinLength();
this.maxLength = args.getDeobfuscationMaxLength();
this.useSourceNameAsAlias = args.useSourceNameAsClassAlias();
this.deobfPresets = new DeobfPresets(this, deobfMapFile);
}
public void execute() {
if (!args.isDeobfuscationForceSave()) {
deobfPresets.load();
initIndexes();
}
process();
deobfPresets.save(args.isDeobfuscationForceSave());
clear();
}
private void initIndexes() {
pkgIndex = pkgSet.size();
clsIndex = deobfPresets.getClsPresetMap().size();
fldIndex = deobfPresets.getFldPresetMap().size();
mthIndex = deobfPresets.getMthPresetMap().size();
}
private void preProcess() {
for (DexNode dexNode : dexNodes) {
for (ClassNode cls : dexNode.getClasses()) {
doClass(cls);
}
}
}
private void process() {
preProcess();
if (DEBUG) {
dumpAlias();
}
for (DexNode dexNode : dexNodes) {
for (ClassNode cls : dexNode.getClasses()) {
processClass(dexNode, cls);
}
}
postProcess();
}
private void postProcess() {
int id = 1;
for (OverridedMethodsNode o : ovrd) {
Iterator<MethodInfo> it = o.getMethods().iterator();
if (it.hasNext()) {
MethodInfo mth = it.next();
if (mth.isRenamed() && !mth.isAliasFromPreset()) {
mth.setAlias(String.format("mo%d%s", id, makeName(mth.getName())));
}
String firstMethodAlias = mth.getAlias();
while (it.hasNext()) {
mth = it.next();
if (!mth.getAlias().equals(firstMethodAlias)) {
mth.setAlias(firstMethodAlias);
}
}
}
id++;
}
}
void clear() {
deobfPresets.clear();
clsMap.clear();
fldMap.clear();
mthMap.clear();
ovrd.clear();
ovrdMap.clear();
}
@Nullable
private static ClassNode resolveOverridingInternal(DexNode dex, ClassNode cls, String signature,
Set<MethodInfo> overrideSet, ClassNode rootClass) {
ClassNode result = null;
for (MethodNode m : cls.getMethods()) {
if (m.getMethodInfo().getShortId().startsWith(signature)) {
result = cls;
if (!overrideSet.contains(m.getMethodInfo())) {
overrideSet.add(m.getMethodInfo());
}
break;
}
}
ArgType superClass = cls.getSuperClass();
if (superClass != null) {
ClassNode superNode = dex.resolveClass(superClass);
if (superNode != null) {
ClassNode clsWithMth = resolveOverridingInternal(dex, superNode, signature, overrideSet, rootClass);
if (clsWithMth != null) {
if ((result != null) && (result != cls)) {
if (clsWithMth != result) {
LOG.warn(String.format("Multiple overriding '%s' from '%s' and '%s' in '%s'",
signature,
result.getFullName(), clsWithMth.getFullName(),
rootClass.getFullName()));
}
} else {
result = clsWithMth;
}
}
}
}
for (ArgType iFaceType : cls.getInterfaces()) {
ClassNode iFaceNode = dex.resolveClass(iFaceType);
if (iFaceNode != null) {
ClassNode clsWithMth = resolveOverridingInternal(dex, iFaceNode, signature, overrideSet, rootClass);
if (clsWithMth != null) {
if ((result != null) && (result != cls)) {
if (clsWithMth != result) {
LOG.warn(String.format("Multiple overriding '%s' from '%s' and '%s' in '%s'",
signature,
result.getFullName(), clsWithMth.getFullName(),
rootClass.getFullName()));
}
} else {
result = clsWithMth;
}
}
}
}
return result;
}
private void resolveOverriding(DexNode dex, ClassNode cls, MethodNode mth) {
Set<MethodInfo> overrideSet = new HashSet<MethodInfo>();
resolveOverridingInternal(dex, cls, mth.getMethodInfo().makeSignature(false), overrideSet, cls);
if (overrideSet.size() > 1) {
OverridedMethodsNode overrideNode = null;
for (MethodInfo _mth : overrideSet) {
if (ovrdMap.containsKey(_mth)) {
overrideNode = ovrdMap.get(_mth);
break;
}
}
if (overrideNode == null) {
overrideNode = new OverridedMethodsNode(overrideSet);
ovrd.add(overrideNode);
}
for (MethodInfo _mth : overrideSet) {
if (!ovrdMap.containsKey(_mth)) {
ovrdMap.put(_mth, overrideNode);
if (!overrideNode.contains(_mth)) {
overrideNode.add(_mth);
}
}
}
} else {
overrideSet.clear();
overrideSet = null;
}
}
private void processClass(DexNode dex, ClassNode cls) {
ClassInfo clsInfo = cls.getClassInfo();
String fullName = getClassFullName(clsInfo);
if (!fullName.equals(clsInfo.getFullName())) {
clsInfo.rename(dex, fullName);
}
for (FieldNode field : cls.getFields()) {
FieldInfo fieldInfo = field.getFieldInfo();
String alias = getFieldAlias(field);
if (alias != null) {
fieldInfo.setAlias(alias);
}
}
for (MethodNode mth : cls.getMethods()) {
MethodInfo methodInfo = mth.getMethodInfo();
String alias = getMethodAlias(mth);
if (alias != null) {
methodInfo.setAlias(alias);
}
if (mth.isVirtual()) {
resolveOverriding(dex, cls, mth);
}
}
}
public void addPackagePreset(String origPkgName, String pkgAlias) {
PackageNode pkg = getPackageNode(origPkgName, true);
pkg.setAlias(pkgAlias);
}
/**
* Gets package node for full package name
*
* @param fullPkgName full package name
* @param create if {@code true} then will create all absent objects
* @return package node object or {@code null} if no package found and <b>create</b> set to {@code false}
*/
private PackageNode getPackageNode(String fullPkgName, boolean create) {
if (fullPkgName.isEmpty() || fullPkgName.equals(CLASS_NAME_SEPARATOR)) {
return rootPackage;
}
PackageNode result = rootPackage;
PackageNode parentNode;
do {
String pkgName;
int idx = fullPkgName.indexOf(CLASS_NAME_SEPARATOR);
if (idx > -1) {
pkgName = fullPkgName.substring(0, idx);
fullPkgName = fullPkgName.substring(idx + 1);
} else {
pkgName = fullPkgName;
fullPkgName = "";
}
parentNode = result;
result = result.getInnerPackageByName(pkgName);
if (result == null && create) {
result = new PackageNode(pkgName);
parentNode.addInnerPackage(result);
}
} while (!fullPkgName.isEmpty() && result != null);
return result;
}
String getNameWithoutPackage(ClassInfo clsInfo) {
String prefix;
ClassInfo parentClsInfo = clsInfo.getParentClass();
if (parentClsInfo != null) {
DeobfClsInfo parentDeobfClsInfo = clsMap.get(parentClsInfo);
if (parentDeobfClsInfo != null) {
prefix = parentDeobfClsInfo.makeNameWithoutPkg();
} else {
prefix = getNameWithoutPackage(parentClsInfo);
}
prefix += INNER_CLASS_SEPARATOR;
} else {
prefix = "";
}
return prefix + clsInfo.getShortName();
}
private void doClass(ClassNode cls) {
ClassInfo classInfo = cls.getClassInfo();
String pkgFullName = classInfo.getPackage();
PackageNode pkg = getPackageNode(pkgFullName, true);
doPkg(pkg, pkgFullName);
String alias = deobfPresets.getForCls(classInfo);
if (alias != null) {
clsMap.put(classInfo, new DeobfClsInfo(this, cls, pkg, alias));
return;
}
if (clsMap.containsKey(classInfo)) {
return;
}
if (shouldRename(classInfo.getShortName())) {
makeClsAlias(cls);
}
}
public String getClsAlias(ClassNode cls) {
DeobfClsInfo deobfClsInfo = clsMap.get(cls.getClassInfo());
if (deobfClsInfo != null) {
return deobfClsInfo.getAlias();
}
return makeClsAlias(cls);
}
private String makeClsAlias(ClassNode cls) {
ClassInfo classInfo = cls.getClassInfo();
String alias = null;
if (this.useSourceNameAsAlias) {
alias = getAliasFromSourceFile(cls);
}
if (alias == null) {
String clsName = classInfo.getShortName();
alias = String.format("C%04d%s", clsIndex++, makeName(clsName));
}
PackageNode pkg = getPackageNode(classInfo.getPackage(), true);
clsMap.put(classInfo, new DeobfClsInfo(this, cls, pkg, alias));
return alias;
}
@Nullable
private String getAliasFromSourceFile(ClassNode cls) {
SourceFileAttr sourceFileAttr = cls.get(AType.SOURCE_FILE);
if (sourceFileAttr == null) {
return null;
}
String name = sourceFileAttr.getFileName();
if (name.endsWith(".java")) {
name = name.substring(0, name.length() - ".java".length());
}
if (NameMapper.isValidIdentifier(name)
&& !NameMapper.isReserved(name)) {
// TODO: check if no class with this name exists or already renamed
cls.remove(AType.SOURCE_FILE);
return name;
}
return null;
}
@Nullable
public String getFieldAlias(FieldNode field) {
FieldInfo fieldInfo = field.getFieldInfo();
String alias = fldMap.get(fieldInfo);
if (alias != null) {
return alias;
}
alias = deobfPresets.getForFld(fieldInfo);
if (alias != null) {
fldMap.put(fieldInfo, alias);
return alias;
}
if (shouldRename(field.getName())) {
return makeFieldAlias(field);
}
return null;
}
@Nullable
public String getMethodAlias(MethodNode mth) {
MethodInfo methodInfo = mth.getMethodInfo();
String alias = mthMap.get(methodInfo);
if (alias != null) {
return alias;
}
alias = deobfPresets.getForMth(methodInfo);
if (alias != null) {
mthMap.put(methodInfo, alias);
methodInfo.setAliasFromPreset(true);
return alias;
}
if (shouldRename(mth.getName())) {
return makeMethodAlias(mth);
}
return null;
}
public String makeFieldAlias(FieldNode field) {
String alias = String.format("f%d%s", fldIndex++, makeName(field.getName()));
fldMap.put(field.getFieldInfo(), alias);
return alias;
}
public String makeMethodAlias(MethodNode mth) {
String alias = String.format("m%d%s", mthIndex++, makeName(mth.getName()));
mthMap.put(mth.getMethodInfo(), alias);
return alias;
}
private void doPkg(PackageNode pkg, String fullName) {
if (pkgSet.contains(fullName)) {
return;
}
pkgSet.add(fullName);
// doPkg for all parent packages except root that not hasAliases
PackageNode parentPkg = pkg.getParentPackage();
while (!parentPkg.getName().isEmpty()) {
if (!parentPkg.hasAlias()) {
doPkg(parentPkg, parentPkg.getFullName());
}
parentPkg = parentPkg.getParentPackage();
}
final String pkgName = pkg.getName();
if (!pkg.hasAlias() && shouldRename(pkgName)) {
final String pkgAlias = String.format("p%03d%s", pkgIndex++, makeName(pkgName));
pkg.setAlias(pkgAlias);
}
}
private boolean shouldRename(String s) {
return s.length() > maxLength
|| s.length() < minLength
|| NameMapper.isReserved(s)
|| !NameMapper.isAllCharsPrintable(s);
}
private String makeName(String name) {
if (name.length() > maxLength) {
return "x" + Integer.toHexString(name.hashCode());
}
if (NameMapper.isReserved(name)) {
return name;
}
if (!NameMapper.isAllCharsPrintable(name)) {
return removeInvalidChars(name);
}
return name;
}
private String removeInvalidChars(String name) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < name.length(); i++) {
int ch = name.charAt(i);
if (NameMapper.isPrintableChar(ch)) {
sb.append((char) ch);
}
}
return sb.toString();
}
private void dumpClassAlias(ClassNode cls) {
PackageNode pkg = getPackageNode(cls.getPackage(), false);
if (pkg != null) {
if (!cls.getFullName().equals(getClassFullName(cls))) {
LOG.info("Alias name for class '{}' is '{}'", cls.getFullName(), getClassFullName(cls));
}
} else {
LOG.error("Can't find package node for '{}'", cls.getPackage());
}
}
private void dumpAlias() {
for (DexNode dexNode : dexNodes) {
for (ClassNode cls : dexNode.getClasses()) {
dumpClassAlias(cls);
}
}
}
private String getPackageName(String packageName) {
final PackageNode pkg = getPackageNode(packageName, false);
if (pkg != null) {
return pkg.getFullAlias();
}
return packageName;
}
private String getClassName(ClassInfo clsInfo) {
final DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
if (deobfClsInfo != null) {
return deobfClsInfo.makeNameWithoutPkg();
}
return getNameWithoutPackage(clsInfo);
}
private String getClassFullName(ClassNode cls) {
return getClassFullName(cls.getClassInfo());
}
private String getClassFullName(ClassInfo clsInfo) {
final DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
if (deobfClsInfo != null) {
return deobfClsInfo.getFullName();
}
return getPackageName(clsInfo.getPackage()) + CLASS_NAME_SEPARATOR + getClassName(clsInfo);
}
public Map<ClassInfo, DeobfClsInfo> getClsMap() {
return clsMap;
}
public Map<FieldInfo, String> getFldMap() {
return fldMap;
}
public Map<MethodInfo, String> getMthMap() {
return mthMap;
}
public PackageNode getRootPackage() {
return rootPackage;
}
}
|
nao20010128nao/show-java
|
app/src/main/java/jadx/core/deobf/Deobfuscator.java
|
Java
|
apache-2.0
| 14,277
|
package ru.stqa.pft.addressbook.tests;
import org.testng.annotations.Test;
import ru.stqa.pft.addressbook.model.ContactData;
import java.util.Arrays;
import java.util.stream.Collectors;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
/**
* Created by jekko on 23.01.2017.
*/
public class ContactPhoneTests extends TestBase {
@Test
public void testContactsPhones() {
app.goTo().gotoContactPage();
ContactData contact = app.contact().all().iterator().next();
ContactData contactInfoFromEditForm = app.contact().infoFromEditForm(contact);
assertThat(contact.getAllPhones(), equalTo(mergePhones(contactInfoFromEditForm)));
}
private String mergePhones(ContactData contact) {
return Arrays.asList(contact.getHomePhone(), contact.getMobilePhone(), contact.getWorkPhone())
.stream().filter((s) -> !s.equals(""))
.map(ContactPhoneTests::cleaned)
.collect(Collectors.joining("\n"));
}
public static String cleaned(String phone) {
return phone.replaceAll("\\s", "").replaceAll("[-()]", "");
}
}
|
ekatanaev/java_first_lesson
|
addressbook-web-tests/src/test/java/ru/stqa/pft/addressbook/tests/ContactPhoneTests.java
|
Java
|
apache-2.0
| 1,124
|
<!-- Generated by pkgdown: do not edit by hand -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Return the number of columns present in x. — h2o.ncol • h2o</title>
<!-- jquery -->
<script src="https://code.jquery.com/jquery-3.1.0.min.js" integrity="sha384-nrOSfDHtoPMzJHjVTdCopGqIqeYETSXhZDFyniQ8ZHcVy08QesyHcnOUpMpqnmWq" crossorigin="anonymous"></script>
<!-- Bootstrap -->
<link href="https://maxcdn.bootstrapcdn.com/bootswatch/3.3.7/cosmo/bootstrap.min.css" rel="stylesheet" crossorigin="anonymous">
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
<!-- Font Awesome icons -->
<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css" rel="stylesheet" integrity="sha384-T8Gy5hrqNKT+hzMclPo118YTQO6cYprQmhrYwIiQ/3axmI1hQomh7Ud2hPOy8SP1" crossorigin="anonymous">
<!-- pkgdown -->
<link href="../pkgdown.css" rel="stylesheet">
<script src="../jquery.sticky-kit.min.js"></script>
<script src="../pkgdown.js"></script>
<link href="../extra.css" rel="stylesheet">
<script src="../extra.js"></script>
<!-- mathjax -->
<script src='https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML'></script>
<!--[if lt IE 9]>
<script src="https://oss.maxcdn.com/html5shiv/3.7.3/html5shiv.min.js"></script>
<script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
<![endif]-->
</head>
<body>
<div class="container template-reference-topic">
<header>
<div class="navbar navbar-inverse navbar-fixed-top" role="navigation">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar">
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="navbar-brand" href="../index.html">H2O.ai</a>
</div>
<div id="navbar" class="navbar-collapse collapse">
<ul class="nav navbar-nav">
<li>
<a href="../articles/h2o-r-package.html">The H2O-R Package</a>
</li>
<li>
<a href="../articles/getting_started.html">Getting Started</a>
</li>
<li>
<a href="../reference/index.html">R Reference Guide</a>
</li>
</ul>
<ul class="nav navbar-nav navbar-right">
<li>
<a href="https://github.com/h2oai/h2o-3">
<span class="fa fa-github"></span>
</a>
</li>
</ul>
</div><!--/.nav-collapse -->
</div><!--/.container -->
</div><!--/.navbar -->
</header>
<div class="row">
<div class="col-md-9 contents">
<div class="page-header">
<h1>Return the number of columns present in x.</h1>
</div>
<p>Return the number of columns present in x.</p>
<pre class="usage"><span class='fu'>h2o.ncol</span>(<span class='no'>x</span>)</pre>
<h2 class="hasAnchor" id="arguments"><a class="anchor" href="#arguments"></a> Arguments</h2>
<table class="ref-arguments">
<colgroup><col class="name" /><col class="desc" /></colgroup>
<tr>
<th>x</th>
<td><p>An H2OFrame object.</p></td>
</tr>
</table>
<h2 class="hasAnchor" id="see-also"><a class="anchor" href="#see-also"></a>See also</h2>
<p><code><a href='http://www.rdocumentation.org/packages/base/topics/nrow'>ncol</a></code> for the base R implementation.</p>
</div>
<div class="col-md-3 hidden-xs hidden-sm" id="sidebar">
<h2>Contents</h2>
<ul class="nav nav-pills nav-stacked">
<li><a href="#arguments">Arguments</a></li>
<li><a href="#see-also">See also</a></li>
</ul>
</div>
</div>
<footer>
<div class="copyright">
<p>Developed by The H2O.ai team.</p>
</div>
<div class="pkgdown">
<p>Site built with <a href="http://hadley.github.io/pkgdown/">pkgdown</a>.</p>
</div>
</footer>
</div>
</body>
</html>
|
spennihana/h2o-3
|
h2o-r/h2o-package/docs/reference/h2o.ncol.html
|
HTML
|
apache-2.0
| 4,155
|
# knfsd-metrics-agent
This collects various system metrics from the NFS proxy and writes them in a format suitable for collectd.
## Environment Variables
* `COLLECTD_HOSTNAME` - Overrides the default system hostname.
* `COLLECTD_INTERVAL` - Metric collection interval in seconds, defaults to 60.
* `METRICS_SOCKET_PATH` - See `-socket` option.
* `METRICS_MODE` - See `-mode` option.
* `METRICS_ENABLE_META` - See `-enable-meta` option.
When using the systemd service, these environment variables can be provided by the `/etc/default/knfsd-metrics-agent` file.
## Options
* `-socket path` \
Sets the path to the unix socket created by the collectd `unixsock` plugin.
This socket will be used to write metrics instead of stdout.
* `-proc path` \
Sets the path to the procfs filesystem (default `/proc`).
* `-mode mode` \
Sets which metrics are collected, valid options are proxy or client (default `proxy`).
* `-enable-meta` \
Enables including metadata with the metrics. This requires collectd 5.11.0 or greater. To disable this use `-enable-meta=false`.
## Mode
### Proxy
* Proxy to Source, per-mount:
* Operations per second
* RPC backlog
* Read RTT and exe time
* Write RTT and exe time
* Inode cache
* Active objects
* Object size
* Dentry cache
* Active objects
* Object size
* Number of client connections
### Client
* Client to Proxy, per-mount:
* Operations per second
* RPC backlog
* Read RTT and exe time
* Write RTT and exe time
* Inode cache
* Active objects
* Object size
* Dentry cache
* Active objects
* Object size
|
GoogleCloudPlatform/knfsd-cache-utils
|
image/resources/knfsd-metrics-agent/README.md
|
Markdown
|
apache-2.0
| 1,597
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8">
<title></title>
<link rel="stylesheet" href="qunit.css" type="text/css">
<script src="qunit.js"></script>
<script src="../src/htmlparser.js"></script>
<script src="../src/htmlminifier.js"></script>
</head>
<body>
<h1 id="qunit-header">HTML Minifier</h1>
<h2 id="qunit-banner"></h2>
<h2 id="qunit-userAgent"></h2>
<ol id="qunit-tests"></ol>
<script src="minifier.js"></script>
</body>
</html>
|
stephenlorenz/sproutstudy
|
sproutStudy_web/yo/node_modules/grunt-contrib-htmlmin/node_modules/html-minifier/tests/index.html
|
HTML
|
apache-2.0
| 621
|
package com.waltz3d.museum.detail;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.ZipInputStream;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;
import com.waltz3d.museum.DiskDataCache;
import com.waltz3d.museum.DownloadInfo;
import com.waltz3d.museum.DownloadSQLiteHelper;
import com.waltz3d.museum.R;
import com.waltz3d.museum.Util;
import com.waltz3d.museum.XL_Log;
import com.waltz3d.museum.R.string;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
public class To3DHelper {
private static final int START_LOADING = 1;//开始加载数据
private static final int ZIP_FILE_SUCCESS = 2; // 解压完成
private static final int MSG_UPDATE_DOWNLOAD_PROGRESS = 3; // 缓存任务interval
private XL_Log log = new XL_Log(To3DHelper.class);
private String Product3D;
private ProgressDialog mProgressDialog;
private Context mContext;
// 更新缓存进度
private Timer mTimer;
private int readLen = 0;
private long fileSize = 0;// 原始文件大小
private String mFileSaveDir;
private DownloadSQLiteHelper mDownloadSQLiteHelper;
private OnloadSuccessListenr mOnloadSuccessListenr;
private String mUrlHashKey;
private Handler handler = new Handler() {
public void handleMessage(Message msg) {
switch (msg.what) {
case START_LOADING:
Util.showDialog(mProgressDialog, "正在加载中...");
break;
case ZIP_FILE_SUCCESS:
stopTimer();
dismissProgressBar();
break;
case MSG_UPDATE_DOWNLOAD_PROGRESS:// 显示进度条
Bundle b = msg.getData();
int progress = b.getInt("progress");
log.debug("progress=" + progress);
String upFormat = mContext.getString(R.string.update_loading);
String upStr = MessageFormat.format(upFormat, progress);
mProgressDialog.setMessage(upStr);
break;
default:
break;
}
}
};
public To3DHelper(Context context, String url,OnloadSuccessListenr onloadSuccessListenr) {
this.mContext = context;
this.Product3D = url;
mProgressDialog = new ProgressDialog(mContext);
this.mOnloadSuccessListenr = onloadSuccessListenr;
mDownloadSQLiteHelper = new DownloadSQLiteHelper(mContext);
mFileSaveDir = Util.getSDCardDir(mContext) + "Mesume/3D";
File f = new File(mFileSaveDir);
if (!f.exists()) {
f.mkdirs();
}
mUrlHashKey = DiskDataCache.hashKeyForDisk(Product3D);
tryToLoad();
}
private void tryToLoad(){
new Thread(new Runnable() {
@Override
public void run() {
List<DownloadInfo> mImgList = mDownloadSQLiteHelper.getZipFileList(mUrlHashKey);
if(mImgList == null || mImgList.size() == 0){
handler.obtainMessage(START_LOADING).sendToTarget();
String mFilePath = mFileSaveDir + File.separator + mUrlHashKey;
File file = new File(mFilePath);
if(file.exists()){//如果文件存在
boolean isSuccess = readByZipInputStream(mFilePath, mFileSaveDir);//尝试解压缩
if(isSuccess){//解压缩成功
mImgList = mDownloadSQLiteHelper.getZipFileList(mUrlHashKey);
}
}
}
if(!selectList(mImgList)){//没有加载成功
downFile();
}
}
}).start();
}
private boolean selectList(List<DownloadInfo> mImgList){
if(mImgList != null && mImgList.size() > 0){//数据为空
List<DownloadInfo> mCallBackList = new ArrayList<DownloadInfo>();
for(DownloadInfo mDownloadInfo : mImgList){
File f = new File(mDownloadInfo.imgPath);
if(f.exists()){
mCallBackList.add(mDownloadInfo);
}
}
if(mCallBackList.size() > 0){
mOnloadSuccessListenr.onLoadSuccess(mCallBackList);
handler.obtainMessage(ZIP_FILE_SUCCESS).sendToTarget();
return true;
}
}
return false;
}
private void startTimer() {
if (null == mTimer) {
mTimer = new Timer();
mTimer.schedule(new PlayTimerTask(), 0, 1000);
}
}
private void stopTimer() {
if (null != mTimer) {
mTimer.cancel();
mTimer = null;
}
}
private class PlayTimerTask extends TimerTask {
@Override
public void run() {
Message msg = handler.obtainMessage(MSG_UPDATE_DOWNLOAD_PROGRESS);
Bundle b = new Bundle();
int progress = (int) (((float) readLen / fileSize) * 100);
b.putInt("progress", progress);
msg.setData(b);
handler.sendMessage(msg);
}
}
private void downFile() {
String mFilePath = mFileSaveDir + File.separator + mUrlHashKey;
File file = new File(mFilePath);
HttpClient client = new DefaultHttpClient();
HttpGet get = new HttpGet(Product3D);
HttpResponse response;
try {
response = client.execute(get);
HttpEntity entity = response.getEntity();
fileSize = entity.getContentLength();
startTimer();
InputStream is = entity.getContent();
FileOutputStream fileOutputStream = null;
if (is != null) {
fileOutputStream = new FileOutputStream(file);
byte[] buf = new byte[8 * 1024];
int ch = -1;
while ((ch = is.read(buf)) != -1) {
fileOutputStream.write(buf, 0, ch);
readLen = readLen + ch;
}
}
fileOutputStream.flush();
if (fileOutputStream != null) {
fileOutputStream.close();
}
boolean isSuccess = readByZipInputStream(mFilePath, mFileSaveDir);
if(isSuccess){
List<DownloadInfo> mImgList = mDownloadSQLiteHelper.getZipFileList(mUrlHashKey);
if(selectList(mImgList)){
return;
};
}
} catch (Exception e) {
e.printStackTrace();
}
handler.obtainMessage(ZIP_FILE_SUCCESS).sendToTarget();
mOnloadSuccessListenr.onLoadSuccess(null);
}
private boolean readByZipInputStream(String archive, String decompressDir){
BufferedInputStream mBufferedInputStream = null;
try {
FileInputStream fi = new FileInputStream(archive);
CheckedInputStream csumi = new CheckedInputStream(fi, new CRC32());
ZipInputStream in2 = new ZipInputStream(csumi);
mBufferedInputStream = new BufferedInputStream(in2);
java.util.zip.ZipEntry ze;
while ((ze = in2.getNextEntry()) != null) {
String entryName = ze.getName();
if (ze.isDirectory()) {
System.out.println("正在创建解压目录 - " + entryName);
File decompressDirFile = new File(decompressDir + "/" + entryName);
if (!decompressDirFile.exists()) {
decompressDirFile.mkdirs();
}
} else {
System.out.println("正在创建解压文件 - " + entryName);
String mItemFileName = decompressDir + "/" + entryName;
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(mItemFileName));
byte[] buffer = new byte[1024];
int readCount = mBufferedInputStream.read(buffer);
while (readCount != -1) {
bos.write(buffer, 0, readCount);
readCount = mBufferedInputStream.read(buffer);
}
bos.close();
if(mItemFileName.endsWith("png") || mItemFileName.endsWith("jpg")){
DownloadInfo mDownloadInfo = new DownloadInfo();
mDownloadInfo.imgPath = mItemFileName;
mDownloadInfo.originZipPath = archive;
mDownloadInfo.urlHashKey = mUrlHashKey;
mDownloadSQLiteHelper.insertData(mDownloadInfo);
}
}
}
return true;
} catch (IOException e) {
e.printStackTrace();
} finally{
if(mBufferedInputStream != null){
try {
mBufferedInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return false;
}
/**
* 取消进度条
*/
private void dismissProgressBar() {
if (mProgressDialog != null && mProgressDialog.isShowing()) {
mProgressDialog.dismiss();
}
}
public interface OnloadSuccessListenr{
void onLoadSuccess(List<DownloadInfo> mList);
}
}
|
zhangzhige/Museum
|
src/com/waltz3d/museum/detail/To3DHelper.java
|
Java
|
apache-2.0
| 8,148
|
/*
* Copyright 2014-2015 Red Hat, Inc. and/or its affiliates
* and other contributors as indicated by the @author tags.
*
* 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.
*/
package org.hawkular.metrics.api.jaxrs.handler;
import static javax.ws.rs.core.MediaType.APPLICATION_JSON;
import static org.hawkular.metrics.api.jaxrs.util.ApiUtils.collectionToResponse;
import static org.hawkular.metrics.api.jaxrs.util.ApiUtils.serverError;
import java.net.URI;
import javax.inject.Inject;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.container.AsyncResponse;
import javax.ws.rs.container.Suspended;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.UriInfo;
import org.hawkular.metrics.api.jaxrs.handler.observer.TenantCreatedObserver;
import org.hawkular.metrics.api.jaxrs.model.ApiError;
import org.hawkular.metrics.api.jaxrs.model.TenantDefinition;
import org.hawkular.metrics.core.api.MetricsService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
/**
* @author Thomas Segismont
*/
@Path("/tenants")
@Consumes(APPLICATION_JSON)
@Produces(APPLICATION_JSON)
@Api(tags = "Tenant")
public class TenantsHandler {
@Inject
private MetricsService metricsService;
@POST
@ApiOperation(value = "Create a new tenant.", notes = "Clients are not required to create explicitly create a "
+ "tenant before starting to store metric data. It is recommended to do so however to ensure that there "
+ "are no tenant id naming collisions and to provide default data retention settings.")
@ApiResponses(value = {
@ApiResponse(code = 201, message = "Tenant has been succesfully created."),
@ApiResponse(code = 400, message = "Missing or invalid retention properties. ",
response = ApiError.class),
@ApiResponse(code = 409, message = "Given tenant id has already been created.",
response = ApiError.class),
@ApiResponse(code = 500, message = "An unexpected error occured while trying to create a tenant.",
response = ApiError.class)
})
public void createTenant(
@Suspended AsyncResponse asyncResponse,
@ApiParam(required = true) TenantDefinition tenantDefinition,
@Context UriInfo uriInfo
) {
URI location = uriInfo.getBaseUriBuilder().path("/tenants").build();
metricsService.createTenant(tenantDefinition.toTenant())
.subscribe(new TenantCreatedObserver(asyncResponse, location));
}
@GET
@ApiOperation(value = "Returns a list of tenants.", response = TenantDefinition.class, responseContainer = "List")
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Returned a list of tenants successfully."),
@ApiResponse(code = 204, message = "No tenants were found."),
@ApiResponse(code = 500, message = "Unexpected error occurred while fetching tenants.",
response = ApiError.class)
})
public void findTenants(@Suspended AsyncResponse asyncResponse) {
metricsService.getTenants().map(TenantDefinition::new).toList().subscribe(
tenants -> asyncResponse.resume(collectionToResponse(tenants)),
error -> asyncResponse.resume(serverError(error))
);
}
}
|
spadgett/hawkular-metrics
|
api/metrics-api-jaxrs/src/main/java/org/hawkular/metrics/api/jaxrs/handler/TenantsHandler.java
|
Java
|
apache-2.0
| 4,082
|
-- phpMyAdmin SQL Dump
-- version 4.0.10deb1
-- http://www.phpmyadmin.net
--
-- Host: localhost
-- Generation Time: Mar 30, 2016 at 09:41 PM
-- Server version: 5.5.47-0ubuntu0.14.04.1
-- PHP Version: 5.5.9-1ubuntu4.14
SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
SET time_zone = "+00:00";
/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
--
-- Database: `daw`
--
-- --------------------------------------------------------
--
-- Table structure for table `comment`
--
CREATE TABLE IF NOT EXISTS `comment` (
`cid` int(11) NOT NULL AUTO_INCREMENT,
`aid` int(11) NOT NULL,
`uid` int(11) NOT NULL,
`content` varchar(1000) NOT NULL,
`date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`cid`,`aid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=23 ;
--
-- Dumping data for table `comment`
--
INSERT INTO `comment` (`cid`, `aid`, `uid`, `content`, `date`) VALUES
(1, 4, 0, '<p><strong>This is the time</strong></p>', '0000-00-00 00:00:00'),
(2, 4, 0, '<ul><li>This</li><li>Is</li><li>A</li><li>Bulleted</li><li>List</li></ul>', '2016-03-21 22:11:44'),
(3, 4, 0, '<ul><li>This</li><li>Is</li><li>A</li><li>Bulleted</li><li>List</li></ul>', '2016-03-21 22:11:50'),
(4, 4, 0, '<ul><li>This</li><li>Is</li><li>A</li><li>Bulleted</li><li>List</li></ul>', '2016-03-21 22:12:13'),
(5, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:39:05'),
(6, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:39:38'),
(7, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:39:44'),
(8, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:39:55'),
(9, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:40:49'),
(10, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:41:36'),
(11, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:43:45'),
(12, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:43:52'),
(13, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:44:00'),
(14, 4, 0, '<p><strong>Hampden-Sydney College in Virginia, looked up one</strong></p>', '2016-03-21 22:44:05'),
(15, 4, 0, '<p>Let's say this is a super l<a href="http://www.google.ro">ong paragraph</a>, what would you say about this?<script>alert("asdad");</script></p><p> </p>', '2016-03-21 22:46:20'),
(16, 1, 0, '<p><strong>FIRST!!!!!!!!!!!!</strong></p>', '2016-03-30 18:25:06'),
(17, 1, 0, '<p><strong>FIRST!!!!!!!!!!!!</strong></p>', '2016-03-30 18:26:16'),
(18, 1, 9, '<p><strong>FIRST!!!!!!!!!!!!</strong></p>', '2016-03-30 18:33:18'),
(19, 1, 9, '<p><strong>Second mogo</strong></p>', '2016-03-30 18:36:22'),
(20, 1, 9, '<p><strong>Second mogo</strong></p>', '2016-03-30 18:36:35'),
(21, 1, 9, '<p><strong>Second mogo</strong></p>', '2016-03-30 18:36:40'),
(22, 1, 9, '<p><strong>FIIIIIIIIIIIIIIIIIIIIIIIIIIIINALLY</strong></p>', '2016-03-30 18:38:11');
-- --------------------------------------------------------
--
-- Table structure for table `users`
--
CREATE TABLE IF NOT EXISTS `users` (
`uid` int(11) NOT NULL AUTO_INCREMENT,
`email` varchar(32) NOT NULL,
`password` varchar(128) NOT NULL,
`name` varchar(64) NOT NULL,
`role` int(11) NOT NULL,
PRIMARY KEY (`uid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=10 ;
--
-- Dumping data for table `users`
--
INSERT INTO `users` (`uid`, `email`, `password`, `name`, `role`) VALUES
(1, 'vdanielpop@yahoo.com', 'bd3dae5fb91f88a4f0978222dfd58f59a124257cb081486387cbae9df11fb879', 'Daniel Pop', 2),
(9, 'vpop@pitechnologies.ro', 'bd3dae5fb91f88a4f0978222dfd58f59a124257cb081486387cbae9df11fb879', 'Daniel Pop 2', 2);
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
|
vdanielpop/daw
|
daw.sql
|
SQL
|
apache-2.0
| 4,340
|
/*
* Copyright (C) 2017 The Proteus Project
*
* 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.
*/
package com.proteus.peach.redis.manager
import org.junit.AfterClass
import org.junit.Assert
import org.junit.Assert.assertTrue
import org.junit.BeforeClass
import org.junit.Test
import redis.clients.jedis.exceptions.JedisConnectionException
object RedisReconnectIT {
/**
* Initialize the Redis session.
*/
@BeforeClass
def beforeClassIT(): Unit = {
RedisSessionManager.init(AbstractRedisManagerHelper.Session)
assertTrue("Default session must be defined",
RedisSessionManager.getSession(AbstractRedisManagerHelper.TargetSession).isDefined)
}
/**
* Finish Redis Session Manager.
*/
@AfterClass
def afterClassIT(): Unit = {
RedisSessionManager.close(AbstractRedisManagerHelper.TargetSession)
}
}
/**
* Test REDIS reconnection method.
*/
class RedisReconnectIT extends AbstractRedisManagerHelper {
/**
* The sleeping time in tests.
*/
val testSleepingTime: Int = 100
/**
* The mockup provider.
*/
val provider = new ReconnectMockupProvider()
/**
* Reconnection finally send the message.
*/
@Test
def reconnectionWorkTest(): Unit = {
val fails = 3
val reconnection = 5
val result = this.provider.forceReconnect(fails, reconnection)
Assert.assertTrue("Result must be defined.", result.isDefined)
}
/**
* Reconnection finally fail.
*/
@Test
def reconnectionFailTest(): Unit = {
val fails = 3
val reconnection = 2
val result = this.provider.forceReconnect(fails, reconnection)
Assert.assertTrue("Result must be empty.", result.isEmpty)
}
/**
* Reconnection mockup.
*/
class ReconnectMockupProvider extends AbstractRedisProvider(AbstractRedisManagerHelper.TargetSession) {
/**
* Method that fails n number of times.
*
* @param numTimes Number of fails.
* @param maxNumTimes Provider reconnections.
* @return DBSize
*/
def forceReconnect(numTimes: Int, maxNumTimes: Int): Option[Long] = {
var i = 0
this.executeOperationWithRetries(() => {
if (i < numTimes) {
i += 1
throw new JedisConnectionException("Connection problem.")
} else {
val jedis = this.client.getOrElse(throw new IllegalArgumentException("Client is null."))
jedis.dbSize()
}
}, maxNumTimes, testSleepingTime)
}
}
}
|
aagea/peach
|
peach-redis-server/src/test/scala/com/proteus/peach/redis/manager/RedisReconnectIT.scala
|
Scala
|
apache-2.0
| 2,958
|
package org.swiften.xtestkit.android.element.locator;
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.AndroidElement;
import io.reactivex.Flowable;
import org.jetbrains.annotations.NotNull;
import org.openqa.selenium.WebElement;
import org.swiften.xtestkit.android.AndroidView;
import org.swiften.xtestkit.base.element.locator.LocatorType;
import org.swiften.xtestkit.mobile.Platform;
import org.swiften.javautilities.protocol.ClassNameProviderType;
import org.swiften.xtestkitcomponents.xpath.CompoundAttribute;
import org.swiften.xtestkitcomponents.xpath.XPath;
/**
* Created by haipham on 1/6/17.
*/
/**
* This interface provides methods to locate {@link org.openqa.selenium.WebElement}
* for {@link Platform#ANDROID}.
*/
public interface AndroidLocatorType extends LocatorType<AndroidDriver<AndroidElement>> {
/**
* Override this method to provide default implementation.
* @return {@link Flowable} instance.
* @see LocatorType#rxe_statusBar()
*/
@NotNull
@Override
default Flowable<WebElement> rxe_statusBar() {
throw new RuntimeException(NOT_AVAILABLE);
}
/**
* Override this method to provide default implementation.
* @return {@link Flowable} instance.
* @see LocatorType#rxe_window()
* @see CompoundAttribute#empty()
* @see CompoundAttribute#withClass(ClassNameProviderType)
* @see CompoundAttribute#withIndex(Integer)
* @see XPath.Builder#addAttribute(CompoundAttribute)
* @see AndroidView.Type#FRAME_LAYOUT
* @see #rxe_withXPath(XPath...)
*/
@NotNull
@Override
default Flowable<WebElement> rxe_window() {
CompoundAttribute cAttr = CompoundAttribute.empty()
.withClass(AndroidView.Type.FRAME_LAYOUT)
.withIndex(1);
XPath xpath = XPath.builder().addAttribute(cAttr).build();
return rxe_withXPath(xpath).firstElement().toFlowable();
}
/**
* Override this method to provide default implementation.
* @return {@link Flowable} instance.
* @see LocatorType#rxe_imageViews()
* @see AndroidView.Type#IMAGE_VIEW
* @see #rxe_ofClass(ClassNameProviderType[])
*/
@NotNull
@Override
default Flowable<WebElement> rxe_imageViews() {
return rxe_ofClass(AndroidView.Type.IMAGE_VIEW);
}
}
|
protoman92/XTestKit
|
src/main/java/org/swiften/xtestkit/android/element/locator/AndroidLocatorType.java
|
Java
|
apache-2.0
| 2,357
|
/*
* Copyright (c) 2021, Peter Abeles. All Rights Reserved.
*
* This file is part of Efficient Java Matrix Library (EJML).
*
* 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.
*/
package org.ejml.dense.row.linsol;
import org.ejml.EjmlStandardJUnit;
import org.ejml.LinearSolverSafe;
import org.ejml.UtilEjml;
import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;
import org.ejml.dense.row.MatrixFeatures_DDRM;
import org.ejml.interfaces.linsol.LinearSolverDense;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Tests the ability of a solver to handle different type of rank deficient matrices
*
* @author Peter Abeles
*/
public class GenericSolvePseudoInverseChecks_DDRM extends EjmlStandardJUnit {
LinearSolverDense<DMatrixRMaj> solver;
public GenericSolvePseudoInverseChecks_DDRM(LinearSolverDense<DMatrixRMaj> solver) {
this.solver = new LinearSolverSafe<DMatrixRMaj>( solver );
}
public void all() {
zeroMatrix();
underDetermined_wide_solve();
underDetermined_wide_inv();
underDetermined_tall_solve();
singular_solve();
singular_inv();
}
/**
* Shouldn't blow if it the input matrix is zero. But there is no solution...
*/
public void zeroMatrix() {
DMatrixRMaj A = new DMatrixRMaj(3,3);
DMatrixRMaj y = new DMatrixRMaj(3,1,true,4,7,8);
assertTrue(solver.setA(A));
DMatrixRMaj x = new DMatrixRMaj(3,1);
solver.solve(y, x);
assertFalse(MatrixFeatures_DDRM.hasUncountable(x));
}
/**
* Compute a solution for a system with more variables than equations
*/
public void underDetermined_wide_solve() {
// create a matrix where two rows are linearly dependent
DMatrixRMaj A = new DMatrixRMaj(2,3,true,1,2,3,2,3,4);
DMatrixRMaj y = new DMatrixRMaj(2,1,true,4,7);
assertTrue(solver.setA(A));
DMatrixRMaj x = new DMatrixRMaj(3,1);
solver.solve(y,x);
DMatrixRMaj found = new DMatrixRMaj(2,1);
CommonOps_DDRM.mult(A, x, found);
// there are multiple 'x' which will generate the same solution, see if this is one of them
assertTrue(MatrixFeatures_DDRM.isEquals(y, found, UtilEjml.TEST_F64));
}
/**
* Compute the pseudo inverse a system with more variables than equations
*/
public void underDetermined_wide_inv() {
// create a matrix where two rows are linearly dependent
DMatrixRMaj A = new DMatrixRMaj(2,3,true,1,2,3,2,3,4);
DMatrixRMaj y = new DMatrixRMaj(2,1,true,4,7);
assertTrue(solver.setA(A));
DMatrixRMaj x = new DMatrixRMaj(3,1);
solver.solve(y,x);
// now test the pseudo inverse
DMatrixRMaj A_pinv = new DMatrixRMaj(3,2);
DMatrixRMaj found = new DMatrixRMaj(3,1);
solver.invert(A_pinv);
CommonOps_DDRM.mult(A_pinv,y,found);
assertTrue(MatrixFeatures_DDRM.isEquals(x, found,UtilEjml.TEST_F64));
}
/**
* Compute a solution for a system with more variables than equations
*/
public void underDetermined_tall_solve() {
// create a matrix where two rows are linearly dependent
DMatrixRMaj A = new DMatrixRMaj(3,2,true,1,2,1,2,2,4);
DMatrixRMaj y = new DMatrixRMaj(3,1,true,4,4,8);
assertTrue(solver.setA(A));
DMatrixRMaj x = new DMatrixRMaj(2,1);
solver.solve(y,x);
DMatrixRMaj found = new DMatrixRMaj(3,1);
CommonOps_DDRM.mult(A, x, found);
// there are multiple 'x' which will generate the same solution, see if this is one of them
assertTrue(MatrixFeatures_DDRM.isEquals(y, found, UtilEjml.TEST_F64));
}
/**
* Compute a solution for a system with more variables than equations
*/
public void singular_solve() {
// create a matrix where two rows are linearly dependent
DMatrixRMaj A = new DMatrixRMaj(3,3,true,1,2,3,2,3,4,2,3,4);
DMatrixRMaj y = new DMatrixRMaj(3,1,true,4,7,7);
assertTrue(solver.setA(A));
DMatrixRMaj x = new DMatrixRMaj(3,1);
solver.solve(y,x);
DMatrixRMaj found = new DMatrixRMaj(3,1);
CommonOps_DDRM.mult(A, x, found);
// there are multiple 'x' which will generate the same solution, see if this is one of them
assertTrue(MatrixFeatures_DDRM.isEquals(y, found, UtilEjml.TEST_F64));
}
/**
* Compute the pseudo inverse a system with more variables than equations
*/
public void singular_inv() {
// create a matrix where two rows are linearly dependent
DMatrixRMaj A = new DMatrixRMaj(3,3,true,1,2,3,2,3,4,2,3,4);
DMatrixRMaj y = new DMatrixRMaj(3,1,true,4,7,7);
assertTrue(solver.setA(A));
DMatrixRMaj x = new DMatrixRMaj(3,1);
solver.solve(y,x);
// now test the pseudo inverse
DMatrixRMaj A_pinv = new DMatrixRMaj(3,3);
DMatrixRMaj found = new DMatrixRMaj(3,1);
solver.invert(A_pinv);
CommonOps_DDRM.mult(A_pinv,y,found);
assertTrue(MatrixFeatures_DDRM.isEquals(x, found,UtilEjml.TEST_F64));
}
}
|
lessthanoptimal/ejml
|
main/ejml-ddense/test/org/ejml/dense/row/linsol/GenericSolvePseudoInverseChecks_DDRM.java
|
Java
|
apache-2.0
| 5,750
|
package us.feliscat.time.en
import us.feliscat.m17n.English
import us.feliscat.text.StringOption
import us.feliscat.time.MultiLingualTimeExtractionPreprocessor
/**
* <pre>
* Created on 2017/02/09.
* </pre>
*
* @author K.Sakamoto
*/
object EnglishTimeExtractionPreprocessor extends MultiLingualTimeExtractionPreprocessor with English {
override def convert(text: StringOption): StringOption = StringOption.empty
}
|
ktr-skmt/FelisCatusZero-multilingual
|
libraries/src/main/scala/us/feliscat/time/en/EnglishTimeExtractionPreprocessor.scala
|
Scala
|
apache-2.0
| 429
|
# Alysicarpus varius Wall. SPECIES
#### Status
ACCEPTED
#### According to
International Plant Names Index
#### Published in
null
#### Original name
null
### Remarks
null
|
mdoering/backbone
|
life/Plantae/Magnoliophyta/Magnoliopsida/Fabales/Fabaceae/Alysicarpus/Alysicarpus varius/README.md
|
Markdown
|
apache-2.0
| 174
|
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package co.nubetech.hiho.mapreduce.lib.db.apache;
@InterfaceAudience.Private
@InterfaceStability.Evolving
public interface MRJobConfig {
// Put all of the attribute names in here so that Job and JobContext are
// consistent.
public static final String INPUT_FORMAT_CLASS_ATTR = "mapreduce.job.inputformat.class";
public static final String MAP_CLASS_ATTR = "mapreduce.job.map.class";
public static final String COMBINE_CLASS_ATTR = "mapreduce.job.combine.class";
public static final String REDUCE_CLASS_ATTR = "mapreduce.job.reduce.class";
public static final String OUTPUT_FORMAT_CLASS_ATTR = "mapreduce.job.outputformat.class";
public static final String PARTITIONER_CLASS_ATTR = "mapreduce.job.partitioner.class";
public static final String SETUP_CLEANUP_NEEDED = "mapreduce.job.committer.setup.cleanup.needed";
public static final String JAR = "mapreduce.job.jar";
public static final String ID = "mapreduce.job.id";
public static final String JOB_NAME = "mapreduce.job.name";
public static final String JAR_UNPACK_PATTERN = "mapreduce.job.jar.unpack.pattern";
public static final String USER_NAME = "mapreduce.job.user.name";
public static final String PRIORITY = "mapreduce.job.priority";
public static final String QUEUE_NAME = "mapreduce.job.queuename";
public static final String JVM_NUMTASKS_TORUN = "mapreduce.job.jvm.numtasks";
public static final String SPLIT_FILE = "mapreduce.job.splitfile";
public static final String NUM_MAPS = "mapreduce.job.maps";
public static final String MAX_TASK_FAILURES_PER_TRACKER = "mapreduce.job.maxtaskfailures.per.tracker";
public static final String COMPLETED_MAPS_FOR_REDUCE_SLOWSTART = "mapreduce.job.reduce.slowstart.completedmaps";
public static final String NUM_REDUCES = "mapreduce.job.reduces";
public static final String SKIP_RECORDS = "mapreduce.job.skiprecords";
public static final String SKIP_OUTDIR = "mapreduce.job.skip.outdir";
public static final String SPECULATIVE_SLOWNODE_THRESHOLD = "mapreduce.job.speculative.slownodethreshold";
public static final String SPECULATIVE_SLOWTASK_THRESHOLD = "mapreduce.job.speculative.slowtaskthreshold";
public static final String SPECULATIVECAP = "mapreduce.job.speculative.speculativecap";
public static final String JOB_LOCAL_DIR = "mapreduce.job.local.dir";
public static final String OUTPUT_KEY_CLASS = "mapreduce.job.output.key.class";
public static final String OUTPUT_VALUE_CLASS = "mapreduce.job.output.value.class";
public static final String KEY_COMPARATOR = "mapreduce.job.output.key.comparator.class";
public static final String GROUP_COMPARATOR_CLASS = "mapreduce.job.output.group.comparator.class";
public static final String WORKING_DIR = "mapreduce.job.working.dir";
public static final String HISTORY_LOCATION = "mapreduce.job.userhistorylocation";
public static final String END_NOTIFICATION_URL = "mapreduce.job.end-notification.url";
public static final String END_NOTIFICATION_RETRIES = "mapreduce.job.end-notification.retry.attempts";
public static final String END_NOTIFICATION_RETRIE_INTERVAL = "mapreduce.job.end-notification.retry.interval";
public static final String CLASSPATH_ARCHIVES = "mapreduce.job.classpath.archives";
public static final String CLASSPATH_FILES = "mapreduce.job.classpath.files";
public static final String CACHE_FILES = "mapreduce.job.cache.files";
public static final String CACHE_ARCHIVES = "mapreduce.job.cache.archives";
public static final String CACHE_FILES_SIZES = "mapreduce.job.cache.files.filesizes"; // internal use only
public static final String CACHE_ARCHIVES_SIZES = "mapreduce.job.cache.archives.filesizes"; // ditto
public static final String CACHE_LOCALFILES = "mapreduce.job.cache.local.files";
public static final String CACHE_LOCALARCHIVES = "mapreduce.job.cache.local.archives";
public static final String CACHE_FILE_TIMESTAMPS = "mapreduce.job.cache.files.timestamps";
public static final String CACHE_ARCHIVES_TIMESTAMPS = "mapreduce.job.cache.archives.timestamps";
public static final String CACHE_FILE_VISIBILITIES = "mapreduce.job.cache.files.visibilities";
public static final String CACHE_ARCHIVES_VISIBILITIES = "mapreduce.job.cache.archives.visibilities";
public static final String CACHE_SYMLINK = "mapreduce.job.cache.symlink.create";
public static final String USER_LOG_RETAIN_HOURS = "mapreduce.job.userlog.retain.hours";
public static final String IO_SORT_FACTOR = "mapreduce.task.io.sort.factor";
public static final String IO_SORT_MB = "mapreduce.task.io.sort.mb";
public static final String PRESERVE_FAILED_TASK_FILES = "mapreduce.task.files.preserve.failedtasks";
public static final String PRESERVE_FILES_PATTERN = "mapreduce.task.files.preserve.filepattern";
public static final String TASK_TEMP_DIR = "mapreduce.task.tmp.dir";
public static final String TASK_DEBUGOUT_LINES = "mapreduce.task.debugout.lines";
public static final String RECORDS_BEFORE_PROGRESS = "mapreduce.task.merge.progress.records";
public static final String SKIP_START_ATTEMPTS = "mapreduce.task.skip.start.attempts";
public static final String TASK_ATTEMPT_ID = "mapreduce.task.attempt.id";
public static final String TASK_ISMAP = "mapreduce.task.ismap";
public static final String TASK_PARTITION = "mapreduce.task.partition";
public static final String TASK_PROFILE = "mapreduce.task.profile";
public static final String TASK_PROFILE_PARAMS = "mapreduce.task.profile.params";
public static final String NUM_MAP_PROFILES = "mapreduce.task.profile.maps";
public static final String NUM_REDUCE_PROFILES = "mapreduce.task.profile.reduces";
public static final String TASK_TIMEOUT = "mapreduce.task.timeout";
public static final String TASK_ID = "mapreduce.task.id";
public static final String TASK_OUTPUT_DIR = "mapreduce.task.output.dir";
public static final String TASK_USERLOG_LIMIT = "mapreduce.task.userlog.limit.kb";
public static final String MAP_SORT_SPILL_PERCENT = "mapreduce.map.sort.spill.percent";
public static final String MAP_INPUT_FILE = "mapreduce.map.input.file";
public static final String MAP_INPUT_PATH = "mapreduce.map.input.length";
public static final String MAP_INPUT_START = "mapreduce.map.input.start";
public static final String MAP_MEMORY_MB = "mapreduce.map.memory.mb";
public static final String MAP_MEMORY_PHYSICAL_MB = "mapreduce.map.memory.physical.mb";
public static final String MAP_ENV = "mapreduce.map.env";
public static final String MAP_JAVA_OPTS = "mapreduce.map.java.opts";
public static final String MAP_ULIMIT = "mapreduce.map.ulimit";
public static final String MAP_MAX_ATTEMPTS = "mapreduce.map.maxattempts";
public static final String MAP_DEBUG_SCRIPT = "mapreduce.map.debug.script";
public static final String MAP_SPECULATIVE = "mapreduce.map.speculative";
public static final String MAP_FAILURES_MAX_PERCENT = "mapreduce.map.failures.maxpercent";
public static final String MAP_SKIP_INCR_PROC_COUNT = "mapreduce.map.skip.proc-count.auto-incr";
public static final String MAP_SKIP_MAX_RECORDS = "mapreduce.map.skip.maxrecords";
public static final String MAP_COMBINE_MIN_SPILLS = "mapreduce.map.combine.minspills";
public static final String MAP_OUTPUT_COMPRESS = "mapreduce.map.output.compress";
public static final String MAP_OUTPUT_COMPRESS_CODEC = "mapreduce.map.output.compress.codec";
public static final String MAP_OUTPUT_KEY_CLASS = "mapreduce.map.output.key.class";
public static final String MAP_OUTPUT_VALUE_CLASS = "mapreduce.map.output.value.class";
public static final String MAP_OUTPUT_KEY_FIELD_SEPERATOR = "mapreduce.map.output.key.field.separator";
public static final String MAP_LOG_LEVEL = "mapreduce.map.log.level";
public static final String REDUCE_LOG_LEVEL = "mapreduce.reduce.log.level";
public static final String REDUCE_MERGE_INMEM_THRESHOLD = "mapreduce.reduce.merge.inmem.threshold";
public static final String REDUCE_INPUT_BUFFER_PERCENT = "mapreduce.reduce.input.buffer.percent";
public static final String REDUCE_MARKRESET_BUFFER_PERCENT = "mapreduce.reduce.markreset.buffer.percent";
public static final String REDUCE_MARKRESET_BUFFER_SIZE = "mapreduce.reduce.markreset.buffer.size";
public static final String REDUCE_MEMORY_PHYSICAL_MB = "mapreduce.reduce.memory.physical.mb";
public static final String REDUCE_MEMORY_MB = "mapreduce.reduce.memory.mb";
public static final String REDUCE_MEMORY_TOTAL_BYTES = "mapreduce.reduce.memory.totalbytes";
public static final String SHUFFLE_INPUT_BUFFER_PERCENT = "mapreduce.reduce.shuffle.input.buffer.percent";
public static final String SHUFFLE_MERGE_EPRCENT = "mapreduce.reduce.shuffle.merge.percent";
public static final String REDUCE_FAILURES_MAXPERCENT = "mapreduce.reduce.failures.maxpercent";
public static final String REDUCE_ENV = "mapreduce.reduce.env";
public static final String REDUCE_JAVA_OPTS = "mapreduce.reduce.java.opts";
public static final String REDUCE_ULIMIT = "mapreduce.reduce.ulimit";
public static final String REDUCE_MAX_ATTEMPTS = "mapreduce.reduce.maxattempts";
public static final String SHUFFLE_PARALLEL_COPIES = "mapreduce.reduce.shuffle.parallelcopies";
public static final String REDUCE_DEBUG_SCRIPT = "mapreduce.reduce.debug.script";
public static final String REDUCE_SPECULATIVE = "mapreduce.reduce.speculative";
public static final String SHUFFLE_CONNECT_TIMEOUT = "mapreduce.reduce.shuffle.connect.timeout";
public static final String SHUFFLE_READ_TIMEOUT = "mapreduce.reduce.shuffle.read.timeout";
public static final String SHUFFLE_FETCH_FAILURES = "mapreduce.reduce.shuffle.maxfetchfailures";
public static final String SHUFFLE_NOTIFY_READERROR = "mapreduce.reduce.shuffle.notify.readerror";
public static final String REDUCE_SKIP_INCR_PROC_COUNT = "mapreduce.reduce.skip.proc-count.auto-incr";
public static final String REDUCE_SKIP_MAXGROUPS = "mapreduce.reduce.skip.maxgroups";
public static final String REDUCE_MEMTOMEM_THRESHOLD = "mapreduce.reduce.merge.memtomem.threshold";
public static final String REDUCE_MEMTOMEM_ENABLED = "mapreduce.reduce.merge.memtomem.enabled";
public static final String JOB_NAMENODES = "mapreduce.job.hdfs-servers";
public static final String JOB_JOBTRACKER_ID = "mapreduce.job.kerberos.jtprinicipal";
public static final String JOB_CANCEL_DELEGATION_TOKEN = "mapreduce.job.complete.cancel.delegation.tokens";
static final String JOB_ACL_VIEW_JOB = "mapreduce.job.acl-view-job";
static final String JOB_ACL_MODIFY_JOB = "mapreduce.job.acl-modify-job";
}
|
sonalgoyal/hiho
|
src/main/java/co/nubetech/hiho/mapreduce/lib/db/apache/MRJobConfig.java
|
Java
|
apache-2.0
| 11,498
|
package com.leader.spring04.autowritedtest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class HelloWorldBean4 {
@Autowired
private HelloWorldbean anotherHelloBean;
private ArrayList<String> t;
public HelloWorldBean4() {
System.out.println(new Date() + " create " + this);
}
public void hello() {
anotherHelloBean.hello();
System.out.println(Arrays.toString(t.toArray()));
}
}
|
upup1000/spring
|
spring-04/src/main/java/com/leader/spring04/autowritedtest/HelloWorldBean4.java
|
Java
|
apache-2.0
| 555
|
<?php
include('../controllers/config.php');
include('../controllers/session.php');
include('head.php');
//session_start();
//call billstatuschecker
?>
<body class="mode-default colorful-enabled theme-red">
<nav class="left-menu" left-menu>
<div class="logo-container">
<a href="index.html" class="logo">
<img src="../assets/common/img/logo.png" alt="Clean UI Admin Template" />
<img class="logo-inverse" src="../assets/common/img/logo-inverse.png" alt="Clean UI Admin Template" />
</a>
</div>
<div class="left-menu-inner scroll-pane">
<ul class="left-menu-list left-menu-list-root list-unstyled">
<li class="left-menu-list-separator "><!-- --></li>
<li class="left-menu-list-active">
<a class="left-menu-link" href="index.php">
<i class="left-menu-link-icon icmn-home2"><!-- --></i>
<span class="menu-top-hidden">Dashboard</span>
</a>
</li>
<li class="left-menu-list-separator"><!-- -->
</li>
<li>
<a class="left-menu-link" href="floors.php">
<i class="left-menu-link-icon icmn-calendar"><!-- --></i>
Floors
</a>
</li>
<li class="left-menu-list-submenu">
<a class="left-menu-link" href="javascript: void(0);">
<i class="left-menu-link-icon icmn-files-empty2"><!-- --></i>
Unit Information
</a>
<ul class="left-menu-list list-unstyled">
<li>
<a class="left-menu-link" href="unitsummary.php">
Unit List
</a>
</li>
<li>
<a class="left-menu-link" href="unitadd.php">
Add Unit
</a>
</li>
<li>
<a class="left-menu-link" href="unitedit.php">
Edit Unit
</a>
</li>
</ul>
</li>
<li class="left-menu-list-separator"><!-- --></li>
<li class="left-menu-list-submenu">
<a class="left-menu-link" href="javascript: void(0);">
Tenant Information
</a>
<ul class="left-menu-list list-unstyled">
<li>
<a class="left-menu-link" href="tenantsummary.php">
Tenant List
</a>
</li>
<li>
<a class="left-menu-link" href="tenantadd.php">
Add Tenant
</a>
</li>
</ul>
</li>
<li>
<a class="left-menu-link" href="bill.php">
<i class="left-menu-link-icon icmn-calendar"><!-- --></i>
Billing
</a>
</li>
<li>
<a class="left-menu-link" href="report.php">
<i class="left-menu-link-icon icmn-calendar"><!-- --></i>
Report
</a>
</li>
<li class="left-menu-list-separator"><!-- --></li>
<li class="left-menu-list-submenu">
<a class="left-menu-link" href="javascript: void(0);">
Current Profile
</a>
<ul class="left-menu-list list-unstyled">
<li>
<a class="left-menu-link" href="profile.php">
Update Information
</a>
</li>
<li>
<a class="left-menu-link" href="profilepass.php">
Change Password
</a>
</li>
</ul>
</li>
<li class="left-menu-list-separator"><!-- --></li>
</ul>
</div>
</nav>
<nav class="top-menu">
<div class="menu-icon-container hidden-md-up">
<div class="animate-menu-button left-menu-toggle">
<div><!-- --></div>
</div>
</div>
<div class="menu">
<div class="menu-user-block">
<div class="dropdown dropdown-avatar">
<a href="javascript: void(0);" class="dropdown-toggle" data-toggle="dropdown" aria-expanded="false">
Welcome, <?php echo $_SESSION['current_user_first_name'];?>
</a>
<ul class="dropdown-menu dropdown-menu-right" aria-labelledby="" role="menu">
<a class="dropdown-item" href="javascript:void(0)"><i class="dropdown-icon icmn-user"></i> Profile</a>
<div class="dropdown-divider"></div>
<a class="dropdown-item" href="logout.php"><i class="dropdown-icon icmn-exit"></i> Logout</a>
</ul>
</div>
</div>
</div>
</nav>
<section class="page-content">
<div class="page-content-inner">
<!-- Dashboard -->
<div class="dashboard-container">
<!--
<div class="row">
<form method="POST" name="statuschecker" id="statuschecker">
<div class="text-center">
<button type="submit" class="btn btn-success-outline" name="submit"">
Check Bill - admin
</button>
</div>
</form>
</div>
--> <?php include('../controllers/billstatuschecker.php');?>
<div class="row">
<div class="col-xl-6 col-lg-6 col-sm-6 col-xs-12">
<div class="widget widget-seven background-success">
<div class="widget-body">
<div href="javascript: void(0);" class="widget-body-inner">
<h5 class="text-uppercase">Floors</h5>
<i class="counter-icon icmn-office"></i>
<span class="counter-count">
<i class="icmn-arrow-up5"></i>
<?php
$conn = new PDO("mysql:host={$host};dbname={$dbname}",$user,$pass);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$sql = "SELECT COUNT(*) FROM _floor WHERE _floor.oid = :user";
$stmt = $conn->prepare($sql);
$stmt->bindParam(':user', $_SESSION['id']);
$stmt->execute();
$number_of_rows = $stmt->fetchColumn();
echo '<span class="counter-init" data-from="3" data-to="'.$number_of_rows.'"></span>';
?>
</span>
</div>
</div>
</div>
</div>
<div class="col-xl-6 col-lg-6 col-sm-6 col-xs-12">
<div class="widget widget-seven background-default">
<div class="widget-body">
<div href="javascript: void(0);" class="widget-body-inner">
<h5 class="text-uppercase">Units</h5>
<i class="counter-icon icmn-home"></i>
<span class="counter-count">
<i class="icmn-arrow-down5"></i>
<?php
$conn = new PDO("mysql:host={$host};dbname={$dbname}",$user,$pass);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$sql = "SELECT COUNT(*) FROM _unit WHERE userName = :user";
$sql = "SELECT COUNT(*) FROM _floor INNER JOIN _owner ON _owner.id = _floor.oid INNER JOIN _unit ON _floor.id = _unit.floor_id WHERE _floor.oid = :owner";
$stmt = $conn->prepare($sql);
$stmt->bindParam(':owner', $_SESSION['id']);
$stmt->execute();
$number_of_rows = $stmt->fetchColumn();
echo '<span class="counter-init" data-from="0" data-to="'.$number_of_rows.'"></span>';
?>
</span>
</div>
</div>
</div>
</div>
<div class="col-xl-6 col-lg-6 col-sm-6 col-xs-12">
<div class="widget widget-seven">
<div class="widget-body">
<div href="javascript: void(0);" class="widget-body-inner">
<h5 class="text-uppercase">Renting Tenants</h5>
<i class="counter-icon icmn-users"></i>
<span class="counter-count">
<i class="icmn-arrow-up5"></i>
<?php
$conn = new PDO("mysql:host={$host};dbname={$dbname}",$user,$pass);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$sql = "SELECT COUNT(*) FROM _tenantprofile INNER JOIN _tenantrentinginformation ON _tenantprofile.id = _tenantrentinginformation.tid WHERE _tenantprofile.oid = :id";
$stmt = $conn->prepare($sql);
$stmt->bindParam(':id', $_SESSION['id']);
$stmt->execute();
$number_of_rows = $stmt->fetchColumn();
$active = $number_of_rows;
echo '<span class="counter-init" data-from="0" data-to="'.$number_of_rows.'"></span>';
?>
</span>
</div>
</div>
</div>
</div>
<div class="col-xl-6 col-lg-6 col-sm-6 col-xs-12">
<div class="widget widget-seven">
<div class="widget-body">
<div href="javascript: void(0);" class="widget-body-inner">
<h5 class="text-uppercase">Space Available</h5>
<i class="counter-icon icmn-stack-text"></i>
<span class="counter-count">
<i class="icmn-arrow-up5"></i>
<?php
$conn = new PDO("mysql:host={$host};dbname={$dbname}",$user,$pass);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$sql = "SELECT _unit.tenantAllowed as allowed, _unit.currentTenant as current FROM _floor INNER JOIN _unit ON _unit.floor_id = _floor.id WHERE _floor.oid = :id";
$stmt = $conn->prepare($sql);
$stmt->bindParam(':id', $_SESSION['id']);
$stmt->execute();
$result = $stmt->fetch(PDO::FETCH_ASSOC);
$avail = $result['allowed'] - $result['current'];
echo '<span class="counter-init" data-from="0" data-to="'.$avail.'"></span>';
?>
</span>
</div>
</div>
</div>
</div>
</div>
<div class="row">
<div class="col-xl-4 col-lg-12 col-sm-12 col-xs-12">
<div class="widget widget-seven">
<div class="carousel-widget-2 carousel slide" data-ride="carousel">
<div class="carousel-inner" role="listbox">
<div class="carousel-item active">
<a href="unitsummary.php" class="widget-body">
<h2>
<i class="icmn-database"></i> Available Units
</h2>
<p>
Current: <?php echo $avail; ?>
<br />
</p>
</a>
</div>
<div class="carousel-item">
<a href="unitsummary.php" class="widget-body">
<h2>
<i class="icmn-users"></i> Tenants
</h2>
<p>
<?php
$sql = "SELECT COUNT(*) as total FROM _tenantprofile WHERE oid = '".$_SESSION['id']."'";
$stmt = $conn->prepare($sql);
$stmt->execute();
$result = $stmt->fetch(PDO::FETCH_ASSOC);
?>
Total: <?php echo $result['total'];?>
<br />
Active: <?php echo $active;?>
</p>
</a>
</div>
</div>
</div>
</div>
</div>
<div class="col-xl-4 col-lg-12 col-sm-12 col-xs-12">
<div class="widget widget-seven background-danger">
<div class="carousel-widget carousel slide" data-ride="carousel">
<div class="carousel-inner" role="listbox">
<div class="carousel-item active">
<a href="tenantsummary.php" class="widget-body">
<h2>
<i class="icmn-books"></i> Profiles
</h2>
<p>
View All Profiles
<br />
</p>
</a>
</div>
<div class="carousel-item">
<a href="unitsummary.php" class="widget-body">
<h2>
<i class="icmn-download"></i> Units
</h2>
<p>
View All Units
</p>
</a>
</div>
</div>
</div>
</div>
</div>
<div class="col-xl-4 col-lg-12 col-sm-12 col-xs-12">
<div class="widget widget-seven background-info" style="background-image: url(../assets/common/img/temp/photos/9.jpeg)">
<div class="carousel-widget-2 carousel slide" data-ride="carousel">
<div class="carousel-inner" role="listbox">
<div class="carousel-item active">
<a href="profile.php" class="widget-body">
<h2>Profile</h2>
<p>
Edit Current Profile
<br />
</p>
</a>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- End Dashboard -->
</div>
<!-- Page Scripts -->
<script>
$(function() {
///////////////////////////////////////////////////////////
// COUNTERS
$('.counter-init').countTo({
speed: 1500
});
// CUSTOM SCROLL
if (!cleanUI.hasTouch) {
$('.custom-scroll').each(function() {
$(this).jScrollPane({
autoReinitialise: true,
autoReinitialiseDelay: 100
});
var api = $(this).data('jsp'),
throttleTimeout;
$(window).bind('resize', function() {
if (!throttleTimeout) {
throttleTimeout = setTimeout(function() {
api.reinitialise();
throttleTimeout = null;
}, 50);
}
});
});
}
///////////////////////////////////////////////////////////
// CAROUSEL WIDGET
$('.carousel-widget').carousel({
interval: 4000
});
$('.carousel-widget-2').carousel({
interval: 6000
});
///////////////////////////////////////////////////////////
// DATATABLES
$('#example1').DataTable({
responsive: true,
"lengthMenu": [[5, 25, 50, -1], [5, 25, 50, "All"]]
});
});
</script>
<!-- End Page Scripts -->
</section>
<div class="main-backdrop"><!-- --></div>
</body>
</html>
|
imran7128/ABCD
|
views/index.php
|
PHP
|
apache-2.0
| 18,104
|
/**
* ueditor完整配置项
* 可以在这里配置整个编辑器的特性
*/
/**************************提示********************************
* 所有被注释的配置项均为UEditor默认值。
* 修改默认配置请首先确保已经完全明确该参数的真实用途。
* 主要有两种修改方案，一种是取消此处注释，然后修改成对应参数；另一种是在实例化编辑器时传入对应参数。
* 当升级编辑器时，可直接使用旧版配置文件替换新版配置文件,不用担心旧版配置文件中因缺少新功能所需的参数而导致脚本报错。
**************************提示********************************/
(function () {
/**
* 编辑器资源文件根路径。它所表示的含义是：以编辑器实例化页面为当前路径，指向编辑器资源文件（即dialog等文件夹）的路径。
* 鉴于很多同学在使用编辑器的时候出现的种种路径问题，此处强烈建议大家使用"相对于网站根目录的相对路径"进行配置。
* "相对于网站根目录的相对路径"也就是以斜杠开头的形如"/myProject/ueditor/"这样的路径。
* 如果站点中有多个不在同一层级的页面需要实例化编辑器，且引用了同一UEditor的时候，此处的URL可能不适用于每个页面的编辑器。
* 因此，UEditor提供了针对不同页面的编辑器可单独配置的根路径，具体来说，在需要实例化编辑器的页面最顶部写上如下代码即可。当然，需要令此处的URL等于对应的配置。
* window.UEDITOR_HOME_URL = "/xxxx/xxxx/";
*/
var URL = window.UEDITOR_HOME_URL || getUEBasePath();
/**
* 配置项主体。注意，此处所有涉及到路径的配置别遗漏URL变量。
*/
window.UEDITOR_CONFIG = {
//为编辑器实例添加一个路径，这个不能被注释
UEDITOR_HOME_URL: URL
// 服务器统一请求接口路径
, serverUrl: URL + "jsp/controller.jsp"
//工具栏上的所有的功能按钮和下拉框，可以在new编辑器的实例时选择自己需要的重新定义
, toolbars: [[
'undo', //撤销
'redo', //重做
'bold', //加粗
'indent', //首行缩进
'italic', //斜体
'underline', //下划线
'strikethrough', //删除线
'subscript', //下标
'fontborder', //字符边框
'superscript', //上标
'blockquote', //引用
'horizontal', //分隔线
'insertorderedlist', //有序列表
'insertunorderedlist', //无序列表
'inserttable', //插入表格
'time', //时间
'date', //日期
'link', //超链接
'unlink', //取消链接
'fontfamily', //字体
'fontsize', //字号
'paragraph', //段落格式
// 'simpleupload', //单图上传
// 'insertimage', //多图上传
'spechars', //特殊字符
'justifyleft', //居左对齐
'justifyright', //居右对齐
'justifycenter', //居中对齐
'justifyjustify', //两端对齐
'forecolor', //字体颜色
'backcolor', //背景色
// 'fullscreen', //全屏
'directionalityltr', //从左向右输入
'directionalityrtl', //从右向左输入
// 'imagenone', //默认
// 'attachment', //附件
// 'imagecenter', //居中
'lineheight', //行间距
'edittip ', //编辑提示
// 'customstyle', //自定义标题
// 'background' //背景
]]
//当鼠标放在工具栏上时显示的tooltip提示,留空支持自动多语言配置，否则以配置值为准
//,labelMap:{
// 'anchor':'', 'undo':''
//}
//语言配置项,默认是zh-cn。有需要的话也可以使用如下这样的方式来自动多语言切换，当然，前提条件是lang文件夹下存在对应的语言文件：
//lang值也可以通过自动获取 (navigator.language||navigator.browserLanguage ||navigator.userLanguage).toLowerCase()
//,lang:"zh-cn"
//,langPath:URL +"lang/"
//主题配置项,默认是default。有需要的话也可以使用如下这样的方式来自动多主题切换，当然，前提条件是themes文件夹下存在对应的主题文件：
//现有如下皮肤:default
//,theme:'default'
//,themePath:URL +"themes/"
//,zIndex : 900 //编辑器层级的基数,默认是900
//针对getAllHtml方法，会在对应的head标签中增加该编码设置。
//,charset:"utf-8"
//若实例化编辑器的页面手动修改的domain，此处需要设置为true
//,customDomain:false
//常用配置项目
//,isShow : true //默认显示编辑器
//,textarea:'editorValue' // 提交表单时，服务器获取编辑器提交内容的所用的参数，多实例时可以给容器name属性，会将name给定的值最为每个实例的键值，不用每次实例化的时候都设置这个值
//,initialContent:'欢迎使用ueditor!' //初始化编辑器的内容,也可以通过textarea/script给值，看官网例子
//,autoClearinitialContent:true //是否自动清除编辑器初始内容，注意：如果focus属性设置为true,这个也为真，那么编辑器一上来就会触发导致初始化的内容看不到了
//,focus:false //初始化时，是否让编辑器获得焦点true或false
//如果自定义，最好给p标签如下的行高，要不输入中文时，会有跳动感
//,initialStyle:'p{line-height:1em}'//编辑器层级的基数,可以用来改变字体等
//,iframeCssUrl: URL + '/themes/iframe.css' //给编辑区域的iframe引入一个css文件
//indentValue
//首行缩进距离,默认是2em
//,indentValue:'2em'
//,initialFrameWidth:1000 //初始化编辑器宽度,默认1000
//,initialFrameHeight:320 //初始化编辑器高度,默认320
//,readonly : false //编辑器初始化结束后,编辑区域是否是只读的，默认是false
//,autoClearEmptyNode : true //getContent时，是否删除空的inlineElement节点（包括嵌套的情况）
//启用自动保存
//,enableAutoSave: true
//自动保存间隔时间， 单位ms
//,saveInterval: 500
//,fullscreen : false //是否开启初始化时即全屏，默认关闭
// ,imagePopup:true //图片操作的浮层开关，默认打开
//,autoSyncData:true //自动同步编辑器要提交的数据
//,emotionLocalization:false //是否开启表情本地化，默认关闭。若要开启请确保emotion文件夹下包含官网提供的images表情文件夹
//粘贴只保留标签，去除标签所有属性
//,retainOnlyLabelPasted: false
//,pasteplain:false //是否默认为纯文本粘贴。false为不使用纯文本粘贴，true为使用纯文本粘贴
//纯文本粘贴模式下的过滤规则
//'filterTxtRules' : function(){
// function transP(node){
// node.tagName = 'p';
// node.setStyle();
// }
// return {
// //直接删除及其字节点内容
// '-' : 'script style object iframe embed input select',
// 'p': {$:{}},
// 'br':{$:{}},
// 'div':{'$':{}},
// 'li':{'$':{}},
// 'caption':transP,
// 'th':transP,
// 'tr':transP,
// 'h1':transP,'h2':transP,'h3':transP,'h4':transP,'h5':transP,'h6':transP,
// 'td':function(node){
// //没有内容的td直接删掉
// var txt = !!node.innerText();
// if(txt){
// node.parentNode.insertAfter(UE.uNode.createText(' '),node);
// }
// node.parentNode.removeChild(node,node.innerText())
// }
// }
//}()
//,allHtmlEnabled:false //提交到后台的数据是否包含整个html字符串
//insertorderedlist
//有序列表的下拉配置,值留空时支持多语言自动识别，若配置值，则以此值为准
//,'insertorderedlist':{
// //自定的样式
// 'num':'1,2,3...',
// 'num1':'1),2),3)...',
// 'num2':'(1),(2),(3)...',
// 'cn':'一,二,三....',
// 'cn1':'一),二),三)....',
// 'cn2':'(一),(二),(三)....',
// //系统自带
// 'decimal' : '' , //'1,2,3...'
// 'lower-alpha' : '' , // 'a,b,c...'
// 'lower-roman' : '' , //'i,ii,iii...'
// 'upper-alpha' : '' , lang //'A,B,C'
// 'upper-roman' : '' //'I,II,III...'
//}
//insertunorderedlist
//无序列表的下拉配置，值留空时支持多语言自动识别，若配置值，则以此值为准
//,insertunorderedlist : { //自定的样式
// 'dash' :'— 破折号', //-破折号
// 'dot':' 。 小圆圈', //系统自带
// 'circle' : '', // '○ 小圆圈'
// 'disc' : '', // '● 小圆点'
// 'square' : '' //'■ 小方块'
//}
//,listDefaultPaddingLeft : '30'//默认的左边缩进的基数倍
//,listiconpath : 'http://bs.baidu.com/listicon/'//自定义标号的路径
//,maxListLevel : 3 //限制可以tab的级数, 设置-1为不限制
//,autoTransWordToList:false //禁止word中粘贴进来的列表自动变成列表标签
//fontfamily
//字体设置 label留空支持多语言自动切换，若配置，则以配置值为准
//,'fontfamily':[
// { label:'',name:'songti',val:'宋体,SimSun'},
// { label:'',name:'kaiti',val:'楷体,楷体_GB2312, SimKai'},
// { label:'',name:'yahei',val:'微软雅黑,Microsoft YaHei'},
// { label:'',name:'heiti',val:'黑体, SimHei'},
// { label:'',name:'lishu',val:'隶书, SimLi'},
// { label:'',name:'andaleMono',val:'andale mono'},
// { label:'',name:'arial',val:'arial, helvetica,sans-serif'},
// { label:'',name:'arialBlack',val:'arial black,avant garde'},
// { label:'',name:'comicSansMs',val:'comic sans ms'},
// { label:'',name:'impact',val:'impact,chicago'},
// { label:'',name:'timesNewRoman',val:'times new roman'}
//]
//fontsize
//字号
//,'fontsize':[10, 11, 12, 14, 16, 18, 20, 24, 36]
//paragraph
//段落格式 值留空时支持多语言自动识别，若配置，则以配置值为准
//,'paragraph':{'p':'', 'h1':'', 'h2':'', 'h3':'', 'h4':'', 'h5':'', 'h6':''}
//rowspacingtop
//段间距 值和显示的名字相同
//,'rowspacingtop':['5', '10', '15', '20', '25']
//rowspacingBottom
//段间距 值和显示的名字相同
//,'rowspacingbottom':['5', '10', '15', '20', '25']
//lineheight
//行内间距 值和显示的名字相同
//,'lineheight':['1', '1.5','1.75','2', '3', '4', '5']
//customstyle
//自定义样式，不支持国际化，此处配置值即可最后显示值
//block的元素是依据设置段落的逻辑设置的，inline的元素依据BIU的逻辑设置
//尽量使用一些常用的标签
//参数说明
//tag 使用的标签名字
//label 显示的名字也是用来标识不同类型的标识符，注意这个值每个要不同，
//style 添加的样式
//每一个对象就是一个自定义的样式
//,'customstyle':[
// {tag:'h1', name:'tc', label:'', style:'border-bottom:#ccc 2px solid;padding:0 4px 0 0;text-align:center;margin:0 0 20px 0;'},
// {tag:'h1', name:'tl',label:'', style:'border-bottom:#ccc 2px solid;padding:0 4px 0 0;margin:0 0 10px 0;'},
// {tag:'span',name:'im', label:'', style:'font-style:italic;font-weight:bold'},
// {tag:'span',name:'hi', label:'', style:'font-style:italic;font-weight:bold;color:rgb(51, 153, 204)'}
//]
//打开右键菜单功能
//,enableContextMenu: true
//右键菜单的内容，可以参考plugins/contextmenu.js里边的默认菜单的例子，label留空支持国际化，否则以此配置为准
//,contextMenu:[
// {
// label:'', //显示的名称
// cmdName:'selectall',//执行的command命令，当点击这个右键菜单时
// //exec可选，有了exec就会在点击时执行这个function，优先级高于cmdName
// exec:function () {
// //this是当前编辑器的实例
// //this.ui._dialogs['inserttableDialog'].open();
// }
// }
//]
//快捷菜单
//,shortcutMenu:["fontfamily", "fontsize", "bold", "italic", "underline", "forecolor", "backcolor", "insertorderedlist", "insertunorderedlist"]
//elementPathEnabled
//是否启用元素路径，默认是显示
//,elementPathEnabled : true
//wordCount
//,wordCount:true //是否开启字数统计
//,maximumWords:10000 //允许的最大字符数
//字数统计提示，{#count}代表当前字数，{#leave}代表还可以输入多少字符数,留空支持多语言自动切换，否则按此配置显示
//,wordCountMsg:'' //当前已输入 {#count} 个字符，您还可以输入{#leave} 个字符
//超出字数限制提示 留空支持多语言自动切换，否则按此配置显示
//,wordOverFlowMsg:'' //<span style="color:red;">你输入的字符个数已经超出最大允许值，服务器可能会拒绝保存！</span>
//tab
//点击tab键时移动的距离,tabSize倍数，tabNode什么字符做为单位
//,tabSize:4
//,tabNode:' '
//removeFormat
//清除格式时可以删除的标签和属性
//removeForamtTags标签
//,removeFormatTags:'b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var'
//removeFormatAttributes属性
//,removeFormatAttributes:'class,style,lang,width,height,align,hspace,valign'
//undo
//可以最多回退的次数,默认20
//,maxUndoCount:20
//当输入的字符数超过该值时，保存一次现场
//,maxInputCount:1
//autoHeightEnabled
// 是否自动长高,默认true
//,autoHeightEnabled:true
//scaleEnabled
//是否可以拉伸长高,默认true(当开启时，自动长高失效)
//,scaleEnabled:false
//,minFrameWidth:800 //编辑器拖动时最小宽度,默认800
//,minFrameHeight:220 //编辑器拖动时最小高度,默认220
//autoFloatEnabled
//是否保持toolbar的位置不动,默认true
//,autoFloatEnabled:true
//浮动时工具栏距离浏览器顶部的高度，用于某些具有固定头部的页面
//,topOffset:30
//编辑器底部距离工具栏高度(如果参数大于等于编辑器高度，则设置无效)
//,toolbarTopOffset:400
//设置远程图片是否抓取到本地保存
//,catchRemoteImageEnable: true //设置是否抓取远程图片
//pageBreakTag
//分页标识符,默认是_ueditor_page_break_tag_
//,pageBreakTag:'_ueditor_page_break_tag_'
//autotypeset
//自动排版参数
//,autotypeset: {
// mergeEmptyline: true, //合并空行
// removeClass: true, //去掉冗余的class
// removeEmptyline: false, //去掉空行
// textAlign:"left", //段落的排版方式，可以是 left,right,center,justify 去掉这个属性表示不执行排版
// imageBlockLine: 'center', //图片的浮动方式，独占一行剧中,左右浮动，默认: center,left,right,none 去掉这个属性表示不执行排版
// pasteFilter: false, //根据规则过滤没事粘贴进来的内容
// clearFontSize: false, //去掉所有的内嵌字号，使用编辑器默认的字号
// clearFontFamily: false, //去掉所有的内嵌字体，使用编辑器默认的字体
// removeEmptyNode: false, // 去掉空节点
// //可以去掉的标签
// removeTagNames: {标签名字:1},
// indent: false, // 行首缩进
// indentValue : '2em', //行首缩进的大小
// bdc2sb: false,
// tobdc: false
//}
//tableDragable
//表格是否可以拖拽
//,tableDragable: true
//sourceEditor
//源码的查看方式,codemirror 是代码高亮，textarea是文本框,默认是codemirror
//注意默认codemirror只能在ie8+和非ie中使用
//,sourceEditor:"codemirror"
//如果sourceEditor是codemirror，还用配置一下两个参数
//codeMirrorJsUrl js加载的路径，默认是 URL + "third-party/codemirror/codemirror.js"
//,codeMirrorJsUrl:URL + "third-party/codemirror/codemirror.js"
//codeMirrorCssUrl css加载的路径，默认是 URL + "third-party/codemirror/codemirror.css"
//,codeMirrorCssUrl:URL + "third-party/codemirror/codemirror.css"
//编辑器初始化完成后是否进入源码模式，默认为否。
//,sourceEditorFirst:false
//iframeUrlMap
//dialog内容的路径 ～会被替换成URL,垓属性一旦打开，将覆盖所有的dialog的默认路径
//,iframeUrlMap:{
// 'anchor':'~/dialogs/anchor/anchor.html',
//}
//allowLinkProtocol 允许的链接地址，有这些前缀的链接地址不会自动添加http
//, allowLinkProtocols: ['http:', 'https:', '#', '/', 'ftp:', 'mailto:', 'tel:', 'git:', 'svn:']
//webAppKey 百度应用的APIkey，每个站长必须首先去百度官网注册一个key后方能正常使用app功能，注册介绍，http://app.baidu.com/static/cms/getapikey.html
//, webAppKey: ""
//默认过滤规则相关配置项目
//,disabledTableInTable:true //禁止表格嵌套
//,allowDivTransToP:true //允许进入编辑器的div标签自动变成p标签
//,rgb2Hex:true //默认产出的数据中的color自动从rgb格式变成16进制格式
// xss 过滤是否开启,inserthtml等操作
,xssFilterRules: true
//input xss过滤
,inputXssFilter: true
//output xss过滤
,outputXssFilter: true
// xss过滤白名单 名单来源: https://raw.githubusercontent.com/leizongmin/js-xss/master/lib/default.js
,whitList: {
a: ['target', 'href', 'title', 'class', 'style'],
abbr: ['title', 'class', 'style'],
address: ['class', 'style'],
area: ['shape', 'coords', 'href', 'alt'],
article: [],
aside: [],
audio: ['autoplay', 'controls', 'loop', 'preload', 'src', 'class', 'style'],
b: ['class', 'style'],
bdi: ['dir'],
bdo: ['dir'],
big: [],
blockquote: ['cite', 'class', 'style'],
br: [],
caption: ['class', 'style'],
center: [],
cite: [],
code: ['class', 'style'],
col: ['align', 'valign', 'span', 'width', 'class', 'style'],
colgroup: ['align', 'valign', 'span', 'width', 'class', 'style'],
dd: ['class', 'style'],
del: ['datetime'],
details: ['open'],
div: ['class', 'style'],
dl: ['class', 'style'],
dt: ['class', 'style'],
em: ['class', 'style'],
font: ['color', 'size', 'face'],
footer: [],
h1: ['class', 'style'],
h2: ['class', 'style'],
h3: ['class', 'style'],
h4: ['class', 'style'],
h5: ['class', 'style'],
h6: ['class', 'style'],
header: [],
hr: [],
i: ['class', 'style'],
img: ['src', 'alt', 'title', 'width', 'height', 'id', '_src', 'loadingclass', 'class', 'data-latex'],
ins: ['datetime'],
li: ['class', 'style'],
mark: [],
nav: [],
ol: ['class', 'style'],
p: ['class', 'style'],
pre: ['class', 'style'],
s: [],
section:[],
small: [],
span: ['class', 'style'],
sub: ['class', 'style'],
sup: ['class', 'style'],
strong: ['class', 'style'],
table: ['width', 'border', 'align', 'valign', 'class', 'style'],
tbody: ['align', 'valign', 'class', 'style'],
td: ['width', 'rowspan', 'colspan', 'align', 'valign', 'class', 'style'],
tfoot: ['align', 'valign', 'class', 'style'],
th: ['width', 'rowspan', 'colspan', 'align', 'valign', 'class', 'style'],
thead: ['align', 'valign', 'class', 'style'],
tr: ['rowspan', 'align', 'valign', 'class', 'style'],
tt: [],
u: [],
ul: ['class', 'style'],
video: ['autoplay', 'controls', 'loop', 'preload', 'src', 'height', 'width', 'class', 'style']
}
};
function getUEBasePath(docUrl, confUrl) {
return getBasePath(docUrl || self.document.URL || self.location.href, confUrl || getConfigFilePath());
}
function getConfigFilePath() {
var configPath = document.getElementsByTagName('script');
return configPath[ configPath.length - 1 ].src;
}
function getBasePath(docUrl, confUrl) {
var basePath = confUrl;
if (/^(\/|\\\\)/.test(confUrl)) {
basePath = /^.+?\w(\/|\\\\)/.exec(docUrl)[0] + confUrl.replace(/^(\/|\\\\)/, '');
} else if (!/^[a-z]+:/i.test(confUrl)) {
docUrl = docUrl.split("#")[0].split("?")[0].replace(/[^\\\/]+$/, '');
basePath = docUrl + "" + confUrl;
}
return optimizationPath(basePath);
}
function optimizationPath(path) {
var protocol = /^[a-z]+:\/\//.exec(path)[ 0 ],
tmp = null,
res = [];
path = path.replace(protocol, "").split("?")[0].split("#")[0];
path = path.replace(/\\/g, '/').split(/\//);
path[ path.length - 1 ] = "";
while (path.length) {
if (( tmp = path.shift() ) === "..") {
res.pop();
} else if (tmp !== ".") {
res.push(tmp);
}
}
return protocol + res.join("/");
}
window.UE = {
getUEBasePath: getUEBasePath
};
})();
|
mnzero/Sdut-jsj-OA
|
src/main/webapp/plugins/UEditor/ueditor.config.js
|
JavaScript
|
apache-2.0
| 23,150
|
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="AppNexusLiveDataFixture.cs" company="Rare Crowds Inc">
// Copyright 2012-2013 Rare Crowds, Inc.
//
// 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.
// </copyright>
// --------------------------------------------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Globalization;
using System.IO;
using Activities;
using ActivityTestUtilities;
using DataAccessLayer;
using Diagnostics;
using DynamicAllocation;
using DynamicAllocationTestUtilities;
using EntityUtilities;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using ReportingActivities;
using ReportingUtilities;
using Rhino.Mocks;
using SimulatedDataStore;
using TestUtilities;
namespace ReportingActivitiesIntegrationTests
{
/// <summary>Test fixture for Reallocation reporting</summary>
[TestClass]
public class AppNexusLiveDataFixture
{
/// <summary>DA campaign stub for testing.</summary>
private static readonly DynamicAllocationCampaignTestStub campaignStub = new DynamicAllocationCampaignTestStub();
/// <summary>Default repository for testing.</summary>
private IEntityRepository repository;
/// <summary>activity request for testing.</summary>
private ActivityRequest request;
/// <summary>One time class initialization</summary>
/// <param name="context">The context.</param>
[ClassInitialize]
public static void InitializeClass(TestContext context)
{
LogManager.Initialize(new[] { MockRepository.GenerateMock<ILogger>() });
// Force Azure emulated storage to start. DSService can still be running
// but the emulated storage not available. The most reliable way to make sure
// it's running and available is to stop it then start again.
var emulatorRunnerPath = ConfigurationManager.AppSettings["AzureEmulatorExe"];
AzureEmulatorHelper.StopStorageEmulator(emulatorRunnerPath);
AzureEmulatorHelper.StartStorageEmulator(emulatorRunnerPath);
AllocationParametersDefaults.Initialize();
MeasureSourceFactory.Initialize(new IMeasureSourceProvider[]
{
new AppNexusActivities.Measures.AppNexusLegacyMeasureSourceProvider(),
new AppNexusActivities.Measures.AppNexusMeasureSourceProvider(),
new GoogleDfpActivities.Measures.DfpMeasureSourceProvider()
});
}
/// <summary>Per test initialization.</summary>
[TestInitialize]
public void InitializeTest()
{
this.repository = new SimulatedEntityRepository(
ConfigurationManager.AppSettings["IndexLocal.ConnectionString"],
ConfigurationManager.AppSettings["EntityLocal.ConnectionString"],
ConfigurationManager.AppSettings["IndexReadOnly.ConnectionString"],
ConfigurationManager.AppSettings["EntityReadOnly.ConnectionString"]);
this.request = new ActivityRequest
{
Values =
{
{ EntityActivityValues.AuthUserId, "user123" },
}
};
}
/// <summary>Generate a report from a test campaign.</summary>
[TestMethod]
[Ignore]
public void CreateReportFromTestLegacyCampaign()
{
// For this test want a local emulated store
var localRepository = ((SimulatedEntityRepository)this.repository).LocalRepository;
// Set up the test data for a legacy campaign
var companyEntityId = new EntityId();
var campaignEntityId = new EntityId();
SetupLegacyTestCampaign(localRepository, companyEntityId, campaignEntityId);
// Set up our activity with a local store
var activity = Activity.CreateActivity(
typeof(CreateCampaignReportActivity),
new Dictionary<Type, object> { { typeof(IEntityRepository), localRepository } },
ActivityTestHelpers.SubmitActivityRequest) as CreateCampaignReportActivity;
this.request.Values[EntityActivityValues.CompanyEntityId] = companyEntityId;
this.request.Values[EntityActivityValues.CampaignEntityId] = campaignEntityId;
this.request.Values[ReportingActivityValues.VerboseReport] = string.Empty;
this.request.Values[ReportingActivityValues.SaveLegacyConversion] = string.Empty;
this.request.Values[ReportingActivityValues.ReportType] = ReportTypes.ClientCampaignBilling;
var result = activity.Run(this.request);
// Assert activity completed successfully
ActivityTestHelpers.AssertValidSuccessResult(result);
// Assert all the data in the chain to the generated report is present
var context = new RequestContext { ExternalCompanyId = companyEntityId };
var reportEntity = ActivityIntegrationTestsFixture.GetReportFromCampaign(
this.repository, context, campaignEntityId, ReportTypes.ClientCampaignBilling);
Assert.IsFalse(string.IsNullOrEmpty(reportEntity.ReportData));
}
/// <summary>Generate a report from an existing legacy campaign.</summary>
[TestMethod]
[Ignore]
public void CreateReportFromExistingLegacyCampaign()
{
////new EntityId("f771702d-9aaa-41c7-8488-41fc73972512"),
////new EntityId("70a15d8d-f7f4-4bbd-982f-cf8e3b481c74"),
////new EntityId("eebac3d2-5f33-4d82-816f-baaa6afc4353"),
////new EntityId("f7f75529-3cc7-4df1-baa3-e850fde22669"),
////new EntityId("59027117-6b6d-495a-97c7-b9d487f714a8"),
////new EntityId("61b57beb-883f-4d49-915e-5a5d324b644a")
////new EntityId("f6102ce1-4880-4366-970f-ccfc2fcba093"),
////new EntityId("83cd1ba3-a2e0-4bcc-b0cc-8aae42077c87"),
////new EntityId("8b9a3f92-cb1d-4f5d-bd5e-24ac951d0538"),
////new EntityId("11720b77-abdb-4bc3-936e-e6d84dee93a6"),
var companyId = new EntityId("360b1a09-6a66-4dc2-898e-4a370e4079d0");
var campaignId = new EntityId("11720b77-abdb-4bc3-936e-e6d84dee93a6");
// Touch the company to pull it down
var context = new RequestContext { ExternalCompanyId = companyId };
this.repository.GetEntity(context, companyId);
// Set up our activity the SimulatedEntityRepository.
// This will read from whatever source is configured for the read repository.
var activity = Activity.CreateActivity(
typeof(CreateCampaignReportActivity),
new Dictionary<Type, object> { { typeof(IEntityRepository), this.repository } },
ActivityTestHelpers.SubmitActivityRequest) as CreateCampaignReportActivity;
this.request.Values[EntityActivityValues.CompanyEntityId] = companyId;
this.request.Values[EntityActivityValues.CampaignEntityId] = campaignId;
this.request.Values[ReportingActivityValues.VerboseReport] = string.Empty;
this.request.Values[ReportingActivityValues.SaveLegacyConversion] = string.Empty;
// Generate campaign billing report
this.request.Values[ReportingActivityValues.ReportType] = ReportTypes.ClientCampaignBilling;
var result = activity.Run(this.request);
ActivityTestHelpers.AssertValidSuccessResult(result);
var reportEntity = ActivityIntegrationTestsFixture.GetReportFromCampaign(
this.repository, context, campaignId, ReportTypes.ClientCampaignBilling);
Assert.IsFalse(string.IsNullOrEmpty(reportEntity.ReportData));
WriteReport(@"C:\ReportFiles", ReportTypes.ClientCampaignBilling, campaignId, reportEntity.ReportData, reportEntity.LastModifiedDate);
// Generate data provider billing report
this.request.Values[ReportingActivityValues.ReportType] = ReportTypes.ClientCampaignBilling;
result = activity.Run(this.request);
reportEntity = ActivityIntegrationTestsFixture.GetReportFromCampaign(
this.repository, context, campaignId, ReportTypes.ClientCampaignBilling);
Assert.IsFalse(string.IsNullOrEmpty(reportEntity.ReportData));
WriteReport(@"C:\ReportFiles", ReportTypes.DataProviderBilling, campaignId, reportEntity.ReportData, reportEntity.LastModifiedDate);
}
/// <summary>Write a report to a csv file.</summary>
/// <param name="path">Directory to write report.</param>
/// <param name="reportType">The report type.</param>
/// <param name="campaignId">The campaign entity id.</param>
/// <param name="report">The report string.</param>
/// <param name="reportDate">The report date.</param>
private static void WriteReport(string path, string reportType, EntityId campaignId, string report, DateTime reportDate)
{
var reportDay = reportDate.ToString("yyyy_MM_dd", CultureInfo.InvariantCulture);
var reportTime = reportDate.ToString("HH_mm", CultureInfo.InvariantCulture);
var reportFile = @"{0}_{1}_{2}_{3}.csv".FormatInvariant(
reportType, campaignId, reportDay, reportTime);
var fullPath = Path.Combine(Path.GetFullPath(path), reportFile);
File.WriteAllText(fullPath, report);
}
/// <summary>Stubbed wrapper for legacy campaign setup.</summary>
/// <param name="repository">The entity Repository.</param>
/// <param name="companyEntityId">The company entity id.</param>
/// <param name="campaignEntityId">The campaign entity id.</param>
private static void SetupLegacyTestCampaign(
IEntityRepository repository, EntityId companyEntityId, EntityId campaignEntityId)
{
// TODO: This is just stubbed for now until we determine if we need to preserve this scenario.
Assert.IsNotNull(campaignEntityId);
Assert.IsNotNull(repository);
Assert.IsNotNull(companyEntityId);
////LegacyCampaignHelpers.SetupLegacyCampaign(localRepository, companyEntityId, campaignEntityId, campaignOwnerId);
}
}
}
|
chinnurtb/OpenAdStack-1
|
Reporting/ReportingActivitiesIntegrationTests/AppNexusLiveDataFixture.cs
|
C#
|
apache-2.0
| 11,337
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.